func ExampleAutoScaling_DetachInstances() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := autoscaling.New(sess)
params := &autoscaling.DetachInstancesInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
ShouldDecrementDesiredCapacity: aws.Bool(true), // Required
InstanceIds: []*string{
aws.String("XmlStringMaxLen19"), // Required
// More values...
},
}
resp, err := svc.DetachInstances(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleAutoScaling_PutLifecycleHook() {
svc := autoscaling.New(session.New())
params := &autoscaling.PutLifecycleHookInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
LifecycleHookName: aws.String("AsciiStringMaxLen255"), // Required
DefaultResult: aws.String("LifecycleActionResult"),
HeartbeatTimeout: aws.Int64(1),
LifecycleTransition: aws.String("LifecycleTransition"),
NotificationMetadata: aws.String("XmlStringMaxLen1023"),
NotificationTargetARN: aws.String("ResourceName"),
RoleARN: aws.String("ResourceName"),
}
resp, err := svc.PutLifecycleHook(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleAutoScaling_PutScheduledUpdateGroupAction() {
svc := autoscaling.New(session.New())
params := &autoscaling.PutScheduledUpdateGroupActionInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
ScheduledActionName: aws.String("XmlStringMaxLen255"), // Required
DesiredCapacity: aws.Int64(1),
EndTime: aws.Time(time.Now()),
MaxSize: aws.Int64(1),
MinSize: aws.Int64(1),
Recurrence: aws.String("XmlStringMaxLen255"),
StartTime: aws.Time(time.Now()),
Time: aws.Time(time.Now()),
}
resp, err := svc.PutScheduledUpdateGroupAction(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleAutoScaling_UpdateAutoScalingGroup() {
svc := autoscaling.New(session.New())
params := &autoscaling.UpdateAutoScalingGroupInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
AvailabilityZones: []*string{
aws.String("XmlStringMaxLen255"), // Required
// More values...
},
DefaultCooldown: aws.Int64(1),
DesiredCapacity: aws.Int64(1),
HealthCheckGracePeriod: aws.Int64(1),
HealthCheckType: aws.String("XmlStringMaxLen32"),
LaunchConfigurationName: aws.String("ResourceName"),
MaxSize: aws.Int64(1),
MinSize: aws.Int64(1),
PlacementGroup: aws.String("XmlStringMaxLen255"),
TerminationPolicies: []*string{
aws.String("XmlStringMaxLen1600"), // Required
// More values...
},
VPCZoneIdentifier: aws.String("XmlStringMaxLen255"),
}
resp, err := svc.UpdateAutoScalingGroup(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleAutoScaling_DescribeScheduledActions() {
svc := autoscaling.New(session.New())
params := &autoscaling.DescribeScheduledActionsInput{
AutoScalingGroupName: aws.String("ResourceName"),
EndTime: aws.Time(time.Now()),
MaxRecords: aws.Int64(1),
NextToken: aws.String("XmlString"),
ScheduledActionNames: []*string{
aws.String("ResourceName"), // Required
// More values...
},
StartTime: aws.Time(time.Now()),
}
resp, err := svc.DescribeScheduledActions(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleAutoScaling_DetachInstances() {
svc := autoscaling.New(nil)
params := &autoscaling.DetachInstancesInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
ShouldDecrementDesiredCapacity: aws.Boolean(true), // Required
InstanceIDs: []*string{
aws.String("XmlStringMaxLen16"), // Required
// More values...
},
}
resp, err := svc.DetachInstances(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
// Private function without the confirmation terminal prompts
func deleteAutoScaleGroups(asgList *AutoScaleGroups, force, dryRun bool) (err error) {
for _, asg := range *asgList {
svc := autoscaling.New(session.New(&aws.Config{Region: aws.String(asg.Region)}))
params := &autoscaling.DeleteAutoScalingGroupInput{
AutoScalingGroupName: aws.String(asg.Name),
ForceDelete: aws.Bool(force),
}
// Delete it!
if !dryRun {
_, err := svc.DeleteAutoScalingGroup(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
return errors.New(awsErr.Message())
}
return err
}
terminal.Information("Deleted AutoScaling Group [" + asg.Name + "] in [" + asg.Region + "]!")
} else {
fmt.Println(params)
}
}
return nil
}
// Returns all instances that are in autoscaling groups within the given region
// if a autoscaling group name is specified then only the instances within that group are returned
func getAutoScalingInstances() []*autoscaling.InstanceDetails {
instances := make([]*autoscaling.InstanceDetails, 0, 50)
var token *string
var resp *autoscaling.DescribeAutoScalingInstancesOutput
var err error
svc := autoscaling.New(session.New(), &aws.Config{Region: aws.String(flag_region)})
// DescribeAutoscalinginstances() only returns 50 instances a time so...
// keep calling for more until all have been retrieved
for {
params := &autoscaling.DescribeAutoScalingInstancesInput{
NextToken: token,
}
resp, err = svc.DescribeAutoScalingInstances(params)
if err != nil {
fmt.Println(err.Error())
return nil
}
instances = append(instances, resp.AutoScalingInstances...)
token = resp.NextToken
// no more instances to get. We done hehr
if token == nil {
break
}
}
if flag_asgName == "" {
return instances
}
return filterByASGName(instances)
}
func ExampleAutoScaling_DescribePolicies() {
svc := autoscaling.New(nil)
params := &autoscaling.DescribePoliciesInput{
AutoScalingGroupName: aws.String("ResourceName"),
MaxRecords: aws.Int64(1),
NextToken: aws.String("XmlString"),
PolicyNames: []*string{
aws.String("ResourceName"), // Required
// More values...
},
PolicyTypes: []*string{
aws.String("XmlStringMaxLen64"), // Required
// More values...
},
}
resp, err := svc.DescribePolicies(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
// getAutoScalingName tries to get autoscaling name from system, first gets from
// config var, if not set then tries ec2dynamicdata service
func getAutoScalingName(conf *Config, session *awssession.Session) (string, error) {
if conf.AutoScalingName != "" {
return conf.AutoScalingName, nil
}
info, err := ec2dynamicdata.Get()
if err != nil {
return "", fmt.Errorf("couldn't get info. Err: %s", err.Error())
}
instanceID := info.InstanceID
asg := autoscaling.New(session)
resp, err := asg.DescribeAutoScalingInstances(
&autoscaling.DescribeAutoScalingInstancesInput{
InstanceIds: []*string{
aws.String(instanceID),
},
},
)
if err != nil {
return "", err
}
for _, instance := range resp.AutoScalingInstances {
if *instance.InstanceId == instanceID {
return *instance.AutoScalingGroupName, nil
}
}
return "", errors.New("couldn't find autoscaling name")
}
func main() {
kingpin.Parse()
me := ec2metadata.New(session.New(), &aws.Config{})
region, err := me.Region()
if err != nil {
fmt.Println(err)
os.Exit(1)
}
cw := cloudwatch.New(session.New(&aws.Config{Region: aws.String(region)}))
as := autoscaling.New(session.New(&aws.Config{Region: aws.String(region)}))
// Get the name of this instance.
instance, err := me.GetMetadata("instance-id")
if err != nil {
fmt.Println(err)
os.Exit(1)
}
log.Printf("Instance: %s", instance)
// Check if this instance is in an auto scaling group.
gps, err := as.DescribeAutoScalingInstances(&autoscaling.DescribeAutoScalingInstancesInput{
InstanceIds: []*string{
aws.String(instance),
},
})
if err == nil && len(gps.AutoScalingInstances) > 0 {
group = *gps.AutoScalingInstances[0].AutoScalingGroupName
log.Printf("AutoScaling group: %s", group)
}
// Loop and send to the backend.
limiter := time.Tick(time.Second * 60)
for {
<-limiter
// Submit all the values.
for _, mn := range strings.Split(*cliMetrics, ",") {
m, err := metric.New(mn)
if err != nil {
log.Printf("Cannot find metric: %s" + mn)
continue
}
v, err := m.Value()
if err != nil {
log.Println("Cannot get metric.")
}
// Send the instance metrics.
Send(cw, "InstanceId", instance, m.Name(), v)
// Send the autoscaling.
if group != "" {
Send(cw, "AutoScalingGroupName", group, m.Name(), v)
}
}
}
}
func ExampleAutoScaling_DescribeAutoScalingInstances() {
svc := autoscaling.New(nil)
params := &autoscaling.DescribeAutoScalingInstancesInput{
InstanceIDs: []*string{
aws.String("XmlStringMaxLen16"), // Required
// More values...
},
MaxRecords: aws.Long(1),
NextToken: aws.String("XmlString"),
}
resp, err := svc.DescribeAutoScalingInstances(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleAutoScaling_DeleteScheduledAction() {
svc := autoscaling.New(nil)
params := &autoscaling.DeleteScheduledActionInput{
ScheduledActionName: aws.String("ResourceName"), // Required
AutoScalingGroupName: aws.String("ResourceName"),
}
resp, err := svc.DeleteScheduledAction(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
// GetLaunchConfigurationsByName returns a slice of Launch Configurations for a given region and name
func GetLaunchConfigurationsByName(region, name string) (LaunchConfigs, error) {
svc := autoscaling.New(session.New(&aws.Config{Region: aws.String(region)}))
params := &autoscaling.DescribeLaunchConfigurationsInput{
LaunchConfigurationNames: []*string{
aws.String(name),
},
}
result, err := svc.DescribeLaunchConfigurations(params)
if err != nil || len(result.LaunchConfigurations) == 0 {
return LaunchConfigs{}, err
}
secGrpList := new(SecurityGroups)
err = GetRegionSecurityGroups(region, secGrpList, "")
imgList := new(Images)
GetRegionImages(region, imgList, "", false)
lcList := make(LaunchConfigs, len(result.LaunchConfigurations))
for i, config := range result.LaunchConfigurations {
lcList[i].Marshal(config, region, secGrpList, imgList)
}
if len(lcList) == 0 {
return lcList, errors.New("No Launch Configurations found with name of [" + name + "] in [" + region + "].")
}
return lcList, err
}
func ExampleAutoScaling_CompleteLifecycleAction() {
svc := autoscaling.New(nil)
params := &autoscaling.CompleteLifecycleActionInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
LifecycleActionResult: aws.String("LifecycleActionResult"), // Required
LifecycleActionToken: aws.String("LifecycleActionToken"), // Required
LifecycleHookName: aws.String("AsciiStringMaxLen255"), // Required
}
resp, err := svc.CompleteLifecycleAction(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleAutoScaling_PutLifecycleHook() {
svc := autoscaling.New(nil)
params := &autoscaling.PutLifecycleHookInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
LifecycleHookName: aws.String("AsciiStringMaxLen255"), // Required
DefaultResult: aws.String("LifecycleActionResult"),
HeartbeatTimeout: aws.Long(1),
LifecycleTransition: aws.String("LifecycleTransition"),
NotificationMetadata: aws.String("XmlStringMaxLen1023"),
NotificationTargetARN: aws.String("ResourceName"),
RoleARN: aws.String("ResourceName"),
}
resp, err := svc.PutLifecycleHook(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleAutoScaling_DescribeScheduledActions() {
svc := autoscaling.New(nil)
params := &autoscaling.DescribeScheduledActionsInput{
AutoScalingGroupName: aws.String("ResourceName"),
EndTime: aws.Time(time.Now()),
MaxRecords: aws.Long(1),
NextToken: aws.String("XmlString"),
ScheduledActionNames: []*string{
aws.String("ResourceName"), // Required
// More values...
},
StartTime: aws.Time(time.Now()),
}
resp, err := svc.DescribeScheduledActions(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleAutoScaling_PutNotificationConfiguration() {
svc := autoscaling.New(nil)
params := &autoscaling.PutNotificationConfigurationInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
NotificationTypes: []*string{ // Required
aws.String("XmlStringMaxLen255"), // Required
// More values...
},
TopicARN: aws.String("ResourceName"), // Required
}
resp, err := svc.PutNotificationConfiguration(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
// LifecycleEventQueueURL inspects the current autoscaling group and returns
// the URL of the first suitable lifecycle hook queue.
func (s *Cluster) LifecycleEventQueueURL() (string, error) {
asg, err := s.AutoscalingGroup()
if err != nil {
return "", err
}
autoscalingSvc := autoscaling.New(s.AwsSession)
resp, err := autoscalingSvc.DescribeLifecycleHooks(&autoscaling.DescribeLifecycleHooksInput{
AutoScalingGroupName: asg.AutoScalingGroupName,
})
if err != nil {
return "", err
}
sqsSvc := sqs.New(s.AwsSession)
for _, hook := range resp.LifecycleHooks {
if !strings.HasPrefix(*hook.NotificationTargetARN, "arn:aws:sqs:") {
continue
}
arnParts := strings.Split(*hook.NotificationTargetARN, ":")
queueName := arnParts[len(arnParts)-1]
queueOwnerAWSAccountID := arnParts[len(arnParts)-2]
resp, err := sqsSvc.GetQueueUrl(&sqs.GetQueueUrlInput{
QueueName: &queueName,
QueueOwnerAWSAccountId: &queueOwnerAWSAccountID,
})
if err != nil {
return "", err
}
return *resp.QueueUrl, nil
}
return "", ErrLifecycleHookNotFound
}
func ExampleAutoScaling_PutScalingPolicy() {
svc := autoscaling.New(nil)
params := &autoscaling.PutScalingPolicyInput{
AdjustmentType: aws.String("XmlStringMaxLen255"), // Required
AutoScalingGroupName: aws.String("ResourceName"), // Required
PolicyName: aws.String("XmlStringMaxLen255"), // Required
Cooldown: aws.Long(1),
MinAdjustmentStep: aws.Long(1),
ScalingAdjustment: aws.Long(1),
}
resp, err := svc.PutScalingPolicy(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
// CreateAwsManager constructs awsManager object.
func CreateAwsManager(configReader io.Reader) (*AwsManager, error) {
if configReader != nil {
var cfg provider_aws.AWSCloudConfig
if err := gcfg.ReadInto(&cfg, configReader); err != nil {
glog.Errorf("Couldn't read config: %v", err)
return nil, err
}
}
service := autoscaling.New(session.New())
manager := &AwsManager{
asgs: make([]*asgInformation, 0),
service: service,
asgCache: make(map[AwsRef]*Asg),
}
go wait.Forever(func() {
manager.cacheMutex.Lock()
defer manager.cacheMutex.Unlock()
if err := manager.regenerateCache(); err != nil {
glog.Errorf("Error while regenerating Asg cache: %v", err)
}
}, time.Hour)
return manager, nil
}
func ExampleAutoScaling_PutScheduledUpdateGroupAction() {
svc := autoscaling.New(nil)
params := &autoscaling.PutScheduledUpdateGroupActionInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
ScheduledActionName: aws.String("XmlStringMaxLen255"), // Required
DesiredCapacity: aws.Long(1),
EndTime: aws.Time(time.Now()),
MaxSize: aws.Long(1),
MinSize: aws.Long(1),
Recurrence: aws.String("XmlStringMaxLen255"),
StartTime: aws.Time(time.Now()),
Time: aws.Time(time.Now()),
}
resp, err := svc.PutScheduledUpdateGroupAction(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleAutoScaling_DeleteTags() {
svc := autoscaling.New(session.New())
params := &autoscaling.DeleteTagsInput{
Tags: []*autoscaling.Tag{ // Required
{ // Required
Key: aws.String("TagKey"), // Required
PropagateAtLaunch: aws.Bool(true),
ResourceId: aws.String("XmlString"),
ResourceType: aws.String("XmlString"),
Value: aws.String("TagValue"),
},
// More values...
},
}
resp, err := svc.DeleteTags(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleAutoScaling_SetDesiredCapacity() {
svc := autoscaling.New(nil)
params := &autoscaling.SetDesiredCapacityInput{
AutoScalingGroupName: aws.String("ResourceName"), // Required
DesiredCapacity: aws.Long(1), // Required
HonorCooldown: aws.Boolean(true),
}
resp, err := svc.SetDesiredCapacity(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleAutoScaling_DescribeTags() {
svc := autoscaling.New(session.New())
params := &autoscaling.DescribeTagsInput{
Filters: []*autoscaling.Filter{
{ // Required
Name: aws.String("XmlString"),
Values: []*string{
aws.String("XmlString"), // Required
// More values...
},
},
// More values...
},
MaxRecords: aws.Int64(1),
NextToken: aws.String("XmlString"),
}
resp, err := svc.DescribeTags(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleAutoScaling_SetInstanceHealth() {
svc := autoscaling.New(nil)
params := &autoscaling.SetInstanceHealthInput{
HealthStatus: aws.String("XmlStringMaxLen32"), // Required
InstanceID: aws.String("XmlStringMaxLen16"), // Required
ShouldRespectGracePeriod: aws.Boolean(true),
}
resp, err := svc.SetInstanceHealth(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleAutoScaling_PutScalingPolicy() {
svc := autoscaling.New(session.New())
params := &autoscaling.PutScalingPolicyInput{
AdjustmentType: aws.String("XmlStringMaxLen255"), // Required
AutoScalingGroupName: aws.String("ResourceName"), // Required
PolicyName: aws.String("XmlStringMaxLen255"), // Required
Cooldown: aws.Int64(1),
EstimatedInstanceWarmup: aws.Int64(1),
MetricAggregationType: aws.String("XmlStringMaxLen32"),
MinAdjustmentMagnitude: aws.Int64(1),
MinAdjustmentStep: aws.Int64(1),
PolicyType: aws.String("XmlStringMaxLen64"),
ScalingAdjustment: aws.Int64(1),
StepAdjustments: []*autoscaling.StepAdjustment{
{ // Required
ScalingAdjustment: aws.Int64(1), // Required
MetricIntervalLowerBound: aws.Float64(1.0),
MetricIntervalUpperBound: aws.Float64(1.0),
},
// More values...
},
}
resp, err := svc.PutScalingPolicy(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleAutoScaling_DeleteTags() {
svc := autoscaling.New(nil)
params := &autoscaling.DeleteTagsInput{
Tags: []*autoscaling.Tag{ // Required
{ // Required
Key: aws.String("TagKey"), // Required
PropagateAtLaunch: aws.Boolean(true),
ResourceID: aws.String("XmlString"),
ResourceType: aws.String("XmlString"),
Value: aws.String("TagValue"),
},
// More values...
},
}
resp, err := svc.DeleteTags(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func GroupSize(group string) (int, error) {
if framework.TestContext.Provider == "gce" || framework.TestContext.Provider == "gke" {
// TODO: make this hit the compute API directly instead of shelling out to gcloud.
// TODO: make gce/gke implement InstanceGroups, so we can eliminate the per-provider logic
output, err := exec.Command("gcloud", "compute", "instance-groups", "managed",
"list-instances", group, "--project="+framework.TestContext.CloudConfig.ProjectID,
"--zone="+framework.TestContext.CloudConfig.Zone).CombinedOutput()
if err != nil {
return -1, err
}
re := regexp.MustCompile("RUNNING")
return len(re.FindAllString(string(output), -1)), nil
} else if framework.TestContext.Provider == "aws" {
client := autoscaling.New(session.New())
instanceGroup, err := awscloud.DescribeInstanceGroup(client, group)
if err != nil {
return -1, fmt.Errorf("error describing instance group: %v", err)
}
if instanceGroup == nil {
return -1, fmt.Errorf("instance group not found: %s", group)
}
return instanceGroup.CurrentSize()
} else {
return -1, fmt.Errorf("provider does not support InstanceGroups")
}
}
func ExampleAutoScaling_DescribeScalingActivities() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := autoscaling.New(sess)
params := &autoscaling.DescribeScalingActivitiesInput{
ActivityIds: []*string{
aws.String("XmlString"), // Required
// More values...
},
AutoScalingGroupName: aws.String("ResourceName"),
MaxRecords: aws.Int64(1),
NextToken: aws.String("XmlString"),
}
resp, err := svc.DescribeScalingActivities(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}