Esempio n. 1
0
// describeEc2Instances Describes EC2 instances by container istance ID
func describeEc2Instances(svc *ecs.ECS, cluster *string, containerInstances []*string) (*ec2.DescribeInstancesOutput, error) {

	params := &ecs.DescribeContainerInstancesInput{
		Cluster:            cluster,
		ContainerInstances: containerInstances,
	}
	ins, err := svc.DescribeContainerInstances(params)
	if err != nil {
		return nil, err
	}
	insfail := cli.Failure(ins.Failures, err)
	if insfail != nil {
		return nil, insfail
	}
	var ec2Instances = make([]*string, len(ins.ContainerInstances))
	for i, v := range ins.ContainerInstances {
		ec2Instances[i] = v.Ec2InstanceId
	}
	ec2client := ec2.New(sess.InitSession())
	ec2params := &ec2.DescribeInstancesInput{
		DryRun:      aws.Bool(false),
		InstanceIds: ec2Instances,
	}
	return ec2client.DescribeInstances(ec2params)
}
Esempio n. 2
0
// StartWait Starts a new task a waits until it started successfully.
func StartWait(svc *ecs.ECS, maxTries *int, timeout *int64, taskDef *string, containerInstances []*string, cluster *string, startedBy *string, overrides *ecs.TaskOverride) (*ecs.DescribeTasksOutput, error) {
	tries := 0
	counter := 0
	start, err := StartTask(
		svc,
		taskDef,
		containerInstances,
		cluster,
		startedBy,
		nil,
	)
	if err != nil {
		return nil, err
	}
	fail := cli.Failure(start.Failures, err)
	if fail != nil {
		return nil, fail
	}
	var tasks = make([]*string, len(start.Tasks))
	for i, v := range start.Tasks {
		tasks[i] = v.TaskArn
	}
	for {
		resp, err := DescribeTasks(
			svc,
			tasks,
			&cliClusterName,
		)
		descFail := cli.Failure(resp.Failures, err)
		if descFail != nil {
			return nil, descFail
		}
		for _, v := range resp.Tasks {
			if *v.LastStatus == *v.DesiredStatus {
				counter = counter + 1
			}
			tries = tries + 1
		}
		if counter >= len(resp.Tasks) {
			return resp, nil
		}
		if tries >= *maxTries {
			return resp, errors.New("Max tries (" + strconv.Itoa(*maxTries) + ") reached")
		}
		time.Sleep(time.Duration(*timeout) * time.Second)
	}
}
Esempio n. 3
0
func cliDescribeTasks(svc *ecs.ECS, args []string) ([]*string, error) {
	err := cliDescribeTasksParams(args).Parse(args)
	resp, err := DescribeTasks(
		svc,
		aws.StringSlice(strings.Split(cliTasks, ",")),
		&cliClusterName,
	)
	if err != nil {
		return nil, err
	}
	fail := cli.Failure(resp.Failures, err)
	if fail != nil {
		return nil, fail
	}
	var ret = make([]*string, len(resp.Tasks))
	for k := range resp.Tasks {
		ret[k] = resp.Tasks[k].TaskArn
	}
	return ret, err
}
Esempio n. 4
0
func cliStartTask(svc *ecs.ECS, args []string) ([]*string, error) {
	err := cliStartTaskParams(args).Parse(args)
	resp, err := StartTask(
		svc,
		&cliTaskDef,
		aws.StringSlice(strings.Split(cliContainerInstance, ",")),
		cli.String(cliClusterName),
		cli.String(cliStartedby),
		nil,
	)
	if err != nil {
		return nil, err
	}
	fail := cli.Failure(resp.Failures, err)
	if fail != nil {
		return nil, fail
	}
	var ret = make([]*string, len(resp.Tasks))
	for k := range resp.Tasks {
		ret[k] = resp.Tasks[k].TaskArn
	}
	return ret, nil
}
Esempio n. 5
0
func cliStartWait(svc *ecs.ECS, args []string) ([]*string, error) {
	err := cliStartWaitParams(args).Parse(args)
	containerInstances := aws.StringSlice(strings.Split(cliContainerInstance, ","))
	resp, err := StartWait(
		svc,
		&cliMaxTries,
		&cliTimeout,
		&cliTaskDef,
		containerInstances,
		cli.String(cliClusterName),
		cli.String(cliStartedby),
		nil,
	)
	if err != nil {
		return nil, err
	}
	fail := cli.Failure(resp.Failures, err)
	if fail != nil {
		return nil, fail
	}
	var ret = make([]*string, len(resp.Tasks))
	for k := range resp.Tasks {
		ret[k] = resp.Tasks[k].TaskArn
	}
	dns, dnserr := describeEc2Instances(svc, cli.String(cliClusterName), containerInstances)
	if dnserr != nil {
		return ret, dnserr
	}
	var result = make([]*string, len(ret)+len(dns.Reservations))
	copy(result, ret)
	for _, r := range dns.Reservations {
		for i, v := range r.Instances {
			result[len(ret)+i] = v.PublicDnsName
		}
	}
	return result, nil
}