Golang ElasticBeanstalk.DescribeEnvironments方法代码示例

// environmentStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
// the creation of the Beanstalk Environment
func environmentStateRefreshFunc(conn *elasticbeanstalk.ElasticBeanstalk, environmentId string) resource.StateRefreshFunc {
	return func() (interface{}, string, error) {
		resp, err := conn.DescribeEnvironments(&elasticbeanstalk.DescribeEnvironmentsInput{
			EnvironmentIds: []*string{aws.String(environmentId)},
		})
		if err != nil {
			log.Printf("[Err] Error waiting for Elastic Beanstalk Environment state: %s", err)
			return -1, "failed", fmt.Errorf("[Err] Error waiting for Elastic Beanstalk Environment state: %s", err)
		}

		if resp == nil || len(resp.Environments) == 0 {
			// Sometimes AWS just has consistency issues and doesn't see
			// our instance yet. Return an empty state.
			return nil, "", nil
		}

		var env *elasticbeanstalk.EnvironmentDescription
		for _, e := range resp.Environments {
			if environmentId == *e.EnvironmentId {
				env = e
			}
		}

		if env == nil {
			return -1, "failed", fmt.Errorf("[Err] Error finding Elastic Beanstalk Environment, environment not found")
		}

		return env, *env.Status, nil
	}
}

func queryBeanstalkEnv(svc *eb.ElasticBeanstalk, filterVal string) interface{} {
	params := &eb.DescribeEnvironmentsInput{
		EnvironmentNames: []*string{aws.String(filterVal)},
	}
	resp, err := svc.DescribeEnvironments(params)
	checkError(err)
	if len(resp.Environments) > 0 {
		return resp
	}

	return nil
}

func describeBeanstalkEnv(conn *elasticbeanstalk.ElasticBeanstalk,
	envID *string) (*elasticbeanstalk.EnvironmentDescription, error) {
	describeBeanstalkEnvOpts := &elasticbeanstalk.DescribeEnvironmentsInput{
		EnvironmentIds: []*string{envID},
	}

	log.Printf("[DEBUG] Elastic Beanstalk Environment TEST describe opts: %s", describeBeanstalkEnvOpts)

	resp, err := conn.DescribeEnvironments(describeBeanstalkEnvOpts)
	if err != nil {
		return &elasticbeanstalk.EnvironmentDescription{}, err
	}
	if len(resp.Environments) == 0 {
		return &elasticbeanstalk.EnvironmentDescription{}, fmt.Errorf("Elastic Beanstalk ENV not found.")
	}
	if len(resp.Environments) > 1 {
		return &elasticbeanstalk.EnvironmentDescription{}, fmt.Errorf("Found %d environments, expected 1.", len(resp.Environments))
	}
	return resp.Environments[0], nil
}

// inspect and print out details of disposable versions for a given application
func inspect(eb *elasticbeanstalk.ElasticBeanstalk, appName string, duration int) []*elasticbeanstalk.ApplicationVersionDescription {
	applicationVersionResp, err := eb.DescribeApplicationVersions(&elasticbeanstalk.DescribeApplicationVersionsInput{ApplicationName: &appName})

	if err != nil {
		if awsErr, ok := err.(awserr.Error); ok {
			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
			if reqErr, ok := err.(awserr.RequestFailure); ok {
				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
			}
		} else {
			fmt.Println(err.Error())
		}
		os.Exit(1)
	}

	environmentResp, err := eb.DescribeEnvironments(&elasticbeanstalk.DescribeEnvironmentsInput{ApplicationName: &appName})

	if err != nil {
		if awsErr, ok := err.(awserr.Error); ok {
			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
			if reqErr, ok := err.(awserr.RequestFailure); ok {
				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
			}
		} else {
			fmt.Println(err.Error())
		}
		os.Exit(1)
	}

	var disposableVersions = make([]*elasticbeanstalk.ApplicationVersionDescription, 0)

	var buffer bytes.Buffer

	buffer.WriteString(fmt.Sprintf("Application Name: %s\n", appName))
	buffer.WriteString(fmt.Sprintf("Total version: %d\n", len(applicationVersionResp.ApplicationVersions)))

	table := termtables.CreateTable()

	table.AddHeaders("Version Label", "Date Created", "Environment")

	for _, version := range applicationVersionResp.ApplicationVersions {
		var found bool = false
		for _, environment := range environmentResp.Environments {
			if *version.VersionLabel == *environment.VersionLabel {
				table.AddRow(*version.VersionLabel, version.DateCreated, *environment.EnvironmentName)
				found = true
			}
		}

		if !found {
			if time.Now().After(version.DateCreated.AddDate(0, 0, duration)) {
				disposableVersions = append(disposableVersions, version)
				table.AddRow(*version.VersionLabel, version.DateCreated, "*Disposable*")
			} else {
				table.AddRow(*version.VersionLabel, version.DateCreated, "Not disposable")
			}
		}
	}

	buffer.WriteString(table.Render())
	buffer.WriteString(fmt.Sprintf("Disposable version count: %d\n", len(disposableVersions)))

	fmt.Println(buffer.String())

	return disposableVersions
}