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) }