func getAwsAutoscalingGroup(
	asgName string,
	conn *autoscaling.AutoScaling) (*autoscaling.Group, error) {

	describeOpts := autoscaling.DescribeAutoScalingGroupsInput{
		AutoScalingGroupNames: []*string{aws.String(asgName)},
	}

	log.Printf("[DEBUG] AutoScaling Group describe configuration: %#v", describeOpts)
	describeGroups, err := conn.DescribeAutoScalingGroups(&describeOpts)
	if err != nil {
		autoscalingerr, ok := err.(awserr.Error)
		if ok && autoscalingerr.Code() == "InvalidGroup.NotFound" {
			return nil, nil
		}

		return nil, fmt.Errorf("Error retrieving AutoScaling groups: %s", err)
	}

	// Search for the autoscaling group
	for idx, asc := range describeGroups.AutoScalingGroups {
		if *asc.AutoScalingGroupName == asgName {
			return describeGroups.AutoScalingGroups[idx], nil
		}
	}

	return nil, nil
}
Esempio n. 2
0
func terminateASG(api *autoscaling.AutoScaling, instance *autoscaling.Group, wg *sync.WaitGroup) error {
	defer wg.Done()

	// 1. set the number of instances to 0
	_, err := api.UpdateAutoScalingGroup(&autoscaling.UpdateAutoScalingGroupInput{
		AutoScalingGroupName: instance.AutoScalingGroupName,
		DesiredCapacity:      aws.Int64(0),
		MaxSize:              aws.Int64(0),
		MinSize:              aws.Int64(0),
	})
	if err != nil {
		return err
	}

	// 2. wait until the instance count is 0
	for {
		instances, err := api.DescribeAutoScalingGroups(&autoscaling.DescribeAutoScalingGroupsInput{
			AutoScalingGroupNames: []*string{instance.AutoScalingGroupName},
		})
		if err != nil {
			return err
		}

		// instance already deleted?  we're done
		if len(instances.AutoScalingGroups) == 0 {
			return nil
		}

		// no instances remaining in asg?  break
		if v := instances.AutoScalingGroups[0]; len(v.Instances) == 0 {
			break
		}

		time.Sleep(15 * time.Second)
	}

	// 3. terminate the asg
	log.Printf("deleting autoscaling group, %s\n", *instance.AutoScalingGroupName)
	_, err = api.DeleteAutoScalingGroup(&autoscaling.DeleteAutoScalingGroupInput{
		AutoScalingGroupName: instance.AutoScalingGroupName,
		ForceDelete:          aws.Bool(true),
	})
	if err != nil {
		return err
	}

	log.Printf("deleting launch configuration, %s\n", *instance.LaunchConfigurationName)
	_, err = api.DeleteLaunchConfiguration(&autoscaling.DeleteLaunchConfigurationInput{
		LaunchConfigurationName: instance.LaunchConfigurationName,
	})
	if err != nil {
		return err
	}

	return nil
}
Esempio n. 3
0
func findASGInstancesToTerminate(api *autoscaling.AutoScaling, opts Options) ([]*autoscaling.Group, error) {
	groups, err := api.DescribeAutoScalingGroups(&autoscaling.DescribeAutoScalingGroupsInput{})
	if err != nil {
		return nil, err
	}

	instances := []*autoscaling.Group{}
	for _, asg := range groups.AutoScalingGroups {
		if !hasASGTags(asg, "app", opts.App) {
			continue
		}
		if !hasASGTags(asg, "env", opts.Env) {
			continue
		}
		if hasASGTags(asg, "version", opts.Exclude) {
			continue
		}

		instances = append(instances, asg)
	}

	return instances, nil
}