From f0d31769998974bfd026bcb1ebc0aca477710d12 Mon Sep 17 00:00:00 2001 From: clint shryock Date: Mon, 7 Mar 2016 14:42:30 -0600 Subject: [PATCH] provider/aws: Add Elastic Beanstalk Application, Configuration Template, and Environment This adds support for Elastic Beanstalk Applications, Configuration Templates, and Environments. This is a combined work of @catsby, @dharrisio, @Bowbaq, and @jen20 --- Godeps/Godeps.json | 5 + builtin/providers/aws/config.go | 5 + builtin/providers/aws/provider.go | 255 +- ...ource_aws_elastic_beanstalk_application.go | 147 + ..._aws_elastic_beanstalk_application_test.go | 100 + ...lastic_beanstalk_configuration_template.go | 242 ++ ...c_beanstalk_configuration_template_test.go | 121 + ...ource_aws_elastic_beanstalk_environment.go | 549 +++ ..._aws_elastic_beanstalk_environment_test.go | 185 + builtin/providers/aws/tagsBeanstalk.go | 52 + builtin/providers/aws/tagsBeanstalk_test.go | 85 + .../service/elasticbeanstalk/api.go | 3839 +++++++++++++++++ .../elasticbeanstalkiface/interface.go | 148 + .../service/elasticbeanstalk/examples_test.go | 839 ++++ .../service/elasticbeanstalk/service.go | 106 + ...lastic_beanstalk_application.html.markdown | 39 + ...stalk_configuration_template.html.markdown | 59 + ...lastic_beanstalk_environment.html.markdown | 83 + website/source/layouts/aws.erb | 14 +- 19 files changed, 6746 insertions(+), 127 deletions(-) create mode 100644 builtin/providers/aws/resource_aws_elastic_beanstalk_application.go create mode 100644 builtin/providers/aws/resource_aws_elastic_beanstalk_application_test.go create mode 100644 builtin/providers/aws/resource_aws_elastic_beanstalk_configuration_template.go create mode 100644 builtin/providers/aws/resource_aws_elastic_beanstalk_configuration_template_test.go create mode 100644 builtin/providers/aws/resource_aws_elastic_beanstalk_environment.go create mode 100644 builtin/providers/aws/resource_aws_elastic_beanstalk_environment_test.go create mode 100644 builtin/providers/aws/tagsBeanstalk.go create mode 100644 builtin/providers/aws/tagsBeanstalk_test.go create mode 100644 vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/api.go create mode 100644 vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/elasticbeanstalkiface/interface.go create mode 100644 vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/examples_test.go create mode 100644 vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/service.go create mode 100644 website/source/docs/providers/aws/r/elastic_beanstalk_application.html.markdown create mode 100644 website/source/docs/providers/aws/r/elastic_beanstalk_configuration_template.html.markdown create mode 100644 website/source/docs/providers/aws/r/elastic_beanstalk_environment.html.markdown diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 42d88c1198..936bc90cc3 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -376,6 +376,11 @@ "Comment": "v1.1.2", "Rev": "8041be5461786460d86b4358305fbdf32d37cfb2" }, + { + "ImportPath": "github.com/aws/aws-sdk-go/service/elasticbeanstalk", + "Comment": "v1.1.0", + "Rev": "be2ec39e520e3c4088c0c6288055bdc8184a89ee" + }, { "ImportPath": "github.com/aws/aws-sdk-go/service/elasticsearchservice", "Comment": "v1.1.2", diff --git a/builtin/providers/aws/config.go b/builtin/providers/aws/config.go index 8554672499..dc422efe3f 100644 --- a/builtin/providers/aws/config.go +++ b/builtin/providers/aws/config.go @@ -35,6 +35,7 @@ import ( "github.com/aws/aws-sdk-go/service/ecs" "github.com/aws/aws-sdk-go/service/efs" "github.com/aws/aws-sdk-go/service/elasticache" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" elasticsearch "github.com/aws/aws-sdk-go/service/elasticsearchservice" "github.com/aws/aws-sdk-go/service/elb" "github.com/aws/aws-sdk-go/service/firehose" @@ -98,6 +99,7 @@ type AWSClient struct { kinesisconn *kinesis.Kinesis firehoseconn *firehose.Firehose elasticacheconn *elasticache.ElastiCache + elasticbeanstalkconn *elasticbeanstalk.ElasticBeanstalk lambdaconn *lambda.Lambda opsworksconn *opsworks.OpsWorks glacierconn *glacier.Glacier @@ -213,6 +215,9 @@ func (c *Config) Client() (interface{}, error) { kinesisSess := session.New(&awsKinesisConfig) client.kinesisconn = kinesis.New(kinesisSess) + log.Println("[INFO] Initializing Elastic Beanstalk Connection") + client.elasticbeanstalkconn = elasticbeanstalk.New(sess) + authErr := c.ValidateAccountId(client.iamconn) if authErr != nil { errs = append(errs, authErr) diff --git a/builtin/providers/aws/provider.go b/builtin/providers/aws/provider.go index 936be6cbcd..a1144cbd63 100644 --- a/builtin/providers/aws/provider.go +++ b/builtin/providers/aws/provider.go @@ -111,132 +111,135 @@ func Provider() terraform.ResourceProvider { }, ResourcesMap: map[string]*schema.Resource{ - "aws_ami": resourceAwsAmi(), - "aws_ami_copy": resourceAwsAmiCopy(), - "aws_ami_from_instance": resourceAwsAmiFromInstance(), - "aws_api_gateway_api_key": resourceAwsApiGatewayApiKey(), - "aws_api_gateway_deployment": resourceAwsApiGatewayDeployment(), - "aws_api_gateway_integration": resourceAwsApiGatewayIntegration(), - "aws_api_gateway_integration_response": resourceAwsApiGatewayIntegrationResponse(), - "aws_api_gateway_method": resourceAwsApiGatewayMethod(), - "aws_api_gateway_method_response": resourceAwsApiGatewayMethodResponse(), - "aws_api_gateway_model": resourceAwsApiGatewayModel(), - "aws_api_gateway_resource": resourceAwsApiGatewayResource(), - "aws_api_gateway_rest_api": resourceAwsApiGatewayRestApi(), - "aws_app_cookie_stickiness_policy": resourceAwsAppCookieStickinessPolicy(), - "aws_autoscaling_group": resourceAwsAutoscalingGroup(), - "aws_autoscaling_notification": resourceAwsAutoscalingNotification(), - "aws_autoscaling_policy": resourceAwsAutoscalingPolicy(), - "aws_autoscaling_schedule": resourceAwsAutoscalingSchedule(), - "aws_cloudformation_stack": resourceAwsCloudFormationStack(), - "aws_cloudtrail": resourceAwsCloudTrail(), - "aws_cloudwatch_event_rule": resourceAwsCloudWatchEventRule(), - "aws_cloudwatch_event_target": resourceAwsCloudWatchEventTarget(), - "aws_cloudwatch_log_group": resourceAwsCloudWatchLogGroup(), - "aws_autoscaling_lifecycle_hook": resourceAwsAutoscalingLifecycleHook(), - "aws_cloudwatch_metric_alarm": resourceAwsCloudWatchMetricAlarm(), - "aws_codedeploy_app": resourceAwsCodeDeployApp(), - "aws_codedeploy_deployment_group": resourceAwsCodeDeployDeploymentGroup(), - "aws_codecommit_repository": resourceAwsCodeCommitRepository(), - "aws_customer_gateway": resourceAwsCustomerGateway(), - "aws_db_instance": resourceAwsDbInstance(), - "aws_db_parameter_group": resourceAwsDbParameterGroup(), - "aws_db_security_group": resourceAwsDbSecurityGroup(), - "aws_db_subnet_group": resourceAwsDbSubnetGroup(), - "aws_directory_service_directory": resourceAwsDirectoryServiceDirectory(), - "aws_dynamodb_table": resourceAwsDynamoDbTable(), - "aws_ebs_volume": resourceAwsEbsVolume(), - "aws_ecr_repository": resourceAwsEcrRepository(), - "aws_ecr_repository_policy": resourceAwsEcrRepositoryPolicy(), - "aws_ecs_cluster": resourceAwsEcsCluster(), - "aws_ecs_service": resourceAwsEcsService(), - "aws_ecs_task_definition": resourceAwsEcsTaskDefinition(), - "aws_efs_file_system": resourceAwsEfsFileSystem(), - "aws_efs_mount_target": resourceAwsEfsMountTarget(), - "aws_eip": resourceAwsEip(), - "aws_elasticache_cluster": resourceAwsElasticacheCluster(), - "aws_elasticache_parameter_group": resourceAwsElasticacheParameterGroup(), - "aws_elasticache_security_group": resourceAwsElasticacheSecurityGroup(), - "aws_elasticache_subnet_group": resourceAwsElasticacheSubnetGroup(), - "aws_elasticsearch_domain": resourceAwsElasticSearchDomain(), - "aws_elb": resourceAwsElb(), - "aws_flow_log": resourceAwsFlowLog(), - "aws_glacier_vault": resourceAwsGlacierVault(), - "aws_iam_access_key": resourceAwsIamAccessKey(), - "aws_iam_account_password_policy": resourceAwsIamAccountPasswordPolicy(), - "aws_iam_group_policy": resourceAwsIamGroupPolicy(), - "aws_iam_group": resourceAwsIamGroup(), - "aws_iam_group_membership": resourceAwsIamGroupMembership(), - "aws_iam_instance_profile": resourceAwsIamInstanceProfile(), - "aws_iam_policy": resourceAwsIamPolicy(), - "aws_iam_policy_attachment": resourceAwsIamPolicyAttachment(), - "aws_iam_role_policy": resourceAwsIamRolePolicy(), - "aws_iam_role": resourceAwsIamRole(), - "aws_iam_saml_provider": resourceAwsIamSamlProvider(), - "aws_iam_server_certificate": resourceAwsIAMServerCertificate(), - "aws_iam_user_policy": resourceAwsIamUserPolicy(), - "aws_iam_user": resourceAwsIamUser(), - "aws_instance": resourceAwsInstance(), - "aws_internet_gateway": resourceAwsInternetGateway(), - "aws_key_pair": resourceAwsKeyPair(), - "aws_kinesis_firehose_delivery_stream": resourceAwsKinesisFirehoseDeliveryStream(), - "aws_kinesis_stream": resourceAwsKinesisStream(), - "aws_lambda_function": resourceAwsLambdaFunction(), - "aws_lambda_event_source_mapping": resourceAwsLambdaEventSourceMapping(), - "aws_lambda_alias": resourceAwsLambdaAlias(), - "aws_lambda_permission": resourceAwsLambdaPermission(), - "aws_launch_configuration": resourceAwsLaunchConfiguration(), - "aws_lb_cookie_stickiness_policy": resourceAwsLBCookieStickinessPolicy(), - "aws_main_route_table_association": resourceAwsMainRouteTableAssociation(), - "aws_nat_gateway": resourceAwsNatGateway(), - "aws_network_acl": resourceAwsNetworkAcl(), - "aws_network_acl_rule": resourceAwsNetworkAclRule(), - "aws_network_interface": resourceAwsNetworkInterface(), - "aws_opsworks_stack": resourceAwsOpsworksStack(), - "aws_opsworks_java_app_layer": resourceAwsOpsworksJavaAppLayer(), - "aws_opsworks_haproxy_layer": resourceAwsOpsworksHaproxyLayer(), - "aws_opsworks_static_web_layer": resourceAwsOpsworksStaticWebLayer(), - "aws_opsworks_php_app_layer": resourceAwsOpsworksPhpAppLayer(), - "aws_opsworks_rails_app_layer": resourceAwsOpsworksRailsAppLayer(), - "aws_opsworks_nodejs_app_layer": resourceAwsOpsworksNodejsAppLayer(), - "aws_opsworks_memcached_layer": resourceAwsOpsworksMemcachedLayer(), - "aws_opsworks_mysql_layer": resourceAwsOpsworksMysqlLayer(), - "aws_opsworks_ganglia_layer": resourceAwsOpsworksGangliaLayer(), - "aws_opsworks_custom_layer": resourceAwsOpsworksCustomLayer(), - "aws_placement_group": resourceAwsPlacementGroup(), - "aws_proxy_protocol_policy": resourceAwsProxyProtocolPolicy(), - "aws_rds_cluster": resourceAwsRDSCluster(), - "aws_rds_cluster_instance": resourceAwsRDSClusterInstance(), - "aws_redshift_cluster": resourceAwsRedshiftCluster(), - "aws_redshift_security_group": resourceAwsRedshiftSecurityGroup(), - "aws_redshift_parameter_group": resourceAwsRedshiftParameterGroup(), - "aws_redshift_subnet_group": resourceAwsRedshiftSubnetGroup(), - "aws_route53_delegation_set": resourceAwsRoute53DelegationSet(), - "aws_route53_record": resourceAwsRoute53Record(), - "aws_route53_zone_association": resourceAwsRoute53ZoneAssociation(), - "aws_route53_zone": resourceAwsRoute53Zone(), - "aws_route53_health_check": resourceAwsRoute53HealthCheck(), - "aws_route": resourceAwsRoute(), - "aws_route_table": resourceAwsRouteTable(), - "aws_route_table_association": resourceAwsRouteTableAssociation(), - "aws_s3_bucket": resourceAwsS3Bucket(), - "aws_s3_bucket_object": resourceAwsS3BucketObject(), - "aws_security_group": resourceAwsSecurityGroup(), - "aws_security_group_rule": resourceAwsSecurityGroupRule(), - "aws_spot_instance_request": resourceAwsSpotInstanceRequest(), - "aws_sqs_queue": resourceAwsSqsQueue(), - "aws_sns_topic": resourceAwsSnsTopic(), - "aws_sns_topic_subscription": resourceAwsSnsTopicSubscription(), - "aws_subnet": resourceAwsSubnet(), - "aws_volume_attachment": resourceAwsVolumeAttachment(), - "aws_vpc_dhcp_options_association": resourceAwsVpcDhcpOptionsAssociation(), - "aws_vpc_dhcp_options": resourceAwsVpcDhcpOptions(), - "aws_vpc_peering_connection": resourceAwsVpcPeeringConnection(), - "aws_vpc": resourceAwsVpc(), - "aws_vpc_endpoint": resourceAwsVpcEndpoint(), - "aws_vpn_connection": resourceAwsVpnConnection(), - "aws_vpn_connection_route": resourceAwsVpnConnectionRoute(), - "aws_vpn_gateway": resourceAwsVpnGateway(), + "aws_ami": resourceAwsAmi(), + "aws_ami_copy": resourceAwsAmiCopy(), + "aws_ami_from_instance": resourceAwsAmiFromInstance(), + "aws_api_gateway_api_key": resourceAwsApiGatewayApiKey(), + "aws_api_gateway_deployment": resourceAwsApiGatewayDeployment(), + "aws_api_gateway_integration": resourceAwsApiGatewayIntegration(), + "aws_api_gateway_integration_response": resourceAwsApiGatewayIntegrationResponse(), + "aws_api_gateway_method": resourceAwsApiGatewayMethod(), + "aws_api_gateway_method_response": resourceAwsApiGatewayMethodResponse(), + "aws_api_gateway_model": resourceAwsApiGatewayModel(), + "aws_api_gateway_resource": resourceAwsApiGatewayResource(), + "aws_api_gateway_rest_api": resourceAwsApiGatewayRestApi(), + "aws_app_cookie_stickiness_policy": resourceAwsAppCookieStickinessPolicy(), + "aws_autoscaling_group": resourceAwsAutoscalingGroup(), + "aws_autoscaling_notification": resourceAwsAutoscalingNotification(), + "aws_autoscaling_policy": resourceAwsAutoscalingPolicy(), + "aws_autoscaling_schedule": resourceAwsAutoscalingSchedule(), + "aws_cloudformation_stack": resourceAwsCloudFormationStack(), + "aws_cloudtrail": resourceAwsCloudTrail(), + "aws_cloudwatch_event_rule": resourceAwsCloudWatchEventRule(), + "aws_cloudwatch_event_target": resourceAwsCloudWatchEventTarget(), + "aws_cloudwatch_log_group": resourceAwsCloudWatchLogGroup(), + "aws_autoscaling_lifecycle_hook": resourceAwsAutoscalingLifecycleHook(), + "aws_cloudwatch_metric_alarm": resourceAwsCloudWatchMetricAlarm(), + "aws_codedeploy_app": resourceAwsCodeDeployApp(), + "aws_codedeploy_deployment_group": resourceAwsCodeDeployDeploymentGroup(), + "aws_codecommit_repository": resourceAwsCodeCommitRepository(), + "aws_customer_gateway": resourceAwsCustomerGateway(), + "aws_db_instance": resourceAwsDbInstance(), + "aws_db_parameter_group": resourceAwsDbParameterGroup(), + "aws_db_security_group": resourceAwsDbSecurityGroup(), + "aws_db_subnet_group": resourceAwsDbSubnetGroup(), + "aws_directory_service_directory": resourceAwsDirectoryServiceDirectory(), + "aws_dynamodb_table": resourceAwsDynamoDbTable(), + "aws_ebs_volume": resourceAwsEbsVolume(), + "aws_ecr_repository": resourceAwsEcrRepository(), + "aws_ecr_repository_policy": resourceAwsEcrRepositoryPolicy(), + "aws_ecs_cluster": resourceAwsEcsCluster(), + "aws_ecs_service": resourceAwsEcsService(), + "aws_ecs_task_definition": resourceAwsEcsTaskDefinition(), + "aws_efs_file_system": resourceAwsEfsFileSystem(), + "aws_efs_mount_target": resourceAwsEfsMountTarget(), + "aws_eip": resourceAwsEip(), + "aws_elasticache_cluster": resourceAwsElasticacheCluster(), + "aws_elasticache_parameter_group": resourceAwsElasticacheParameterGroup(), + "aws_elasticache_security_group": resourceAwsElasticacheSecurityGroup(), + "aws_elasticache_subnet_group": resourceAwsElasticacheSubnetGroup(), + "aws_elastic_beanstalk_application": resourceAwsElasticBeanstalkApplication(), + "aws_elastic_beanstalk_configuration_template": resourceAwsElasticBeanstalkConfigurationTemplate(), + "aws_elastic_beanstalk_environment": resourceAwsElasticBeanstalkEnvironment(), + "aws_elasticsearch_domain": resourceAwsElasticSearchDomain(), + "aws_elb": resourceAwsElb(), + "aws_flow_log": resourceAwsFlowLog(), + "aws_glacier_vault": resourceAwsGlacierVault(), + "aws_iam_access_key": resourceAwsIamAccessKey(), + "aws_iam_account_password_policy": resourceAwsIamAccountPasswordPolicy(), + "aws_iam_group_policy": resourceAwsIamGroupPolicy(), + "aws_iam_group": resourceAwsIamGroup(), + "aws_iam_group_membership": resourceAwsIamGroupMembership(), + "aws_iam_instance_profile": resourceAwsIamInstanceProfile(), + "aws_iam_policy": resourceAwsIamPolicy(), + "aws_iam_policy_attachment": resourceAwsIamPolicyAttachment(), + "aws_iam_role_policy": resourceAwsIamRolePolicy(), + "aws_iam_role": resourceAwsIamRole(), + "aws_iam_saml_provider": resourceAwsIamSamlProvider(), + "aws_iam_server_certificate": resourceAwsIAMServerCertificate(), + "aws_iam_user_policy": resourceAwsIamUserPolicy(), + "aws_iam_user": resourceAwsIamUser(), + "aws_instance": resourceAwsInstance(), + "aws_internet_gateway": resourceAwsInternetGateway(), + "aws_key_pair": resourceAwsKeyPair(), + "aws_kinesis_firehose_delivery_stream": resourceAwsKinesisFirehoseDeliveryStream(), + "aws_kinesis_stream": resourceAwsKinesisStream(), + "aws_lambda_function": resourceAwsLambdaFunction(), + "aws_lambda_event_source_mapping": resourceAwsLambdaEventSourceMapping(), + "aws_lambda_alias": resourceAwsLambdaAlias(), + "aws_lambda_permission": resourceAwsLambdaPermission(), + "aws_launch_configuration": resourceAwsLaunchConfiguration(), + "aws_lb_cookie_stickiness_policy": resourceAwsLBCookieStickinessPolicy(), + "aws_main_route_table_association": resourceAwsMainRouteTableAssociation(), + "aws_nat_gateway": resourceAwsNatGateway(), + "aws_network_acl": resourceAwsNetworkAcl(), + "aws_network_acl_rule": resourceAwsNetworkAclRule(), + "aws_network_interface": resourceAwsNetworkInterface(), + "aws_opsworks_stack": resourceAwsOpsworksStack(), + "aws_opsworks_java_app_layer": resourceAwsOpsworksJavaAppLayer(), + "aws_opsworks_haproxy_layer": resourceAwsOpsworksHaproxyLayer(), + "aws_opsworks_static_web_layer": resourceAwsOpsworksStaticWebLayer(), + "aws_opsworks_php_app_layer": resourceAwsOpsworksPhpAppLayer(), + "aws_opsworks_rails_app_layer": resourceAwsOpsworksRailsAppLayer(), + "aws_opsworks_nodejs_app_layer": resourceAwsOpsworksNodejsAppLayer(), + "aws_opsworks_memcached_layer": resourceAwsOpsworksMemcachedLayer(), + "aws_opsworks_mysql_layer": resourceAwsOpsworksMysqlLayer(), + "aws_opsworks_ganglia_layer": resourceAwsOpsworksGangliaLayer(), + "aws_opsworks_custom_layer": resourceAwsOpsworksCustomLayer(), + "aws_placement_group": resourceAwsPlacementGroup(), + "aws_proxy_protocol_policy": resourceAwsProxyProtocolPolicy(), + "aws_rds_cluster": resourceAwsRDSCluster(), + "aws_rds_cluster_instance": resourceAwsRDSClusterInstance(), + "aws_redshift_cluster": resourceAwsRedshiftCluster(), + "aws_redshift_security_group": resourceAwsRedshiftSecurityGroup(), + "aws_redshift_parameter_group": resourceAwsRedshiftParameterGroup(), + "aws_redshift_subnet_group": resourceAwsRedshiftSubnetGroup(), + "aws_route53_delegation_set": resourceAwsRoute53DelegationSet(), + "aws_route53_record": resourceAwsRoute53Record(), + "aws_route53_zone_association": resourceAwsRoute53ZoneAssociation(), + "aws_route53_zone": resourceAwsRoute53Zone(), + "aws_route53_health_check": resourceAwsRoute53HealthCheck(), + "aws_route": resourceAwsRoute(), + "aws_route_table": resourceAwsRouteTable(), + "aws_route_table_association": resourceAwsRouteTableAssociation(), + "aws_s3_bucket": resourceAwsS3Bucket(), + "aws_s3_bucket_object": resourceAwsS3BucketObject(), + "aws_security_group": resourceAwsSecurityGroup(), + "aws_security_group_rule": resourceAwsSecurityGroupRule(), + "aws_spot_instance_request": resourceAwsSpotInstanceRequest(), + "aws_sqs_queue": resourceAwsSqsQueue(), + "aws_sns_topic": resourceAwsSnsTopic(), + "aws_sns_topic_subscription": resourceAwsSnsTopicSubscription(), + "aws_subnet": resourceAwsSubnet(), + "aws_volume_attachment": resourceAwsVolumeAttachment(), + "aws_vpc_dhcp_options_association": resourceAwsVpcDhcpOptionsAssociation(), + "aws_vpc_dhcp_options": resourceAwsVpcDhcpOptions(), + "aws_vpc_peering_connection": resourceAwsVpcPeeringConnection(), + "aws_vpc": resourceAwsVpc(), + "aws_vpc_endpoint": resourceAwsVpcEndpoint(), + "aws_vpn_connection": resourceAwsVpnConnection(), + "aws_vpn_connection_route": resourceAwsVpnConnectionRoute(), + "aws_vpn_gateway": resourceAwsVpnGateway(), }, ConfigureFunc: providerConfigure, diff --git a/builtin/providers/aws/resource_aws_elastic_beanstalk_application.go b/builtin/providers/aws/resource_aws_elastic_beanstalk_application.go new file mode 100644 index 0000000000..89fe92ae65 --- /dev/null +++ b/builtin/providers/aws/resource_aws_elastic_beanstalk_application.go @@ -0,0 +1,147 @@ +package aws + +import ( + "fmt" + "log" + "time" + + "github.com/hashicorp/terraform/helper/schema" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" + "github.com/hashicorp/terraform/helper/resource" +) + +func resourceAwsElasticBeanstalkApplication() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsElasticBeanstalkApplicationCreate, + Read: resourceAwsElasticBeanstalkApplicationRead, + Update: resourceAwsElasticBeanstalkApplicationUpdate, + Delete: resourceAwsElasticBeanstalkApplicationDelete, + + Schema: map[string]*schema.Schema{ + "name": &schema.Schema{ + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + "description": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + ForceNew: false, + }, + }, + } +} + +func resourceAwsElasticBeanstalkApplicationCreate(d *schema.ResourceData, meta interface{}) error { + beanstalkConn := meta.(*AWSClient).elasticbeanstalkconn + + // Get the name and description + name := d.Get("name").(string) + description := d.Get("description").(string) + + log.Printf("[DEBUG] Elastic Beanstalk application create: %s, description: %s", name, description) + + req := &elasticbeanstalk.CreateApplicationInput{ + ApplicationName: aws.String(name), + Description: aws.String(description), + } + + _, err := beanstalkConn.CreateApplication(req) + if err != nil { + return err + } + + d.SetId(name) + + return resourceAwsElasticBeanstalkApplicationRead(d, meta) +} + +func resourceAwsElasticBeanstalkApplicationUpdate(d *schema.ResourceData, meta interface{}) error { + beanstalkConn := meta.(*AWSClient).elasticbeanstalkconn + + if d.HasChange("description") { + if err := resourceAwsElasticBeanstalkApplicationDescriptionUpdate(beanstalkConn, d); err != nil { + return err + } + } + + return resourceAwsElasticBeanstalkApplicationRead(d, meta) +} + +func resourceAwsElasticBeanstalkApplicationDescriptionUpdate(beanstalkConn *elasticbeanstalk.ElasticBeanstalk, d *schema.ResourceData) error { + name := d.Get("name").(string) + description := d.Get("description").(string) + + log.Printf("[DEBUG] Elastic Beanstalk application: %s, update description: %s", name, description) + + _, err := beanstalkConn.UpdateApplication(&elasticbeanstalk.UpdateApplicationInput{ + ApplicationName: aws.String(name), + Description: aws.String(description), + }) + + return err +} + +func resourceAwsElasticBeanstalkApplicationRead(d *schema.ResourceData, meta interface{}) error { + a, err := getBeanstalkApplication(d, meta) + if err != nil { + return err + } + if a == nil { + return err + } + + d.Set("description", a.Description) + return nil +} + +func resourceAwsElasticBeanstalkApplicationDelete(d *schema.ResourceData, meta interface{}) error { + beanstalkConn := meta.(*AWSClient).elasticbeanstalkconn + + a, err := getBeanstalkApplication(d, meta) + if err != nil { + return err + } + _, err = beanstalkConn.DeleteApplication(&elasticbeanstalk.DeleteApplicationInput{ + ApplicationName: aws.String(d.Id()), + }) + + return resource.Retry(10*time.Second, func() error { + if a, _ = getBeanstalkApplication(d, meta); a != nil { + return fmt.Errorf("Beanstalk Application still exists") + } + return nil + }) +} + +func getBeanstalkApplication( + d *schema.ResourceData, + meta interface{}) (*elasticbeanstalk.ApplicationDescription, error) { + conn := meta.(*AWSClient).elasticbeanstalkconn + + resp, err := conn.DescribeApplications(&elasticbeanstalk.DescribeApplicationsInput{ + ApplicationNames: []*string{aws.String(d.Id())}, + }) + + if err != nil { + if ec2err, ok := err.(awserr.Error); ok && ec2err.Code() != "InvalidBeanstalkAppID.NotFound" { + log.Printf("[Err] Error reading Elastic Beanstalk Application (%s): Application not found", d.Id()) + d.SetId("") + return nil, nil + } + return nil, err + } + + switch { + case len(resp.Applications) > 1: + return nil, fmt.Errorf("Error %d Applications matched, expected 1", len(resp.Applications)) + case len(resp.Applications) == 0: + d.SetId("") + return nil, nil + default: + return resp.Applications[0], nil + } +} diff --git a/builtin/providers/aws/resource_aws_elastic_beanstalk_application_test.go b/builtin/providers/aws/resource_aws_elastic_beanstalk_application_test.go new file mode 100644 index 0000000000..edcf4c1746 --- /dev/null +++ b/builtin/providers/aws/resource_aws_elastic_beanstalk_application_test.go @@ -0,0 +1,100 @@ +package aws + +import ( + "fmt" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func TestAccAWSBeanstalkApp_basic(t *testing.T) { + var app elasticbeanstalk.ApplicationDescription + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBeanstalkAppDestroy, + Steps: []resource.TestStep{ + resource.TestStep{ + Config: testAccBeanstalkAppConfig, + Check: resource.ComposeTestCheckFunc( + testAccCheckBeanstalkAppExists("aws_elastic_beanstalk_application.tftest", &app), + ), + }, + }, + }) +} + +func testAccCheckBeanstalkAppDestroy(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).elasticbeanstalkconn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_elastic_beanstalk_application" { + continue + } + + // Try to find the application + DescribeBeanstalkAppOpts := &elasticbeanstalk.DescribeApplicationsInput{ + ApplicationNames: []*string{aws.String(rs.Primary.ID)}, + } + resp, err := conn.DescribeApplications(DescribeBeanstalkAppOpts) + if err == nil { + if len(resp.Applications) > 0 { + return fmt.Errorf("Elastic Beanstalk Application still exists.") + } + + return nil + } + + // Verify the error is what we want + ec2err, ok := err.(awserr.Error) + if !ok { + return err + } + if ec2err.Code() != "InvalidBeanstalkAppID.NotFound" { + return err + } + } + + return nil +} + +func testAccCheckBeanstalkAppExists(n string, app *elasticbeanstalk.ApplicationDescription) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[n] + if !ok { + return fmt.Errorf("Not found: %s", n) + } + + if rs.Primary.ID == "" { + return fmt.Errorf("Elastic Beanstalk app ID is not set") + } + + conn := testAccProvider.Meta().(*AWSClient).elasticbeanstalkconn + DescribeBeanstalkAppOpts := &elasticbeanstalk.DescribeApplicationsInput{ + ApplicationNames: []*string{aws.String(rs.Primary.ID)}, + } + resp, err := conn.DescribeApplications(DescribeBeanstalkAppOpts) + if err != nil { + return err + } + if len(resp.Applications) == 0 { + return fmt.Errorf("Elastic Beanstalk Application not found.") + } + + *app = *resp.Applications[0] + + return nil + } +} + +const testAccBeanstalkAppConfig = ` +resource "aws_elastic_beanstalk_application" "tftest" { + name = "tf-test-name" + description = "tf-test-desc" +} +` diff --git a/builtin/providers/aws/resource_aws_elastic_beanstalk_configuration_template.go b/builtin/providers/aws/resource_aws_elastic_beanstalk_configuration_template.go new file mode 100644 index 0000000000..eff6535e94 --- /dev/null +++ b/builtin/providers/aws/resource_aws_elastic_beanstalk_configuration_template.go @@ -0,0 +1,242 @@ +package aws + +import ( + "fmt" + "log" + + "github.com/hashicorp/terraform/helper/hashcode" + "github.com/hashicorp/terraform/helper/schema" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" +) + +func resourceAwsElasticBeanstalkConfigurationTemplate() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsElasticBeanstalkConfigurationTemplateCreate, + Read: resourceAwsElasticBeanstalkConfigurationTemplateRead, + Update: resourceAwsElasticBeanstalkConfigurationTemplateUpdate, + Delete: resourceAwsElasticBeanstalkConfigurationTemplateDelete, + + Schema: map[string]*schema.Schema{ + "name": &schema.Schema{ + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + "application": &schema.Schema{ + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + "description": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + }, + "environment_id": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + "option_settings": &schema.Schema{ + Type: schema.TypeSet, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "namespace": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + }, + "option_name": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + }, + "value": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + }, + }, + }, + Set: optionSettingHash, + }, + "solution_stack_name": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + }, + } +} + +func resourceAwsElasticBeanstalkConfigurationTemplateCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).elasticbeanstalkconn + + // Get the relevant properties + name := d.Get("name").(string) + appName := d.Get("application").(string) + + optionSettings := gatherOptionSettings(d) + + opts := elasticbeanstalk.CreateConfigurationTemplateInput{ + ApplicationName: aws.String(appName), + TemplateName: aws.String(name), + OptionSettings: optionSettings, + } + + if attr, ok := d.GetOk("description"); ok { + opts.Description = aws.String(attr.(string)) + } + + if attr, ok := d.GetOk("environment_id"); ok { + opts.EnvironmentId = aws.String(attr.(string)) + } + + if attr, ok := d.GetOk("solution_stack_name"); ok { + opts.SolutionStackName = aws.String(attr.(string)) + } + + log.Printf("[DEBUG] Elastic Beanstalk configuration template create opts: %s", opts) + if _, err := conn.CreateConfigurationTemplate(&opts); err != nil { + return fmt.Errorf("Error creating Elastic Beanstalk configuration template: %s", err) + } + + d.SetId(name) + + return resourceAwsElasticBeanstalkConfigurationTemplateRead(d, meta) +} + +func resourceAwsElasticBeanstalkConfigurationTemplateRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).elasticbeanstalkconn + + log.Printf("[DEBUG] Elastic Beanstalk configuration template read: %s", d.Get("name").(string)) + + resp, err := conn.DescribeConfigurationSettings(&elasticbeanstalk.DescribeConfigurationSettingsInput{ + TemplateName: aws.String(d.Id()), + ApplicationName: aws.String(d.Get("application").(string)), + }) + + if err != nil { + return err + } + + // if len(resp.ConfigurationSettings) > 1 { + + // settings := make(map[string]map[string]string) + // for _, setting := range resp.ConfigurationSettings { + // k := fmt.Sprintf("%s.%s", setting.) + // } + // } + + if len(resp.ConfigurationSettings) != 1 { + log.Printf("[DEBUG] Elastic Beanstalk unexpected describe configuration template response: %+v", resp) + return fmt.Errorf("Error reading application properties: found %d applications, expected 1", len(resp.ConfigurationSettings)) + } + + d.Set("description", resp.ConfigurationSettings[0].Description) + return nil +} + +func resourceAwsElasticBeanstalkConfigurationTemplateUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).elasticbeanstalkconn + + log.Printf("[DEBUG] Elastic Beanstalk configuration template update: %s", d.Get("name").(string)) + + if d.HasChange("description") { + if err := resourceAwsElasticBeanstalkConfigurationTemplateDescriptionUpdate(conn, d); err != nil { + return err + } + } + + if d.HasChange("option_settings") { + if err := resourceAwsElasticBeanstalkConfigurationTemplateOptionSettingsUpdate(conn, d); err != nil { + return err + } + } + + return resourceAwsElasticBeanstalkConfigurationTemplateRead(d, meta) +} + +func resourceAwsElasticBeanstalkConfigurationTemplateDescriptionUpdate(conn *elasticbeanstalk.ElasticBeanstalk, d *schema.ResourceData) error { + _, err := conn.UpdateConfigurationTemplate(&elasticbeanstalk.UpdateConfigurationTemplateInput{ + ApplicationName: aws.String(d.Get("application").(string)), + TemplateName: aws.String(d.Get("name").(string)), + Description: aws.String(d.Get("description").(string)), + }) + + return err +} + +func resourceAwsElasticBeanstalkConfigurationTemplateOptionSettingsUpdate(conn *elasticbeanstalk.ElasticBeanstalk, d *schema.ResourceData) error { + if d.HasChange("option_settings") { + _, err := conn.ValidateConfigurationSettings(&elasticbeanstalk.ValidateConfigurationSettingsInput{ + ApplicationName: aws.String(d.Get("application").(string)), + TemplateName: aws.String(d.Get("name").(string)), + OptionSettings: gatherOptionSettings(d), + }) + if err != nil { + return err + } + + o, n := d.GetChange("option_settings") + if o == nil { + o = new(schema.Set) + } + if n == nil { + n = new(schema.Set) + } + + os := o.(*schema.Set) + ns := o.(*schema.Set) + + remove := extractOptionSettings(os.Difference(ns)) + add := extractOptionSettings(ns.Difference(os)) + + req := &elasticbeanstalk.UpdateConfigurationTemplateInput{ + ApplicationName: aws.String(d.Get("application").(string)), + TemplateName: aws.String(d.Get("name").(string)), + OptionSettings: add, + } + + for _, elem := range remove { + req.OptionsToRemove = append(req.OptionsToRemove, &elasticbeanstalk.OptionSpecification{ + Namespace: elem.Namespace, + OptionName: elem.OptionName, + }) + } + + if _, err := conn.UpdateConfigurationTemplate(req); err != nil { + return err + } + } + + return nil +} + +func resourceAwsElasticBeanstalkConfigurationTemplateDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).elasticbeanstalkconn + + application := d.Get("application").(string) + + _, err := conn.DeleteConfigurationTemplate(&elasticbeanstalk.DeleteConfigurationTemplateInput{ + ApplicationName: aws.String(application), + TemplateName: aws.String(d.Id()), + }) + + return err +} + +func optionSettingHash(v interface{}) int { + rd := v.(*schema.ResourceData) + namespace := rd.Get("namespace").(string) + optionName := rd.Get("option_name").(string) + return hashcode.String(fmt.Sprintf("%s.%s", namespace, optionName)) +} + +func gatherOptionSettings(d *schema.ResourceData) []*elasticbeanstalk.ConfigurationOptionSetting { + optionSettingsSet, ok := d.Get("option_settings").(*schema.Set) + if !ok || optionSettingsSet == nil { + optionSettingsSet = new(schema.Set) + } + + return extractOptionSettings(optionSettingsSet) +} diff --git a/builtin/providers/aws/resource_aws_elastic_beanstalk_configuration_template_test.go b/builtin/providers/aws/resource_aws_elastic_beanstalk_configuration_template_test.go new file mode 100644 index 0000000000..0d0ec4c0af --- /dev/null +++ b/builtin/providers/aws/resource_aws_elastic_beanstalk_configuration_template_test.go @@ -0,0 +1,121 @@ +package aws + +import ( + "fmt" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func TestAccAWSBeanstalkConfigurationTemplate_basic(t *testing.T) { + var config elasticbeanstalk.ConfigurationSettingsDescription + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBeanstalkConfigurationTemplateDestroy, + Steps: []resource.TestStep{ + resource.TestStep{ + Config: testAccBeanstalkConfigurationTemplateConfig, + Check: resource.ComposeTestCheckFunc( + testAccCheckBeanstalkConfigurationTemplateExists("aws_elastic_beanstalk_configuration_template.tf_template", &config), + ), + }, + }, + }) +} + +func testAccCheckBeanstalkConfigurationTemplateDestroy(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).elasticbeanstalkconn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_elastic_beanstalk_configuration_template" { + continue + } + + // Try to find the Configuration Template + opts := elasticbeanstalk.DescribeConfigurationSettingsInput{ + TemplateName: aws.String(rs.Primary.ID), + ApplicationName: aws.String(rs.Primary.Attributes["application"]), + } + resp, err := conn.DescribeConfigurationSettings(&opts) + if err == nil { + if len(resp.ConfigurationSettings) > 0 { + return fmt.Errorf("Elastic Beanstalk Application still exists.") + } + + return nil + } + + // Verify the error is what we want + ec2err, ok := err.(awserr.Error) + if !ok { + return err + } + + switch { + case ec2err.Code() == "InvalidBeanstalkConfigurationTemplateID.NotFound": + return nil + // This error can be returned when the beanstalk application no longer exists. + case ec2err.Code() == "InvalidParameterValue": + return nil + default: + return err + } + } + + return nil +} + +func testAccCheckBeanstalkConfigurationTemplateExists(n string, config *elasticbeanstalk.ConfigurationSettingsDescription) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).elasticbeanstalkconn + rs, ok := s.RootModule().Resources[n] + if !ok { + return fmt.Errorf("Not found: %s", n) + } + + if rs.Primary.ID == "" { + return fmt.Errorf("Elastic Beanstalk config ID is not set") + } + + opts := elasticbeanstalk.DescribeConfigurationSettingsInput{ + TemplateName: aws.String(rs.Primary.ID), + ApplicationName: aws.String(rs.Primary.Attributes["application"]), + } + resp, err := conn.DescribeConfigurationSettings(&opts) + if err != nil { + return err + } + if len(resp.ConfigurationSettings) == 0 { + return fmt.Errorf("Elastic Beanstalk Configurations not found.") + } + + *config = *resp.ConfigurationSettings[0] + + return nil + } +} + +const testAccBeanstalkConfigurationTemplateConfig = ` +resource "aws_elastic_beanstalk_application" "tftest" { + name = "tf-test-name" + description = "tf-test-desc" +} + +#resource "aws_elastic_beanstalk_environment" "tfenvtest" { +# name = "tf-test-name" +# application = "${aws_elastic_beanstalk_application.tftest.name}" +# solution_stack_name = "64bit Amazon Linux 2015.03 v2.0.3 running Go 1.4" +#} + +resource "aws_elastic_beanstalk_configuration_template" "tf_template" { + name = "tf-test-template-config" + application = "${aws_elastic_beanstalk_application.tftest.name}" + solution_stack_name = "64bit Amazon Linux 2015.09 v2.0.8 running Go 1.4" +} +` diff --git a/builtin/providers/aws/resource_aws_elastic_beanstalk_environment.go b/builtin/providers/aws/resource_aws_elastic_beanstalk_environment.go new file mode 100644 index 0000000000..d7cfaed303 --- /dev/null +++ b/builtin/providers/aws/resource_aws_elastic_beanstalk_environment.go @@ -0,0 +1,549 @@ +package aws + +import ( + "fmt" + "log" + "sort" + "strings" + "time" + + "github.com/hashicorp/terraform/helper/hashcode" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/helper/schema" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/ec2" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" +) + +func resourceAwsElasticBeanstalkOptionSetting() *schema.Resource { + return &schema.Resource{ + Schema: map[string]*schema.Schema{ + "namespace": &schema.Schema{ + Type: schema.TypeString, + Required: true, + }, + "name": &schema.Schema{ + Type: schema.TypeString, + Required: true, + }, + "value": &schema.Schema{ + Type: schema.TypeString, + Required: true, + }, + }, + } +} + +func resourceAwsElasticBeanstalkEnvironment() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsElasticBeanstalkEnvironmentCreate, + Read: resourceAwsElasticBeanstalkEnvironmentRead, + Update: resourceAwsElasticBeanstalkEnvironmentUpdate, + Delete: resourceAwsElasticBeanstalkEnvironmentDelete, + + Schema: map[string]*schema.Schema{ + "name": &schema.Schema{ + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + "application": &schema.Schema{ + Type: schema.TypeString, + Required: true, + }, + "description": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + }, + "cname": &schema.Schema{ + Type: schema.TypeString, + Computed: true, + }, + "tier": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + ValidateFunc: func(v interface{}, k string) (ws []string, errors []error) { + value := v.(string) + switch value { + case + "Worker", + "WebServer": + return + } + errors = append(errors, fmt.Errorf("%s is not a valid tier. Valid options are WebServer or Worker", value)) + return + }, + ForceNew: true, + }, + "setting": &schema.Schema{ + Type: schema.TypeSet, + Optional: true, + Computed: true, + Elem: resourceAwsElasticBeanstalkOptionSetting(), + Set: optionSettingValueHash, + }, + "all_settings": &schema.Schema{ + Type: schema.TypeSet, + Computed: true, + Elem: resourceAwsElasticBeanstalkOptionSetting(), + Set: optionSettingValueHash, + }, + "solution_stack_name": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + }, + "template_name": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + ConflictsWith: []string{"solution_stack_name"}, + }, + + "tags": tagsSchema(), + }, + } +} + +func resourceAwsElasticBeanstalkEnvironmentCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).elasticbeanstalkconn + + // Get values from config + name := d.Get("name").(string) + cname := d.Get("cname").(string) + tier := d.Get("tier").(string) + app := d.Get("application").(string) + desc := d.Get("description").(string) + settings := d.Get("setting").(*schema.Set) + solutionStack := d.Get("solution_stack_name").(string) + templateName := d.Get("template_name").(string) + + // TODO set tags + // Note: at time of writing, you cannot view or edit Tags after creation + // d.Set("tags", tagsToMap(instance.Tags)) + createOpts := elasticbeanstalk.CreateEnvironmentInput{ + EnvironmentName: aws.String(name), + ApplicationName: aws.String(app), + OptionSettings: extractOptionSettings(settings), + Tags: tagsFromMapBeanstalk(d.Get("tags").(map[string]interface{})), + } + + if desc != "" { + createOpts.Description = aws.String(desc) + } + + if cname != "" { + createOpts.CNAMEPrefix = aws.String(cname) + } + + if tier != "" { + var tierType string + + switch tier { + case "WebServer": + tierType = "Standard" + case "Worker": + tierType = "SQS/HTTP" + } + environmentTier := elasticbeanstalk.EnvironmentTier{ + Name: aws.String(tier), + Type: aws.String(tierType), + } + createOpts.Tier = &environmentTier + } + + if solutionStack != "" { + createOpts.SolutionStackName = aws.String(solutionStack) + } + + if templateName != "" { + createOpts.TemplateName = aws.String(templateName) + } + + log.Printf("[DEBUG] Elastic Beanstalk Environment create opts: %s", createOpts) + resp, err := conn.CreateEnvironment(&createOpts) + if err != nil { + return err + } + + // Assign the application name as the resource ID + d.SetId(*resp.EnvironmentId) + + stateConf := &resource.StateChangeConf{ + Pending: []string{"Launching", "Updating"}, + Target: []string{"Ready"}, + Refresh: environmentStateRefreshFunc(conn, d.Id()), + Timeout: 10 * time.Minute, + Delay: 10 * time.Second, + MinTimeout: 3 * time.Second, + } + + _, err = stateConf.WaitForState() + if err != nil { + return fmt.Errorf( + "Error waiting for Elastic Beanstalk Environment (%s) to become ready: %s", + d.Id(), err) + } + + return resourceAwsElasticBeanstalkEnvironmentRead(d, meta) +} + +func resourceAwsElasticBeanstalkEnvironmentUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).elasticbeanstalkconn + + if d.HasChange("description") { + if err := resourceAwsElasticBeanstalkEnvironmentDescriptionUpdate(conn, d); err != nil { + return err + } + } + + if d.HasChange("solution_stack_name") { + if err := resourceAwsElasticBeanstalkEnvironmentSolutionStackUpdate(conn, d); err != nil { + return err + } + } + + if d.HasChange("setting") { + if err := resourceAwsElasticBeanstalkEnvironmentOptionSettingsUpdate(conn, d); err != nil { + return err + } + } + + return resourceAwsElasticBeanstalkEnvironmentRead(d, meta) +} + +func resourceAwsElasticBeanstalkEnvironmentDescriptionUpdate(conn *elasticbeanstalk.ElasticBeanstalk, d *schema.ResourceData) error { + name := d.Get("name").(string) + desc := d.Get("description").(string) + envId := d.Id() + + log.Printf("[DEBUG] Elastic Beanstalk application: %s, update description: %s", name, desc) + + _, err := conn.UpdateEnvironment(&elasticbeanstalk.UpdateEnvironmentInput{ + EnvironmentId: aws.String(envId), + Description: aws.String(desc), + }) + + return err +} + +func resourceAwsElasticBeanstalkEnvironmentOptionSettingsUpdate(conn *elasticbeanstalk.ElasticBeanstalk, d *schema.ResourceData) error { + name := d.Get("name").(string) + envId := d.Id() + + log.Printf("[DEBUG] Elastic Beanstalk application: %s, update options", name) + + req := &elasticbeanstalk.UpdateEnvironmentInput{ + EnvironmentId: aws.String(envId), + } + + if d.HasChange("setting") { + o, n := d.GetChange("setting") + if o == nil { + o = &schema.Set{F: optionSettingValueHash} + } + if n == nil { + n = &schema.Set{F: optionSettingValueHash} + } + + os := o.(*schema.Set) + ns := n.(*schema.Set) + + req.OptionSettings = extractOptionSettings(ns.Difference(os)) + } + + if _, err := conn.UpdateEnvironment(req); err != nil { + return err + } + + return nil +} + +func resourceAwsElasticBeanstalkEnvironmentSolutionStackUpdate(conn *elasticbeanstalk.ElasticBeanstalk, d *schema.ResourceData) error { + name := d.Get("name").(string) + solutionStack := d.Get("solution_stack_name").(string) + envId := d.Id() + + log.Printf("[DEBUG] Elastic Beanstalk application: %s, update solution_stack_name: %s", name, solutionStack) + + _, err := conn.UpdateEnvironment(&elasticbeanstalk.UpdateEnvironmentInput{ + EnvironmentId: aws.String(envId), + SolutionStackName: aws.String(solutionStack), + }) + + return err +} + +func resourceAwsElasticBeanstalkEnvironmentRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).elasticbeanstalkconn + + app := d.Get("application").(string) + envId := d.Id() + + log.Printf("[DEBUG] Elastic Beanstalk environment read %s: id %s", d.Get("name").(string), d.Id()) + + resp, err := conn.DescribeEnvironments(&elasticbeanstalk.DescribeEnvironmentsInput{ + ApplicationName: aws.String(app), + EnvironmentIds: []*string{aws.String(envId)}, + }) + + if err != nil { + return err + } + + if len(resp.Environments) == 0 { + log.Printf("[DEBUG] Elastic Beanstalk environment properties: could not find environment %s", d.Id()) + + d.SetId("") + return nil + } else if len(resp.Environments) != 1 { + return fmt.Errorf("Error reading application properties: found %d environments, expected 1", len(resp.Environments)) + } + + env := resp.Environments[0] + + if *env.Status == "Terminated" { + log.Printf("[DEBUG] Elastic Beanstalk environment %s was terminated", d.Id()) + + d.SetId("") + return nil + } + + if err := d.Set("description", env.Description); err != nil { + return err + } + + if err := d.Set("cname", env.CNAME); err != nil { + return err + } + + return resourceAwsElasticBeanstalkEnvironmentSettingsRead(d, meta) +} + +func fetchAwsElasticBeanstalkEnvironmentSettings(d *schema.ResourceData, meta interface{}) (*schema.Set, error) { + conn := meta.(*AWSClient).elasticbeanstalkconn + + app := d.Get("application").(string) + name := d.Get("name").(string) + + resp, err := conn.DescribeConfigurationSettings(&elasticbeanstalk.DescribeConfigurationSettingsInput{ + ApplicationName: aws.String(app), + EnvironmentName: aws.String(name), + }) + + if err != nil { + return nil, err + } + + if len(resp.ConfigurationSettings) != 1 { + return nil, fmt.Errorf("Error reading environment settings: received %d settings groups, expected 1", len(resp.ConfigurationSettings)) + } + + settings := &schema.Set{F: optionSettingValueHash} + for _, optionSetting := range resp.ConfigurationSettings[0].OptionSettings { + m := map[string]interface{}{} + + if optionSetting.Namespace != nil { + m["namespace"] = *optionSetting.Namespace + } else { + return nil, fmt.Errorf("Error reading environment settings: option setting with no namespace: %v", optionSetting) + } + + if optionSetting.OptionName != nil { + m["name"] = *optionSetting.OptionName + } else { + return nil, fmt.Errorf("Error reading environment settings: option setting with no name: %v", optionSetting) + } + + if optionSetting.Value != nil { + switch *optionSetting.OptionName { + case "SecurityGroups": + m["value"] = dropGeneratedSecurityGroup(*optionSetting.Value, meta) + case "Subnets", "ELBSubnets": + m["value"] = sortValues(*optionSetting.Value) + default: + m["value"] = *optionSetting.Value + } + } + + settings.Add(m) + } + + return settings, nil +} + +func resourceAwsElasticBeanstalkEnvironmentSettingsRead(d *schema.ResourceData, meta interface{}) error { + log.Printf("[DEBUG] Elastic Beanstalk environment settings read %s: id %s", d.Get("name").(string), d.Id()) + + allSettings, err := fetchAwsElasticBeanstalkEnvironmentSettings(d, meta) + if err != nil { + return err + } + + settings := d.Get("setting").(*schema.Set) + + log.Printf("[DEBUG] Elastic Beanstalk allSettings: %s", allSettings.GoString()) + log.Printf("[DEBUG] Elastic Beanstalk settings: %s", settings.GoString()) + + // perform the set operation with only name/namespace as keys, excluding value + // this is so we override things in the settings resource data key with updated values + // from the api. we skip values we didn't know about before because there are so many + // defaults set by the eb api that we would delete many useful defaults. + // + // there is likely a better way to do this + allSettingsKeySet := schema.NewSet(optionSettingKeyHash, allSettings.List()) + settingsKeySet := schema.NewSet(optionSettingKeyHash, settings.List()) + updatedSettingsKeySet := allSettingsKeySet.Intersection(settingsKeySet) + + log.Printf("[DEBUG] Elastic Beanstalk updatedSettingsKeySet: %s", updatedSettingsKeySet.GoString()) + + updatedSettings := schema.NewSet(optionSettingValueHash, updatedSettingsKeySet.List()) + + log.Printf("[DEBUG] Elastic Beanstalk updatedSettings: %s", updatedSettings.GoString()) + + if err := d.Set("all_settings", allSettings.List()); err != nil { + return err + } + + if err := d.Set("setting", updatedSettings.List()); err != nil { + return err + } + + return nil +} + +func resourceAwsElasticBeanstalkEnvironmentDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).elasticbeanstalkconn + + opts := elasticbeanstalk.TerminateEnvironmentInput{ + EnvironmentId: aws.String(d.Id()), + TerminateResources: aws.Bool(true), + } + + log.Printf("[DEBUG] Elastic Beanstalk Environment terminate opts: %s", opts) + _, err := conn.TerminateEnvironment(&opts) + + if err != nil { + return err + } + + stateConf := &resource.StateChangeConf{ + Pending: []string{"Terminating"}, + Target: []string{"Terminated"}, + Refresh: environmentStateRefreshFunc(conn, d.Id()), + Timeout: 10 * time.Minute, + Delay: 10 * time.Second, + MinTimeout: 3 * time.Second, + } + + _, err = stateConf.WaitForState() + if err != nil { + return fmt.Errorf( + "Error waiting for Elastic Beanstalk Environment (%s) to become terminated: %s", + d.Id(), err) + } + + return nil +} + +// 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 + } +} + +// we use the following two functions to allow us to split out defaults +// as they become overridden from within the template +func optionSettingValueHash(v interface{}) int { + rd := v.(map[string]interface{}) + namespace := rd["namespace"].(string) + optionName := rd["name"].(string) + value, _ := rd["value"].(string) + hk := fmt.Sprintf("%s:%s=%s", namespace, optionName, sortValues(value)) + log.Printf("[DEBUG] Elastic Beanstalk optionSettingValueHash(%#v): %s: hk=%s,hc=%d", v, optionName, hk, hashcode.String(hk)) + return hashcode.String(hk) +} + +func optionSettingKeyHash(v interface{}) int { + rd := v.(map[string]interface{}) + namespace := rd["namespace"].(string) + optionName := rd["name"].(string) + hk := fmt.Sprintf("%s:%s", namespace, optionName) + log.Printf("[DEBUG] Elastic Beanstalk optionSettingKeyHash(%#v): %s: hk=%s,hc=%d", v, optionName, hk, hashcode.String(hk)) + return hashcode.String(hk) +} + +func sortValues(v string) string { + values := strings.Split(v, ",") + sort.Strings(values) + return strings.Join(values, ",") +} + +func extractOptionSettings(s *schema.Set) []*elasticbeanstalk.ConfigurationOptionSetting { + settings := []*elasticbeanstalk.ConfigurationOptionSetting{} + + if s != nil { + for _, setting := range s.List() { + settings = append(settings, &elasticbeanstalk.ConfigurationOptionSetting{ + Namespace: aws.String(setting.(map[string]interface{})["namespace"].(string)), + OptionName: aws.String(setting.(map[string]interface{})["name"].(string)), + Value: aws.String(setting.(map[string]interface{})["value"].(string)), + }) + } + } + + return settings +} + +func dropGeneratedSecurityGroup(settingValue string, meta interface{}) string { + conn := meta.(*AWSClient).ec2conn + + groups := strings.Split(settingValue, ",") + + resp, err := conn.DescribeSecurityGroups(&ec2.DescribeSecurityGroupsInput{ + GroupIds: aws.StringSlice(groups), + }) + + if err != nil { + log.Printf("[DEBUG] Elastic Beanstalk error describing SecurityGroups: %v", err) + return settingValue + } + + var legitGroups []string + for _, group := range resp.SecurityGroups { + log.Printf("[DEBUG] Elastic Beanstalk SecurityGroup: %v", *group.GroupName) + if !strings.HasPrefix(*group.GroupName, "awseb") { + legitGroups = append(legitGroups, *group.GroupId) + } + } + + sort.Strings(legitGroups) + + return strings.Join(legitGroups, ",") +} diff --git a/builtin/providers/aws/resource_aws_elastic_beanstalk_environment_test.go b/builtin/providers/aws/resource_aws_elastic_beanstalk_environment_test.go new file mode 100644 index 0000000000..6c2caa20b8 --- /dev/null +++ b/builtin/providers/aws/resource_aws_elastic_beanstalk_environment_test.go @@ -0,0 +1,185 @@ +package aws + +import ( + "fmt" + "log" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func TestAccAWSBeanstalkEnv_basic(t *testing.T) { + var app elasticbeanstalk.EnvironmentDescription + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBeanstalkEnvDestroy, + Steps: []resource.TestStep{ + resource.TestStep{ + Config: testAccBeanstalkEnvConfig, + Check: resource.ComposeTestCheckFunc( + testAccCheckBeanstalkEnvExists("aws_elastic_beanstalk_environment.tfenvtest", &app), + ), + }, + }, + }) +} + +func TestAccAWSBeanstalkEnv_tier(t *testing.T) { + var app elasticbeanstalk.EnvironmentDescription + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBeanstalkEnvDestroy, + Steps: []resource.TestStep{ + resource.TestStep{ + Config: testAccBeanstalkWorkerEnvConfig, + Check: resource.ComposeTestCheckFunc( + testAccCheckBeanstalkEnvTier("aws_elastic_beanstalk_environment.tfenvtest", &app), + ), + }, + }, + }) +} + +func testAccCheckBeanstalkEnvDestroy(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).elasticbeanstalkconn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_elastic_beanstalk_environment" { + continue + } + + // Try to find the environment + describeBeanstalkEnvOpts := &elasticbeanstalk.DescribeEnvironmentsInput{ + EnvironmentIds: []*string{aws.String(rs.Primary.ID)}, + } + resp, err := conn.DescribeEnvironments(describeBeanstalkEnvOpts) + if err == nil { + switch { + case len(resp.Environments) > 1: + return fmt.Errorf("Error %d environments match, expected 1", len(resp.Environments)) + case len(resp.Environments) == 1: + if *resp.Environments[0].Status == "Terminated" { + return nil + } + return fmt.Errorf("Elastic Beanstalk ENV still exists.") + default: + return nil + } + } + + // Verify the error is what we want + ec2err, ok := err.(awserr.Error) + if !ok { + return err + } + if ec2err.Code() != "InvalidBeanstalkEnvID.NotFound" { + return err + } + } + + return nil +} + +func testAccCheckBeanstalkEnvExists(n string, app *elasticbeanstalk.EnvironmentDescription) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[n] + if !ok { + return fmt.Errorf("Not found: %s", n) + } + + if rs.Primary.ID == "" { + return fmt.Errorf("Elastic Beanstalk ENV is not set") + } + + env, err := describeBeanstalkEnv(testAccProvider.Meta().(*AWSClient).elasticbeanstalkconn, aws.String(rs.Primary.ID)) + if err != nil { + return err + } + + *app = *env + + return nil + } +} + +func testAccCheckBeanstalkEnvTier(n string, app *elasticbeanstalk.EnvironmentDescription) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[n] + if !ok { + return fmt.Errorf("Not found: %s", n) + } + + if rs.Primary.ID == "" { + return fmt.Errorf("Elastic Beanstalk ENV is not set") + } + + env, err := describeBeanstalkEnv(testAccProvider.Meta().(*AWSClient).elasticbeanstalkconn, aws.String(rs.Primary.ID)) + if err != nil { + return err + } + if *env.Tier.Name != "Worker" { + return fmt.Errorf("Beanstalk Environment tier is %s, expected Worker", *env.Tier.Name) + } + + *app = *env + + 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 +} + +const testAccBeanstalkEnvConfig = ` +resource "aws_elastic_beanstalk_application" "tftest" { + name = "tf-test-name" + description = "tf-test-desc" +} + +resource "aws_elastic_beanstalk_environment" "tfenvtest" { + name = "tf-test-name" + application = "${aws_elastic_beanstalk_application.tftest.name}" + solution_stack_name = "64bit Amazon Linux 2015.09 v2.0.8 running Go 1.4" + #solution_stack_name = +} +` + +const testAccBeanstalkWorkerEnvConfig = ` +resource "aws_elastic_beanstalk_application" "tftest" { + name = "tf-test-name" + description = "tf-test-desc" +} + +resource "aws_elastic_beanstalk_environment" "tfenvtest" { + name = "tf-test-name" + application = "${aws_elastic_beanstalk_application.tftest.name}" + tier = "Worker" + solution_stack_name = "64bit Amazon Linux 2015.09 v2.0.4 running Go 1.4" +} +` diff --git a/builtin/providers/aws/tagsBeanstalk.go b/builtin/providers/aws/tagsBeanstalk.go new file mode 100644 index 0000000000..b54b77ee9f --- /dev/null +++ b/builtin/providers/aws/tagsBeanstalk.go @@ -0,0 +1,52 @@ +package aws + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" +) + +// diffTags takes our tags locally and the ones remotely and returns +// the set of tags that must be created, and the set of tags that must +// be destroyed. +func diffTagsBeanstalk(oldTags, newTags []*elasticbeanstalk.Tag) ([]*elasticbeanstalk.Tag, []*elasticbeanstalk.Tag) { + // First, we're creating everything we have + create := make(map[string]interface{}) + for _, t := range newTags { + create[*t.Key] = *t.Value + } + + // Build the list of what to remove + var remove []*elasticbeanstalk.Tag + for _, t := range oldTags { + old, ok := create[*t.Key] + if !ok || old != *t.Value { + // Delete it! + remove = append(remove, t) + } + } + + return tagsFromMapBeanstalk(create), remove +} + +// tagsFromMap returns the tags for the given map of data. +func tagsFromMapBeanstalk(m map[string]interface{}) []*elasticbeanstalk.Tag { + var result []*elasticbeanstalk.Tag + for k, v := range m { + result = append(result, &elasticbeanstalk.Tag{ + Key: aws.String(k), + Value: aws.String(v.(string)), + }) + } + + return result +} + +// tagsToMap turns the list of tags into a map. +func tagsToMapBeanstalk(ts []*elasticbeanstalk.Tag) map[string]string { + result := make(map[string]string) + for _, t := range ts { + result[*t.Key] = *t.Value + } + + return result +} diff --git a/builtin/providers/aws/tagsBeanstalk_test.go b/builtin/providers/aws/tagsBeanstalk_test.go new file mode 100644 index 0000000000..0a6613de65 --- /dev/null +++ b/builtin/providers/aws/tagsBeanstalk_test.go @@ -0,0 +1,85 @@ +package aws + +import ( + "fmt" + "reflect" + "testing" + + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func TestDiffBeanstalkTags(t *testing.T) { + cases := []struct { + Old, New map[string]interface{} + Create, Remove map[string]string + }{ + // Basic add/remove + { + Old: map[string]interface{}{ + "foo": "bar", + }, + New: map[string]interface{}{ + "bar": "baz", + }, + Create: map[string]string{ + "bar": "baz", + }, + Remove: map[string]string{ + "foo": "bar", + }, + }, + + // Modify + { + Old: map[string]interface{}{ + "foo": "bar", + }, + New: map[string]interface{}{ + "foo": "baz", + }, + Create: map[string]string{ + "foo": "baz", + }, + Remove: map[string]string{ + "foo": "bar", + }, + }, + } + + for i, tc := range cases { + c, r := diffTagsBeanstalk(tagsFromMapBeanstalk(tc.Old), tagsFromMapBeanstalk(tc.New)) + cm := tagsToMapBeanstalk(c) + rm := tagsToMapBeanstalk(r) + if !reflect.DeepEqual(cm, tc.Create) { + t.Fatalf("%d: bad create: %#v", i, cm) + } + if !reflect.DeepEqual(rm, tc.Remove) { + t.Fatalf("%d: bad remove: %#v", i, rm) + } + } +} + +// testAccCheckTags can be used to check the tags on a resource. +func testAccCheckBeanstalkTags( + ts *[]*elasticbeanstalk.Tag, key string, value string) resource.TestCheckFunc { + return func(s *terraform.State) error { + m := tagsToMapBeanstalk(*ts) + v, ok := m[key] + if value != "" && !ok { + return fmt.Errorf("Missing tag: %s", key) + } else if value == "" && ok { + return fmt.Errorf("Extra tag: %s", key) + } + if value == "" { + return nil + } + + if v != value { + return fmt.Errorf("%s: bad value: %s", key, v) + } + + return nil + } +} diff --git a/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/api.go b/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/api.go new file mode 100644 index 0000000000..906d60dcc2 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/api.go @@ -0,0 +1,3839 @@ +// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. + +// Package elasticbeanstalk provides a client for AWS Elastic Beanstalk. +package elasticbeanstalk + +import ( + "time" + + "github.com/aws/aws-sdk-go/aws/awsutil" + "github.com/aws/aws-sdk-go/aws/request" +) + +const opAbortEnvironmentUpdate = "AbortEnvironmentUpdate" + +// AbortEnvironmentUpdateRequest generates a request for the AbortEnvironmentUpdate operation. +func (c *ElasticBeanstalk) AbortEnvironmentUpdateRequest(input *AbortEnvironmentUpdateInput) (req *request.Request, output *AbortEnvironmentUpdateOutput) { + op := &request.Operation{ + Name: opAbortEnvironmentUpdate, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &AbortEnvironmentUpdateInput{} + } + + req = c.newRequest(op, input, output) + output = &AbortEnvironmentUpdateOutput{} + req.Data = output + return +} + +// Cancels in-progress environment configuration update or application version +// deployment. +func (c *ElasticBeanstalk) AbortEnvironmentUpdate(input *AbortEnvironmentUpdateInput) (*AbortEnvironmentUpdateOutput, error) { + req, out := c.AbortEnvironmentUpdateRequest(input) + err := req.Send() + return out, err +} + +const opCheckDNSAvailability = "CheckDNSAvailability" + +// CheckDNSAvailabilityRequest generates a request for the CheckDNSAvailability operation. +func (c *ElasticBeanstalk) CheckDNSAvailabilityRequest(input *CheckDNSAvailabilityInput) (req *request.Request, output *CheckDNSAvailabilityOutput) { + op := &request.Operation{ + Name: opCheckDNSAvailability, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &CheckDNSAvailabilityInput{} + } + + req = c.newRequest(op, input, output) + output = &CheckDNSAvailabilityOutput{} + req.Data = output + return +} + +// Checks if the specified CNAME is available. +func (c *ElasticBeanstalk) CheckDNSAvailability(input *CheckDNSAvailabilityInput) (*CheckDNSAvailabilityOutput, error) { + req, out := c.CheckDNSAvailabilityRequest(input) + err := req.Send() + return out, err +} + +const opComposeEnvironments = "ComposeEnvironments" + +// ComposeEnvironmentsRequest generates a request for the ComposeEnvironments operation. +func (c *ElasticBeanstalk) ComposeEnvironmentsRequest(input *ComposeEnvironmentsInput) (req *request.Request, output *EnvironmentDescriptionsMessage) { + op := &request.Operation{ + Name: opComposeEnvironments, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &ComposeEnvironmentsInput{} + } + + req = c.newRequest(op, input, output) + output = &EnvironmentDescriptionsMessage{} + req.Data = output + return +} + +// Create or update a group of environments that each run a separate component +// of a single application. Takes a list of version labels that specify application +// source bundles for each of the environments to create or update. The name +// of each environment and other required information must be included in the +// source bundles in an environment manifest named env.yaml. See Compose Environments +// (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environment-mgmt-compose.html) +// for details. +func (c *ElasticBeanstalk) ComposeEnvironments(input *ComposeEnvironmentsInput) (*EnvironmentDescriptionsMessage, error) { + req, out := c.ComposeEnvironmentsRequest(input) + err := req.Send() + return out, err +} + +const opCreateApplication = "CreateApplication" + +// CreateApplicationRequest generates a request for the CreateApplication operation. +func (c *ElasticBeanstalk) CreateApplicationRequest(input *CreateApplicationInput) (req *request.Request, output *ApplicationDescriptionMessage) { + op := &request.Operation{ + Name: opCreateApplication, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &CreateApplicationInput{} + } + + req = c.newRequest(op, input, output) + output = &ApplicationDescriptionMessage{} + req.Data = output + return +} + +// Creates an application that has one configuration template named default +// and no application versions. +func (c *ElasticBeanstalk) CreateApplication(input *CreateApplicationInput) (*ApplicationDescriptionMessage, error) { + req, out := c.CreateApplicationRequest(input) + err := req.Send() + return out, err +} + +const opCreateApplicationVersion = "CreateApplicationVersion" + +// CreateApplicationVersionRequest generates a request for the CreateApplicationVersion operation. +func (c *ElasticBeanstalk) CreateApplicationVersionRequest(input *CreateApplicationVersionInput) (req *request.Request, output *ApplicationVersionDescriptionMessage) { + op := &request.Operation{ + Name: opCreateApplicationVersion, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &CreateApplicationVersionInput{} + } + + req = c.newRequest(op, input, output) + output = &ApplicationVersionDescriptionMessage{} + req.Data = output + return +} + +// Creates an application version for the specified application. +// +// Once you create an application version with a specified Amazon S3 bucket +// and key location, you cannot change that Amazon S3 location. If you change +// the Amazon S3 location, you receive an exception when you attempt to launch +// an environment from the application version. +func (c *ElasticBeanstalk) CreateApplicationVersion(input *CreateApplicationVersionInput) (*ApplicationVersionDescriptionMessage, error) { + req, out := c.CreateApplicationVersionRequest(input) + err := req.Send() + return out, err +} + +const opCreateConfigurationTemplate = "CreateConfigurationTemplate" + +// CreateConfigurationTemplateRequest generates a request for the CreateConfigurationTemplate operation. +func (c *ElasticBeanstalk) CreateConfigurationTemplateRequest(input *CreateConfigurationTemplateInput) (req *request.Request, output *ConfigurationSettingsDescription) { + op := &request.Operation{ + Name: opCreateConfigurationTemplate, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &CreateConfigurationTemplateInput{} + } + + req = c.newRequest(op, input, output) + output = &ConfigurationSettingsDescription{} + req.Data = output + return +} + +// Creates a configuration template. Templates are associated with a specific +// application and are used to deploy different versions of the application +// with the same configuration settings. +// +// Related Topics +// +// DescribeConfigurationOptions DescribeConfigurationSettings ListAvailableSolutionStacks +func (c *ElasticBeanstalk) CreateConfigurationTemplate(input *CreateConfigurationTemplateInput) (*ConfigurationSettingsDescription, error) { + req, out := c.CreateConfigurationTemplateRequest(input) + err := req.Send() + return out, err +} + +const opCreateEnvironment = "CreateEnvironment" + +// CreateEnvironmentRequest generates a request for the CreateEnvironment operation. +func (c *ElasticBeanstalk) CreateEnvironmentRequest(input *CreateEnvironmentInput) (req *request.Request, output *EnvironmentDescription) { + op := &request.Operation{ + Name: opCreateEnvironment, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &CreateEnvironmentInput{} + } + + req = c.newRequest(op, input, output) + output = &EnvironmentDescription{} + req.Data = output + return +} + +// Launches an environment for the specified application using the specified +// configuration. +func (c *ElasticBeanstalk) CreateEnvironment(input *CreateEnvironmentInput) (*EnvironmentDescription, error) { + req, out := c.CreateEnvironmentRequest(input) + err := req.Send() + return out, err +} + +const opCreateStorageLocation = "CreateStorageLocation" + +// CreateStorageLocationRequest generates a request for the CreateStorageLocation operation. +func (c *ElasticBeanstalk) CreateStorageLocationRequest(input *CreateStorageLocationInput) (req *request.Request, output *CreateStorageLocationOutput) { + op := &request.Operation{ + Name: opCreateStorageLocation, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &CreateStorageLocationInput{} + } + + req = c.newRequest(op, input, output) + output = &CreateStorageLocationOutput{} + req.Data = output + return +} + +// Creates the Amazon S3 storage location for the account. +// +// This location is used to store user log files. +func (c *ElasticBeanstalk) CreateStorageLocation(input *CreateStorageLocationInput) (*CreateStorageLocationOutput, error) { + req, out := c.CreateStorageLocationRequest(input) + err := req.Send() + return out, err +} + +const opDeleteApplication = "DeleteApplication" + +// DeleteApplicationRequest generates a request for the DeleteApplication operation. +func (c *ElasticBeanstalk) DeleteApplicationRequest(input *DeleteApplicationInput) (req *request.Request, output *DeleteApplicationOutput) { + op := &request.Operation{ + Name: opDeleteApplication, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DeleteApplicationInput{} + } + + req = c.newRequest(op, input, output) + output = &DeleteApplicationOutput{} + req.Data = output + return +} + +// Deletes the specified application along with all associated versions and +// configurations. The application versions will not be deleted from your Amazon +// S3 bucket. +// +// You cannot delete an application that has a running environment. +func (c *ElasticBeanstalk) DeleteApplication(input *DeleteApplicationInput) (*DeleteApplicationOutput, error) { + req, out := c.DeleteApplicationRequest(input) + err := req.Send() + return out, err +} + +const opDeleteApplicationVersion = "DeleteApplicationVersion" + +// DeleteApplicationVersionRequest generates a request for the DeleteApplicationVersion operation. +func (c *ElasticBeanstalk) DeleteApplicationVersionRequest(input *DeleteApplicationVersionInput) (req *request.Request, output *DeleteApplicationVersionOutput) { + op := &request.Operation{ + Name: opDeleteApplicationVersion, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DeleteApplicationVersionInput{} + } + + req = c.newRequest(op, input, output) + output = &DeleteApplicationVersionOutput{} + req.Data = output + return +} + +// Deletes the specified version from the specified application. +// +// You cannot delete an application version that is associated with a running +// environment. +func (c *ElasticBeanstalk) DeleteApplicationVersion(input *DeleteApplicationVersionInput) (*DeleteApplicationVersionOutput, error) { + req, out := c.DeleteApplicationVersionRequest(input) + err := req.Send() + return out, err +} + +const opDeleteConfigurationTemplate = "DeleteConfigurationTemplate" + +// DeleteConfigurationTemplateRequest generates a request for the DeleteConfigurationTemplate operation. +func (c *ElasticBeanstalk) DeleteConfigurationTemplateRequest(input *DeleteConfigurationTemplateInput) (req *request.Request, output *DeleteConfigurationTemplateOutput) { + op := &request.Operation{ + Name: opDeleteConfigurationTemplate, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DeleteConfigurationTemplateInput{} + } + + req = c.newRequest(op, input, output) + output = &DeleteConfigurationTemplateOutput{} + req.Data = output + return +} + +// Deletes the specified configuration template. +// +// When you launch an environment using a configuration template, the environment +// gets a copy of the template. You can delete or modify the environment's copy +// of the template without affecting the running environment. +func (c *ElasticBeanstalk) DeleteConfigurationTemplate(input *DeleteConfigurationTemplateInput) (*DeleteConfigurationTemplateOutput, error) { + req, out := c.DeleteConfigurationTemplateRequest(input) + err := req.Send() + return out, err +} + +const opDeleteEnvironmentConfiguration = "DeleteEnvironmentConfiguration" + +// DeleteEnvironmentConfigurationRequest generates a request for the DeleteEnvironmentConfiguration operation. +func (c *ElasticBeanstalk) DeleteEnvironmentConfigurationRequest(input *DeleteEnvironmentConfigurationInput) (req *request.Request, output *DeleteEnvironmentConfigurationOutput) { + op := &request.Operation{ + Name: opDeleteEnvironmentConfiguration, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DeleteEnvironmentConfigurationInput{} + } + + req = c.newRequest(op, input, output) + output = &DeleteEnvironmentConfigurationOutput{} + req.Data = output + return +} + +// Deletes the draft configuration associated with the running environment. +// +// Updating a running environment with any configuration changes creates a +// draft configuration set. You can get the draft configuration using DescribeConfigurationSettings +// while the update is in progress or if the update fails. The DeploymentStatus +// for the draft configuration indicates whether the deployment is in process +// or has failed. The draft configuration remains in existence until it is deleted +// with this action. +func (c *ElasticBeanstalk) DeleteEnvironmentConfiguration(input *DeleteEnvironmentConfigurationInput) (*DeleteEnvironmentConfigurationOutput, error) { + req, out := c.DeleteEnvironmentConfigurationRequest(input) + err := req.Send() + return out, err +} + +const opDescribeApplicationVersions = "DescribeApplicationVersions" + +// DescribeApplicationVersionsRequest generates a request for the DescribeApplicationVersions operation. +func (c *ElasticBeanstalk) DescribeApplicationVersionsRequest(input *DescribeApplicationVersionsInput) (req *request.Request, output *DescribeApplicationVersionsOutput) { + op := &request.Operation{ + Name: opDescribeApplicationVersions, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeApplicationVersionsInput{} + } + + req = c.newRequest(op, input, output) + output = &DescribeApplicationVersionsOutput{} + req.Data = output + return +} + +// Retrieve a list of application versions stored in your AWS Elastic Beanstalk +// storage bucket. +func (c *ElasticBeanstalk) DescribeApplicationVersions(input *DescribeApplicationVersionsInput) (*DescribeApplicationVersionsOutput, error) { + req, out := c.DescribeApplicationVersionsRequest(input) + err := req.Send() + return out, err +} + +const opDescribeApplications = "DescribeApplications" + +// DescribeApplicationsRequest generates a request for the DescribeApplications operation. +func (c *ElasticBeanstalk) DescribeApplicationsRequest(input *DescribeApplicationsInput) (req *request.Request, output *DescribeApplicationsOutput) { + op := &request.Operation{ + Name: opDescribeApplications, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeApplicationsInput{} + } + + req = c.newRequest(op, input, output) + output = &DescribeApplicationsOutput{} + req.Data = output + return +} + +// Returns the descriptions of existing applications. +func (c *ElasticBeanstalk) DescribeApplications(input *DescribeApplicationsInput) (*DescribeApplicationsOutput, error) { + req, out := c.DescribeApplicationsRequest(input) + err := req.Send() + return out, err +} + +const opDescribeConfigurationOptions = "DescribeConfigurationOptions" + +// DescribeConfigurationOptionsRequest generates a request for the DescribeConfigurationOptions operation. +func (c *ElasticBeanstalk) DescribeConfigurationOptionsRequest(input *DescribeConfigurationOptionsInput) (req *request.Request, output *DescribeConfigurationOptionsOutput) { + op := &request.Operation{ + Name: opDescribeConfigurationOptions, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeConfigurationOptionsInput{} + } + + req = c.newRequest(op, input, output) + output = &DescribeConfigurationOptionsOutput{} + req.Data = output + return +} + +// Describes the configuration options that are used in a particular configuration +// template or environment, or that a specified solution stack defines. The +// description includes the values the options, their default values, and an +// indication of the required action on a running environment if an option value +// is changed. +func (c *ElasticBeanstalk) DescribeConfigurationOptions(input *DescribeConfigurationOptionsInput) (*DescribeConfigurationOptionsOutput, error) { + req, out := c.DescribeConfigurationOptionsRequest(input) + err := req.Send() + return out, err +} + +const opDescribeConfigurationSettings = "DescribeConfigurationSettings" + +// DescribeConfigurationSettingsRequest generates a request for the DescribeConfigurationSettings operation. +func (c *ElasticBeanstalk) DescribeConfigurationSettingsRequest(input *DescribeConfigurationSettingsInput) (req *request.Request, output *DescribeConfigurationSettingsOutput) { + op := &request.Operation{ + Name: opDescribeConfigurationSettings, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeConfigurationSettingsInput{} + } + + req = c.newRequest(op, input, output) + output = &DescribeConfigurationSettingsOutput{} + req.Data = output + return +} + +// Returns a description of the settings for the specified configuration set, +// that is, either a configuration template or the configuration set associated +// with a running environment. +// +// When describing the settings for the configuration set associated with +// a running environment, it is possible to receive two sets of setting descriptions. +// One is the deployed configuration set, and the other is a draft configuration +// of an environment that is either in the process of deployment or that failed +// to deploy. +// +// Related Topics +// +// DeleteEnvironmentConfiguration +func (c *ElasticBeanstalk) DescribeConfigurationSettings(input *DescribeConfigurationSettingsInput) (*DescribeConfigurationSettingsOutput, error) { + req, out := c.DescribeConfigurationSettingsRequest(input) + err := req.Send() + return out, err +} + +const opDescribeEnvironmentHealth = "DescribeEnvironmentHealth" + +// DescribeEnvironmentHealthRequest generates a request for the DescribeEnvironmentHealth operation. +func (c *ElasticBeanstalk) DescribeEnvironmentHealthRequest(input *DescribeEnvironmentHealthInput) (req *request.Request, output *DescribeEnvironmentHealthOutput) { + op := &request.Operation{ + Name: opDescribeEnvironmentHealth, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeEnvironmentHealthInput{} + } + + req = c.newRequest(op, input, output) + output = &DescribeEnvironmentHealthOutput{} + req.Data = output + return +} + +// Returns information about the overall health of the specified environment. +// The DescribeEnvironmentHealth operation is only available with AWS Elastic +// Beanstalk Enhanced Health. +func (c *ElasticBeanstalk) DescribeEnvironmentHealth(input *DescribeEnvironmentHealthInput) (*DescribeEnvironmentHealthOutput, error) { + req, out := c.DescribeEnvironmentHealthRequest(input) + err := req.Send() + return out, err +} + +const opDescribeEnvironmentResources = "DescribeEnvironmentResources" + +// DescribeEnvironmentResourcesRequest generates a request for the DescribeEnvironmentResources operation. +func (c *ElasticBeanstalk) DescribeEnvironmentResourcesRequest(input *DescribeEnvironmentResourcesInput) (req *request.Request, output *DescribeEnvironmentResourcesOutput) { + op := &request.Operation{ + Name: opDescribeEnvironmentResources, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeEnvironmentResourcesInput{} + } + + req = c.newRequest(op, input, output) + output = &DescribeEnvironmentResourcesOutput{} + req.Data = output + return +} + +// Returns AWS resources for this environment. +func (c *ElasticBeanstalk) DescribeEnvironmentResources(input *DescribeEnvironmentResourcesInput) (*DescribeEnvironmentResourcesOutput, error) { + req, out := c.DescribeEnvironmentResourcesRequest(input) + err := req.Send() + return out, err +} + +const opDescribeEnvironments = "DescribeEnvironments" + +// DescribeEnvironmentsRequest generates a request for the DescribeEnvironments operation. +func (c *ElasticBeanstalk) DescribeEnvironmentsRequest(input *DescribeEnvironmentsInput) (req *request.Request, output *EnvironmentDescriptionsMessage) { + op := &request.Operation{ + Name: opDescribeEnvironments, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeEnvironmentsInput{} + } + + req = c.newRequest(op, input, output) + output = &EnvironmentDescriptionsMessage{} + req.Data = output + return +} + +// Returns descriptions for existing environments. +func (c *ElasticBeanstalk) DescribeEnvironments(input *DescribeEnvironmentsInput) (*EnvironmentDescriptionsMessage, error) { + req, out := c.DescribeEnvironmentsRequest(input) + err := req.Send() + return out, err +} + +const opDescribeEvents = "DescribeEvents" + +// DescribeEventsRequest generates a request for the DescribeEvents operation. +func (c *ElasticBeanstalk) DescribeEventsRequest(input *DescribeEventsInput) (req *request.Request, output *DescribeEventsOutput) { + op := &request.Operation{ + Name: opDescribeEvents, + HTTPMethod: "POST", + HTTPPath: "/", + Paginator: &request.Paginator{ + InputTokens: []string{"NextToken"}, + OutputTokens: []string{"NextToken"}, + LimitToken: "MaxRecords", + TruncationToken: "", + }, + } + + if input == nil { + input = &DescribeEventsInput{} + } + + req = c.newRequest(op, input, output) + output = &DescribeEventsOutput{} + req.Data = output + return +} + +// Returns list of event descriptions matching criteria up to the last 6 weeks. +// +// This action returns the most recent 1,000 events from the specified NextToken. +func (c *ElasticBeanstalk) DescribeEvents(input *DescribeEventsInput) (*DescribeEventsOutput, error) { + req, out := c.DescribeEventsRequest(input) + err := req.Send() + return out, err +} + +func (c *ElasticBeanstalk) DescribeEventsPages(input *DescribeEventsInput, fn func(p *DescribeEventsOutput, lastPage bool) (shouldContinue bool)) error { + page, _ := c.DescribeEventsRequest(input) + page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator")) + return page.EachPage(func(p interface{}, lastPage bool) bool { + return fn(p.(*DescribeEventsOutput), lastPage) + }) +} + +const opDescribeInstancesHealth = "DescribeInstancesHealth" + +// DescribeInstancesHealthRequest generates a request for the DescribeInstancesHealth operation. +func (c *ElasticBeanstalk) DescribeInstancesHealthRequest(input *DescribeInstancesHealthInput) (req *request.Request, output *DescribeInstancesHealthOutput) { + op := &request.Operation{ + Name: opDescribeInstancesHealth, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeInstancesHealthInput{} + } + + req = c.newRequest(op, input, output) + output = &DescribeInstancesHealthOutput{} + req.Data = output + return +} + +// Returns more detailed information about the health of the specified instances +// (for example, CPU utilization, load average, and causes). The DescribeInstancesHealth +// operation is only available with AWS Elastic Beanstalk Enhanced Health. +func (c *ElasticBeanstalk) DescribeInstancesHealth(input *DescribeInstancesHealthInput) (*DescribeInstancesHealthOutput, error) { + req, out := c.DescribeInstancesHealthRequest(input) + err := req.Send() + return out, err +} + +const opListAvailableSolutionStacks = "ListAvailableSolutionStacks" + +// ListAvailableSolutionStacksRequest generates a request for the ListAvailableSolutionStacks operation. +func (c *ElasticBeanstalk) ListAvailableSolutionStacksRequest(input *ListAvailableSolutionStacksInput) (req *request.Request, output *ListAvailableSolutionStacksOutput) { + op := &request.Operation{ + Name: opListAvailableSolutionStacks, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &ListAvailableSolutionStacksInput{} + } + + req = c.newRequest(op, input, output) + output = &ListAvailableSolutionStacksOutput{} + req.Data = output + return +} + +// Returns a list of the available solution stack names. +func (c *ElasticBeanstalk) ListAvailableSolutionStacks(input *ListAvailableSolutionStacksInput) (*ListAvailableSolutionStacksOutput, error) { + req, out := c.ListAvailableSolutionStacksRequest(input) + err := req.Send() + return out, err +} + +const opRebuildEnvironment = "RebuildEnvironment" + +// RebuildEnvironmentRequest generates a request for the RebuildEnvironment operation. +func (c *ElasticBeanstalk) RebuildEnvironmentRequest(input *RebuildEnvironmentInput) (req *request.Request, output *RebuildEnvironmentOutput) { + op := &request.Operation{ + Name: opRebuildEnvironment, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &RebuildEnvironmentInput{} + } + + req = c.newRequest(op, input, output) + output = &RebuildEnvironmentOutput{} + req.Data = output + return +} + +// Deletes and recreates all of the AWS resources (for example: the Auto Scaling +// group, load balancer, etc.) for a specified environment and forces a restart. +func (c *ElasticBeanstalk) RebuildEnvironment(input *RebuildEnvironmentInput) (*RebuildEnvironmentOutput, error) { + req, out := c.RebuildEnvironmentRequest(input) + err := req.Send() + return out, err +} + +const opRequestEnvironmentInfo = "RequestEnvironmentInfo" + +// RequestEnvironmentInfoRequest generates a request for the RequestEnvironmentInfo operation. +func (c *ElasticBeanstalk) RequestEnvironmentInfoRequest(input *RequestEnvironmentInfoInput) (req *request.Request, output *RequestEnvironmentInfoOutput) { + op := &request.Operation{ + Name: opRequestEnvironmentInfo, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &RequestEnvironmentInfoInput{} + } + + req = c.newRequest(op, input, output) + output = &RequestEnvironmentInfoOutput{} + req.Data = output + return +} + +// Initiates a request to compile the specified type of information of the deployed +// environment. +// +// Setting the InfoType to tail compiles the last lines from the application +// server log files of every Amazon EC2 instance in your environment. +// +// Setting the InfoType to bundle compresses the application server log files +// for every Amazon EC2 instance into a .zip file. Legacy and .NET containers +// do not support bundle logs. +// +// Use RetrieveEnvironmentInfo to obtain the set of logs. +// +// Related Topics +// +// RetrieveEnvironmentInfo +func (c *ElasticBeanstalk) RequestEnvironmentInfo(input *RequestEnvironmentInfoInput) (*RequestEnvironmentInfoOutput, error) { + req, out := c.RequestEnvironmentInfoRequest(input) + err := req.Send() + return out, err +} + +const opRestartAppServer = "RestartAppServer" + +// RestartAppServerRequest generates a request for the RestartAppServer operation. +func (c *ElasticBeanstalk) RestartAppServerRequest(input *RestartAppServerInput) (req *request.Request, output *RestartAppServerOutput) { + op := &request.Operation{ + Name: opRestartAppServer, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &RestartAppServerInput{} + } + + req = c.newRequest(op, input, output) + output = &RestartAppServerOutput{} + req.Data = output + return +} + +// Causes the environment to restart the application container server running +// on each Amazon EC2 instance. +func (c *ElasticBeanstalk) RestartAppServer(input *RestartAppServerInput) (*RestartAppServerOutput, error) { + req, out := c.RestartAppServerRequest(input) + err := req.Send() + return out, err +} + +const opRetrieveEnvironmentInfo = "RetrieveEnvironmentInfo" + +// RetrieveEnvironmentInfoRequest generates a request for the RetrieveEnvironmentInfo operation. +func (c *ElasticBeanstalk) RetrieveEnvironmentInfoRequest(input *RetrieveEnvironmentInfoInput) (req *request.Request, output *RetrieveEnvironmentInfoOutput) { + op := &request.Operation{ + Name: opRetrieveEnvironmentInfo, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &RetrieveEnvironmentInfoInput{} + } + + req = c.newRequest(op, input, output) + output = &RetrieveEnvironmentInfoOutput{} + req.Data = output + return +} + +// Retrieves the compiled information from a RequestEnvironmentInfo request. +// +// Related Topics +// +// RequestEnvironmentInfo +func (c *ElasticBeanstalk) RetrieveEnvironmentInfo(input *RetrieveEnvironmentInfoInput) (*RetrieveEnvironmentInfoOutput, error) { + req, out := c.RetrieveEnvironmentInfoRequest(input) + err := req.Send() + return out, err +} + +const opSwapEnvironmentCNAMEs = "SwapEnvironmentCNAMEs" + +// SwapEnvironmentCNAMEsRequest generates a request for the SwapEnvironmentCNAMEs operation. +func (c *ElasticBeanstalk) SwapEnvironmentCNAMEsRequest(input *SwapEnvironmentCNAMEsInput) (req *request.Request, output *SwapEnvironmentCNAMEsOutput) { + op := &request.Operation{ + Name: opSwapEnvironmentCNAMEs, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &SwapEnvironmentCNAMEsInput{} + } + + req = c.newRequest(op, input, output) + output = &SwapEnvironmentCNAMEsOutput{} + req.Data = output + return +} + +// Swaps the CNAMEs of two environments. +func (c *ElasticBeanstalk) SwapEnvironmentCNAMEs(input *SwapEnvironmentCNAMEsInput) (*SwapEnvironmentCNAMEsOutput, error) { + req, out := c.SwapEnvironmentCNAMEsRequest(input) + err := req.Send() + return out, err +} + +const opTerminateEnvironment = "TerminateEnvironment" + +// TerminateEnvironmentRequest generates a request for the TerminateEnvironment operation. +func (c *ElasticBeanstalk) TerminateEnvironmentRequest(input *TerminateEnvironmentInput) (req *request.Request, output *EnvironmentDescription) { + op := &request.Operation{ + Name: opTerminateEnvironment, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &TerminateEnvironmentInput{} + } + + req = c.newRequest(op, input, output) + output = &EnvironmentDescription{} + req.Data = output + return +} + +// Terminates the specified environment. +func (c *ElasticBeanstalk) TerminateEnvironment(input *TerminateEnvironmentInput) (*EnvironmentDescription, error) { + req, out := c.TerminateEnvironmentRequest(input) + err := req.Send() + return out, err +} + +const opUpdateApplication = "UpdateApplication" + +// UpdateApplicationRequest generates a request for the UpdateApplication operation. +func (c *ElasticBeanstalk) UpdateApplicationRequest(input *UpdateApplicationInput) (req *request.Request, output *ApplicationDescriptionMessage) { + op := &request.Operation{ + Name: opUpdateApplication, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &UpdateApplicationInput{} + } + + req = c.newRequest(op, input, output) + output = &ApplicationDescriptionMessage{} + req.Data = output + return +} + +// Updates the specified application to have the specified properties. +// +// If a property (for example, description) is not provided, the value remains +// unchanged. To clear these properties, specify an empty string. +func (c *ElasticBeanstalk) UpdateApplication(input *UpdateApplicationInput) (*ApplicationDescriptionMessage, error) { + req, out := c.UpdateApplicationRequest(input) + err := req.Send() + return out, err +} + +const opUpdateApplicationVersion = "UpdateApplicationVersion" + +// UpdateApplicationVersionRequest generates a request for the UpdateApplicationVersion operation. +func (c *ElasticBeanstalk) UpdateApplicationVersionRequest(input *UpdateApplicationVersionInput) (req *request.Request, output *ApplicationVersionDescriptionMessage) { + op := &request.Operation{ + Name: opUpdateApplicationVersion, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &UpdateApplicationVersionInput{} + } + + req = c.newRequest(op, input, output) + output = &ApplicationVersionDescriptionMessage{} + req.Data = output + return +} + +// Updates the specified application version to have the specified properties. +// +// If a property (for example, description) is not provided, the value remains +// unchanged. To clear properties, specify an empty string. +func (c *ElasticBeanstalk) UpdateApplicationVersion(input *UpdateApplicationVersionInput) (*ApplicationVersionDescriptionMessage, error) { + req, out := c.UpdateApplicationVersionRequest(input) + err := req.Send() + return out, err +} + +const opUpdateConfigurationTemplate = "UpdateConfigurationTemplate" + +// UpdateConfigurationTemplateRequest generates a request for the UpdateConfigurationTemplate operation. +func (c *ElasticBeanstalk) UpdateConfigurationTemplateRequest(input *UpdateConfigurationTemplateInput) (req *request.Request, output *ConfigurationSettingsDescription) { + op := &request.Operation{ + Name: opUpdateConfigurationTemplate, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &UpdateConfigurationTemplateInput{} + } + + req = c.newRequest(op, input, output) + output = &ConfigurationSettingsDescription{} + req.Data = output + return +} + +// Updates the specified configuration template to have the specified properties +// or configuration option values. +// +// If a property (for example, ApplicationName) is not provided, its value +// remains unchanged. To clear such properties, specify an empty string. Related +// Topics +// +// DescribeConfigurationOptions +func (c *ElasticBeanstalk) UpdateConfigurationTemplate(input *UpdateConfigurationTemplateInput) (*ConfigurationSettingsDescription, error) { + req, out := c.UpdateConfigurationTemplateRequest(input) + err := req.Send() + return out, err +} + +const opUpdateEnvironment = "UpdateEnvironment" + +// UpdateEnvironmentRequest generates a request for the UpdateEnvironment operation. +func (c *ElasticBeanstalk) UpdateEnvironmentRequest(input *UpdateEnvironmentInput) (req *request.Request, output *EnvironmentDescription) { + op := &request.Operation{ + Name: opUpdateEnvironment, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &UpdateEnvironmentInput{} + } + + req = c.newRequest(op, input, output) + output = &EnvironmentDescription{} + req.Data = output + return +} + +// Updates the environment description, deploys a new application version, updates +// the configuration settings to an entirely new configuration template, or +// updates select configuration option values in the running environment. +// +// Attempting to update both the release and configuration is not allowed +// and AWS Elastic Beanstalk returns an InvalidParameterCombination error. +// +// When updating the configuration settings to a new template or individual +// settings, a draft configuration is created and DescribeConfigurationSettings +// for this environment returns two setting descriptions with different DeploymentStatus +// values. +func (c *ElasticBeanstalk) UpdateEnvironment(input *UpdateEnvironmentInput) (*EnvironmentDescription, error) { + req, out := c.UpdateEnvironmentRequest(input) + err := req.Send() + return out, err +} + +const opValidateConfigurationSettings = "ValidateConfigurationSettings" + +// ValidateConfigurationSettingsRequest generates a request for the ValidateConfigurationSettings operation. +func (c *ElasticBeanstalk) ValidateConfigurationSettingsRequest(input *ValidateConfigurationSettingsInput) (req *request.Request, output *ValidateConfigurationSettingsOutput) { + op := &request.Operation{ + Name: opValidateConfigurationSettings, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &ValidateConfigurationSettingsInput{} + } + + req = c.newRequest(op, input, output) + output = &ValidateConfigurationSettingsOutput{} + req.Data = output + return +} + +// Takes a set of configuration settings and either a configuration template +// or environment, and determines whether those values are valid. +// +// This action returns a list of messages indicating any errors or warnings +// associated with the selection of option values. +func (c *ElasticBeanstalk) ValidateConfigurationSettings(input *ValidateConfigurationSettingsInput) (*ValidateConfigurationSettingsOutput, error) { + req, out := c.ValidateConfigurationSettingsRequest(input) + err := req.Send() + return out, err +} + +type AbortEnvironmentUpdateInput struct { + _ struct{} `type:"structure"` + + // This specifies the ID of the environment with the in-progress update that + // you want to cancel. + EnvironmentId *string `type:"string"` + + // This specifies the name of the environment with the in-progress update that + // you want to cancel. + EnvironmentName *string `min:"4" type:"string"` +} + +// String returns the string representation +func (s AbortEnvironmentUpdateInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s AbortEnvironmentUpdateInput) GoString() string { + return s.String() +} + +type AbortEnvironmentUpdateOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s AbortEnvironmentUpdateOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s AbortEnvironmentUpdateOutput) GoString() string { + return s.String() +} + +// Describes the properties of an application. +type ApplicationDescription struct { + _ struct{} `type:"structure"` + + // The name of the application. + ApplicationName *string `min:"1" type:"string"` + + // The names of the configuration templates associated with this application. + ConfigurationTemplates []*string `type:"list"` + + // The date when the application was created. + DateCreated *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // The date when the application was last modified. + DateUpdated *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // User-defined description of the application. + Description *string `type:"string"` + + // The names of the versions for this application. + Versions []*string `type:"list"` +} + +// String returns the string representation +func (s ApplicationDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ApplicationDescription) GoString() string { + return s.String() +} + +// Result message containing a single description of an application. +type ApplicationDescriptionMessage struct { + _ struct{} `type:"structure"` + + // The ApplicationDescription of the application. + Application *ApplicationDescription `type:"structure"` +} + +// String returns the string representation +func (s ApplicationDescriptionMessage) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ApplicationDescriptionMessage) GoString() string { + return s.String() +} + +// Represents the application metrics for a specified environment. +type ApplicationMetrics struct { + _ struct{} `type:"structure"` + + // The amount of time that the metrics cover (usually 10 seconds). For example, + // you might have 5 requests (request_count) within the most recent time slice + // of 10 seconds (duration). + Duration *int64 `type:"integer"` + + // Represents the average latency for the slowest X percent of requests over + // the last 10 seconds. Latencies are in seconds with one milisecond resolution. + Latency *Latency `type:"structure"` + + // Average number of requests handled by the web server per second over the + // last 10 seconds. + RequestCount *int64 `type:"integer"` + + // Represents the percentage of requests over the last 10 seconds that resulted + // in each type of status code response. + StatusCodes *StatusCodes `type:"structure"` +} + +// String returns the string representation +func (s ApplicationMetrics) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ApplicationMetrics) GoString() string { + return s.String() +} + +// Describes the properties of an application version. +type ApplicationVersionDescription struct { + _ struct{} `type:"structure"` + + // The name of the application associated with this release. + ApplicationName *string `min:"1" type:"string"` + + // The creation date of the application version. + DateCreated *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // The last modified date of the application version. + DateUpdated *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // The description of this application version. + Description *string `type:"string"` + + // The location where the source bundle is located for this version. + SourceBundle *S3Location `type:"structure"` + + // The processing status of the application version. + Status *string `type:"string" enum:"ApplicationVersionStatus"` + + // A label uniquely identifying the version for the associated application. + VersionLabel *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s ApplicationVersionDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ApplicationVersionDescription) GoString() string { + return s.String() +} + +// Result message wrapping a single description of an application version. +type ApplicationVersionDescriptionMessage struct { + _ struct{} `type:"structure"` + + // The ApplicationVersionDescription of the application version. + ApplicationVersion *ApplicationVersionDescription `type:"structure"` +} + +// String returns the string representation +func (s ApplicationVersionDescriptionMessage) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ApplicationVersionDescriptionMessage) GoString() string { + return s.String() +} + +// Describes an Auto Scaling launch configuration. +type AutoScalingGroup struct { + _ struct{} `type:"structure"` + + // The name of the AutoScalingGroup . + Name *string `type:"string"` +} + +// String returns the string representation +func (s AutoScalingGroup) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s AutoScalingGroup) GoString() string { + return s.String() +} + +// Represents CPU utilization information from the specified instance that belongs +// to the AWS Elastic Beanstalk environment. Use the instanceId property to +// specify the application instance for which you'd like to return data. +type CPUUtilization struct { + _ struct{} `type:"structure"` + + // Percentage of time that the CPU has spent in the I/O Wait state over the + // last 10 seconds. + IOWait *float64 `type:"double"` + + // Percentage of time that the CPU has spent in the IRQ state over the last + // 10 seconds. + IRQ *float64 `type:"double"` + + // Percentage of time that the CPU has spent in the Idle state over the last + // 10 seconds. + Idle *float64 `type:"double"` + + // Percentage of time that the CPU has spent in the Nice state over the last + // 10 seconds. + Nice *float64 `type:"double"` + + // Percentage of time that the CPU has spent in the SoftIRQ state over the last + // 10 seconds. + SoftIRQ *float64 `type:"double"` + + // Percentage of time that the CPU has spent in the System state over the last + // 10 seconds. + System *float64 `type:"double"` + + // Percentage of time that the CPU has spent in the User state over the last + // 10 seconds. + User *float64 `type:"double"` +} + +// String returns the string representation +func (s CPUUtilization) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CPUUtilization) GoString() string { + return s.String() +} + +// Results message indicating whether a CNAME is available. +type CheckDNSAvailabilityInput struct { + _ struct{} `type:"structure"` + + // The prefix used when this CNAME is reserved. + CNAMEPrefix *string `min:"4" type:"string" required:"true"` +} + +// String returns the string representation +func (s CheckDNSAvailabilityInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CheckDNSAvailabilityInput) GoString() string { + return s.String() +} + +// Indicates if the specified CNAME is available. +type CheckDNSAvailabilityOutput struct { + _ struct{} `type:"structure"` + + // Indicates if the specified CNAME is available: + // + // true : The CNAME is available. false : The CNAME is not available. + Available *bool `type:"boolean"` + + // The fully qualified CNAME to reserve when CreateEnvironment is called with + // the provided prefix. + FullyQualifiedCNAME *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s CheckDNSAvailabilityOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CheckDNSAvailabilityOutput) GoString() string { + return s.String() +} + +type ComposeEnvironmentsInput struct { + _ struct{} `type:"structure"` + + // The name of the application to which the specified source bundles belong. + ApplicationName *string `min:"1" type:"string"` + + // The name of the group to which the target environments belong. Specify a + // group name only if the environment name defined in each target environment's + // manifest ends with a + (plus) character. See Environment Manifest (env.yaml) + // (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environment-mgmt-compose.html#environment-mgmt-compose-envyaml) + // for details. + GroupName *string `min:"1" type:"string"` + + // A list of version labels, specifying one or more application source bundles + // that belong to the target application. Each source bundle must include an + // environment manifest that specifies the name of the environment and the name + // of the solution stack to use, and optionally can specify environment links + // to create. + VersionLabels []*string `type:"list"` +} + +// String returns the string representation +func (s ComposeEnvironmentsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ComposeEnvironmentsInput) GoString() string { + return s.String() +} + +// Describes the possible values for a configuration option. +type ConfigurationOptionDescription struct { + _ struct{} `type:"structure"` + + // An indication of which action is required if the value for this configuration + // option changes: + // + // NoInterruption : There is no interruption to the environment or application + // availability. RestartEnvironment : The environment is entirely restarted, + // all AWS resources are deleted and recreated, and the environment is unavailable + // during the process. RestartApplicationServer : The environment is available + // the entire time. However, a short application outage occurs when the application + // servers on the running Amazon EC2 instances are restarted. + ChangeSeverity *string `type:"string"` + + // The default value for this configuration option. + DefaultValue *string `type:"string"` + + // If specified, the configuration option must be a string value no longer than + // this value. + MaxLength *int64 `type:"integer"` + + // If specified, the configuration option must be a numeric value less than + // this value. + MaxValue *int64 `type:"integer"` + + // If specified, the configuration option must be a numeric value greater than + // this value. + MinValue *int64 `type:"integer"` + + // The name of the configuration option. + Name *string `type:"string"` + + // A unique namespace identifying the option's associated AWS resource. + Namespace *string `type:"string"` + + // If specified, the configuration option must be a string value that satisfies + // this regular expression. + Regex *OptionRestrictionRegex `type:"structure"` + + // An indication of whether the user defined this configuration option: + // + // true : This configuration option was defined by the user. It is a valid + // choice for specifying if this as an Option to Remove when updating configuration + // settings. + // + // false : This configuration was not defined by the user. Constraint: + // You can remove only UserDefined options from a configuration. + // + // Valid Values: true | false + UserDefined *bool `type:"boolean"` + + // If specified, values for the configuration option are selected from this + // list. + ValueOptions []*string `type:"list"` + + // An indication of which type of values this option has and whether it is allowable + // to select one or more than one of the possible values: + // + // Scalar : Values for this option are a single selection from the possible + // values, or an unformatted string, or numeric value governed by the MIN/MAX/Regex + // constraints. List : Values for this option are multiple selections from + // the possible values. Boolean : Values for this option are either true or + // false . Json : Values for this option are a JSON representation of a ConfigDocument. + ValueType *string `type:"string" enum:"ConfigurationOptionValueType"` +} + +// String returns the string representation +func (s ConfigurationOptionDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ConfigurationOptionDescription) GoString() string { + return s.String() +} + +// A specification identifying an individual configuration option along with +// its current value. For a list of possible option values, go to Option Values +// (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/command-options.html) +// in the AWS Elastic Beanstalk Developer Guide. +type ConfigurationOptionSetting struct { + _ struct{} `type:"structure"` + + // A unique namespace identifying the option's associated AWS resource. + Namespace *string `type:"string"` + + // The name of the configuration option. + OptionName *string `type:"string"` + + // A unique resource name for a time-based scaling configuration option. + ResourceName *string `min:"1" type:"string"` + + // The current value for the configuration option. + Value *string `type:"string"` +} + +// String returns the string representation +func (s ConfigurationOptionSetting) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ConfigurationOptionSetting) GoString() string { + return s.String() +} + +// Describes the settings for a configuration set. +type ConfigurationSettingsDescription struct { + _ struct{} `type:"structure"` + + // The name of the application associated with this configuration set. + ApplicationName *string `min:"1" type:"string"` + + // The date (in UTC time) when this configuration set was created. + DateCreated *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // The date (in UTC time) when this configuration set was last modified. + DateUpdated *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // If this configuration set is associated with an environment, the DeploymentStatus + // parameter indicates the deployment status of this configuration set: + // + // null: This configuration is not associated with a running environment. + // pending: This is a draft configuration that is not deployed to the associated + // environment but is in the process of deploying. deployed: This is the configuration + // that is currently deployed to the associated running environment. failed: + // This is a draft configuration that failed to successfully deploy. + DeploymentStatus *string `type:"string" enum:"ConfigurationDeploymentStatus"` + + // Describes this configuration set. + Description *string `type:"string"` + + // If not null, the name of the environment for this configuration set. + EnvironmentName *string `min:"4" type:"string"` + + // A list of the configuration options and their values in this configuration + // set. + OptionSettings []*ConfigurationOptionSetting `type:"list"` + + // The name of the solution stack this configuration set uses. + SolutionStackName *string `type:"string"` + + // If not null, the name of the configuration template for this configuration + // set. + TemplateName *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s ConfigurationSettingsDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ConfigurationSettingsDescription) GoString() string { + return s.String() +} + +type CreateApplicationInput struct { + _ struct{} `type:"structure"` + + // The name of the application. + // + // Constraint: This name must be unique within your account. If the specified + // name already exists, the action returns an InvalidParameterValue error. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // Describes the application. + Description *string `type:"string"` +} + +// String returns the string representation +func (s CreateApplicationInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CreateApplicationInput) GoString() string { + return s.String() +} + +type CreateApplicationVersionInput struct { + _ struct{} `type:"structure"` + + // The name of the application. If no application is found with this name, and + // AutoCreateApplication is false, returns an InvalidParameterValue error. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // Determines how the system behaves if the specified application for this version + // does not already exist: + // + // true : Automatically creates the specified application for this release + // if it does not already exist. false : Throws an InvalidParameterValue if + // the specified application for this release does not already exist. Default: + // false + // + // Valid Values: true | false + AutoCreateApplication *bool `type:"boolean"` + + // Describes this version. + Description *string `type:"string"` + + // Preprocesses and validates the environment manifest and configuration files + // in the source bundle. Validating configuration files can identify issues + // prior to deploying the application version to an environment. + Process *bool `type:"boolean"` + + // The Amazon S3 bucket and key that identify the location of the source bundle + // for this version. + // + // If data found at the Amazon S3 location exceeds the maximum allowed source + // bundle size, AWS Elastic Beanstalk returns an InvalidParameterValue error. + // The maximum size allowed is 512 MB. + // + // Default: If not specified, AWS Elastic Beanstalk uses a sample application. + // If only partially specified (for example, a bucket is provided but not the + // key) or if no data is found at the Amazon S3 location, AWS Elastic Beanstalk + // returns an InvalidParameterCombination error. + SourceBundle *S3Location `type:"structure"` + + // A label identifying this version. + // + // Constraint: Must be unique per application. If an application version already + // exists with this label for the specified application, AWS Elastic Beanstalk + // returns an InvalidParameterValue error. + VersionLabel *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s CreateApplicationVersionInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CreateApplicationVersionInput) GoString() string { + return s.String() +} + +type CreateConfigurationTemplateInput struct { + _ struct{} `type:"structure"` + + // The name of the application to associate with this configuration template. + // If no application is found with this name, AWS Elastic Beanstalk returns + // an InvalidParameterValue error. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // Describes this configuration. + Description *string `type:"string"` + + // The ID of the environment used with this configuration template. + EnvironmentId *string `type:"string"` + + // If specified, AWS Elastic Beanstalk sets the specified configuration option + // to the requested value. The new value overrides the value obtained from the + // solution stack or the source configuration template. + OptionSettings []*ConfigurationOptionSetting `type:"list"` + + // The name of the solution stack used by this configuration. The solution stack + // specifies the operating system, architecture, and application server for + // a configuration template. It determines the set of configuration options + // as well as the possible and default values. + // + // Use ListAvailableSolutionStacks to obtain a list of available solution + // stacks. + // + // A solution stack name or a source configuration parameter must be specified, + // otherwise AWS Elastic Beanstalk returns an InvalidParameterValue error. + // + // If a solution stack name is not specified and the source configuration + // parameter is specified, AWS Elastic Beanstalk uses the same solution stack + // as the source configuration template. + SolutionStackName *string `type:"string"` + + // If specified, AWS Elastic Beanstalk uses the configuration values from the + // specified configuration template to create a new configuration. + // + // Values specified in the OptionSettings parameter of this call overrides + // any values obtained from the SourceConfiguration. + // + // If no configuration template is found, returns an InvalidParameterValue + // error. + // + // Constraint: If both the solution stack name parameter and the source configuration + // parameters are specified, the solution stack of the source configuration + // template must match the specified solution stack name or else AWS Elastic + // Beanstalk returns an InvalidParameterCombination error. + SourceConfiguration *SourceConfiguration `type:"structure"` + + // The name of the configuration template. + // + // Constraint: This name must be unique per application. + // + // Default: If a configuration template already exists with this name, AWS + // Elastic Beanstalk returns an InvalidParameterValue error. + TemplateName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s CreateConfigurationTemplateInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CreateConfigurationTemplateInput) GoString() string { + return s.String() +} + +type CreateEnvironmentInput struct { + _ struct{} `type:"structure"` + + // The name of the application that contains the version to be deployed. + // + // If no application is found with this name, CreateEnvironment returns an + // InvalidParameterValue error. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // If specified, the environment attempts to use this value as the prefix for + // the CNAME. If not specified, the CNAME is generated automatically by appending + // a random alphanumeric string to the environment name. + CNAMEPrefix *string `min:"4" type:"string"` + + // Describes this environment. + Description *string `type:"string"` + + // A unique name for the deployment environment. Used in the application URL. + // + // Constraint: Must be from 4 to 23 characters in length. The name can contain + // only letters, numbers, and hyphens. It cannot start or end with a hyphen. + // This name must be unique in your account. If the specified name already exists, + // AWS Elastic Beanstalk returns an InvalidParameterValue error. + // + // Default: If the CNAME parameter is not specified, the environment name becomes + // part of the CNAME, and therefore part of the visible URL for your application. + EnvironmentName *string `min:"4" type:"string"` + + // The name of the group to which the target environment belongs. Specify a + // group name only if the environment's name is specified in an environment + // manifest and not with the environment name parameter. See Environment Manifest + // (env.yaml) (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environment-mgmt-compose.html#environment-mgmt-compose-envyaml) + // for details. + GroupName *string `min:"1" type:"string"` + + // If specified, AWS Elastic Beanstalk sets the specified configuration options + // to the requested value in the configuration set for the new environment. + // These override the values obtained from the solution stack or the configuration + // template. + OptionSettings []*ConfigurationOptionSetting `type:"list"` + + // A list of custom user-defined configuration options to remove from the configuration + // set for this new environment. + OptionsToRemove []*OptionSpecification `type:"list"` + + // This is an alternative to specifying a template name. If specified, AWS Elastic + // Beanstalk sets the configuration values to the default values associated + // with the specified solution stack. + // + // Condition: You must specify either this or a TemplateName, but not both. + // If you specify both, AWS Elastic Beanstalk returns an InvalidParameterCombination + // error. If you do not specify either, AWS Elastic Beanstalk returns a MissingRequiredParameter + // error. + SolutionStackName *string `type:"string"` + + // This specifies the tags applied to resources in the environment. + Tags []*Tag `type:"list"` + + // The name of the configuration template to use in deployment. If no configuration + // template is found with this name, AWS Elastic Beanstalk returns an InvalidParameterValue + // error. + // + // Condition: You must specify either this parameter or a SolutionStackName, + // but not both. If you specify both, AWS Elastic Beanstalk returns an InvalidParameterCombination + // error. If you do not specify either, AWS Elastic Beanstalk returns a MissingRequiredParameter + // error. + TemplateName *string `min:"1" type:"string"` + + // This specifies the tier to use for creating this environment. + Tier *EnvironmentTier `type:"structure"` + + // The name of the application version to deploy. + // + // If the specified application has no associated application versions, AWS + // Elastic Beanstalk UpdateEnvironment returns an InvalidParameterValue error. + // + // Default: If not specified, AWS Elastic Beanstalk attempts to launch the + // sample application in the container. + VersionLabel *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s CreateEnvironmentInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CreateEnvironmentInput) GoString() string { + return s.String() +} + +type CreateStorageLocationInput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s CreateStorageLocationInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CreateStorageLocationInput) GoString() string { + return s.String() +} + +// Results of a CreateStorageLocationResult call. +type CreateStorageLocationOutput struct { + _ struct{} `type:"structure"` + + // The name of the Amazon S3 bucket created. + S3Bucket *string `type:"string"` +} + +// String returns the string representation +func (s CreateStorageLocationOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CreateStorageLocationOutput) GoString() string { + return s.String() +} + +type DeleteApplicationInput struct { + _ struct{} `type:"structure"` + + // The name of the application to delete. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // When set to true, running environments will be terminated before deleting + // the application. + TerminateEnvByForce *bool `type:"boolean"` +} + +// String returns the string representation +func (s DeleteApplicationInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteApplicationInput) GoString() string { + return s.String() +} + +type DeleteApplicationOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DeleteApplicationOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteApplicationOutput) GoString() string { + return s.String() +} + +type DeleteApplicationVersionInput struct { + _ struct{} `type:"structure"` + + // The name of the application to delete releases from. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // Indicates whether to delete the associated source bundle from Amazon S3: + // + // true: An attempt is made to delete the associated Amazon S3 source bundle + // specified at time of creation. false: No action is taken on the Amazon + // S3 source bundle specified at time of creation. Valid Values: true | false + DeleteSourceBundle *bool `type:"boolean"` + + // The label of the version to delete. + VersionLabel *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s DeleteApplicationVersionInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteApplicationVersionInput) GoString() string { + return s.String() +} + +type DeleteApplicationVersionOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DeleteApplicationVersionOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteApplicationVersionOutput) GoString() string { + return s.String() +} + +type DeleteConfigurationTemplateInput struct { + _ struct{} `type:"structure"` + + // The name of the application to delete the configuration template from. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // The name of the configuration template to delete. + TemplateName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s DeleteConfigurationTemplateInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteConfigurationTemplateInput) GoString() string { + return s.String() +} + +type DeleteConfigurationTemplateOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DeleteConfigurationTemplateOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteConfigurationTemplateOutput) GoString() string { + return s.String() +} + +type DeleteEnvironmentConfigurationInput struct { + _ struct{} `type:"structure"` + + // The name of the application the environment is associated with. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // The name of the environment to delete the draft configuration from. + EnvironmentName *string `min:"4" type:"string" required:"true"` +} + +// String returns the string representation +func (s DeleteEnvironmentConfigurationInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteEnvironmentConfigurationInput) GoString() string { + return s.String() +} + +type DeleteEnvironmentConfigurationOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DeleteEnvironmentConfigurationOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteEnvironmentConfigurationOutput) GoString() string { + return s.String() +} + +// Result message containing a list of configuration descriptions. +type DescribeApplicationVersionsInput struct { + _ struct{} `type:"structure"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // only include ones that are associated with the specified application. + ApplicationName *string `min:"1" type:"string"` + + // If specified, restricts the returned descriptions to only include ones that + // have the specified version labels. + VersionLabels []*string `type:"list"` +} + +// String returns the string representation +func (s DescribeApplicationVersionsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeApplicationVersionsInput) GoString() string { + return s.String() +} + +// Result message wrapping a list of application version descriptions. +type DescribeApplicationVersionsOutput struct { + _ struct{} `type:"structure"` + + // List of ApplicationVersionDescription objects sorted by order of creation. + ApplicationVersions []*ApplicationVersionDescription `type:"list"` +} + +// String returns the string representation +func (s DescribeApplicationVersionsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeApplicationVersionsOutput) GoString() string { + return s.String() +} + +type DescribeApplicationsInput struct { + _ struct{} `type:"structure"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // only include those with the specified names. + ApplicationNames []*string `type:"list"` +} + +// String returns the string representation +func (s DescribeApplicationsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeApplicationsInput) GoString() string { + return s.String() +} + +// Result message containing a list of application descriptions. +type DescribeApplicationsOutput struct { + _ struct{} `type:"structure"` + + // This parameter contains a list of ApplicationDescription. + Applications []*ApplicationDescription `type:"list"` +} + +// String returns the string representation +func (s DescribeApplicationsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeApplicationsOutput) GoString() string { + return s.String() +} + +// Result message containig a list of application version descriptions. +type DescribeConfigurationOptionsInput struct { + _ struct{} `type:"structure"` + + // The name of the application associated with the configuration template or + // environment. Only needed if you want to describe the configuration options + // associated with either the configuration template or environment. + ApplicationName *string `min:"1" type:"string"` + + // The name of the environment whose configuration options you want to describe. + EnvironmentName *string `min:"4" type:"string"` + + // If specified, restricts the descriptions to only the specified options. + Options []*OptionSpecification `type:"list"` + + // The name of the solution stack whose configuration options you want to describe. + SolutionStackName *string `type:"string"` + + // The name of the configuration template whose configuration options you want + // to describe. + TemplateName *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s DescribeConfigurationOptionsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeConfigurationOptionsInput) GoString() string { + return s.String() +} + +// Describes the settings for a specified configuration set. +type DescribeConfigurationOptionsOutput struct { + _ struct{} `type:"structure"` + + // A list of ConfigurationOptionDescription. + Options []*ConfigurationOptionDescription `type:"list"` + + // The name of the solution stack these configuration options belong to. + SolutionStackName *string `type:"string"` +} + +// String returns the string representation +func (s DescribeConfigurationOptionsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeConfigurationOptionsOutput) GoString() string { + return s.String() +} + +// Result message containing all of the configuration settings for a specified +// solution stack or configuration template. +type DescribeConfigurationSettingsInput struct { + _ struct{} `type:"structure"` + + // The application for the environment or configuration template. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // The name of the environment to describe. + // + // Condition: You must specify either this or a TemplateName, but not both. + // If you specify both, AWS Elastic Beanstalk returns an InvalidParameterCombination + // error. If you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentName *string `min:"4" type:"string"` + + // The name of the configuration template to describe. + // + // Conditional: You must specify either this parameter or an EnvironmentName, + // but not both. If you specify both, AWS Elastic Beanstalk returns an InvalidParameterCombination + // error. If you do not specify either, AWS Elastic Beanstalk returns a MissingRequiredParameter + // error. + TemplateName *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s DescribeConfigurationSettingsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeConfigurationSettingsInput) GoString() string { + return s.String() +} + +// The results from a request to change the configuration settings of an environment. +type DescribeConfigurationSettingsOutput struct { + _ struct{} `type:"structure"` + + // A list of ConfigurationSettingsDescription. + ConfigurationSettings []*ConfigurationSettingsDescription `type:"list"` +} + +// String returns the string representation +func (s DescribeConfigurationSettingsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeConfigurationSettingsOutput) GoString() string { + return s.String() +} + +// See the example below to learn how to create a request body. +type DescribeEnvironmentHealthInput struct { + _ struct{} `type:"structure"` + + // Specifies the response elements you wish to receive. If no attribute names + // are specified, AWS Elastic Beanstalk only returns the name of the environment. + AttributeNames []*string `type:"list"` + + // Specifies the AWS Elastic Beanstalk environment ID. + // + // Condition: You must specify either this or an EnvironmentName, or both. + // If you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentId *string `type:"string"` + + // Specifies the AWS Elastic Beanstalk environment name. + // + // Condition: You must specify either this or an EnvironmentId, or both. If + // you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentName *string `min:"4" type:"string"` +} + +// String returns the string representation +func (s DescribeEnvironmentHealthInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeEnvironmentHealthInput) GoString() string { + return s.String() +} + +// See the example below for a sample response. +type DescribeEnvironmentHealthOutput struct { + _ struct{} `type:"structure"` + + // Represents the application metrics for a specified environment. + ApplicationMetrics *ApplicationMetrics `type:"structure"` + + // Returns potential causes for the reported status. + Causes []*string `type:"list"` + + // Returns the color indicator that tells you information about the health of + // the environment. For more information, see Health Colors and Statuses (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html). + Color *string `type:"string"` + + // The AWS Elastic Beanstalk environment name. + EnvironmentName *string `min:"4" type:"string"` + + // Contains the response body with information about the health of the environment. + HealthStatus *string `type:"string"` + + // Represents summary information about the health of an instance. For more + // information, see Health Colors and Statuses (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html). + InstancesHealth *InstanceHealthSummary `type:"structure"` + + // The date and time the information was last refreshed. + RefreshedAt *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // Returns the health status value of the environment. For more information, + // see Health Colors and Statuses (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html). + Status *string `type:"string" enum:"EnvironmentHealth"` +} + +// String returns the string representation +func (s DescribeEnvironmentHealthOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeEnvironmentHealthOutput) GoString() string { + return s.String() +} + +type DescribeEnvironmentResourcesInput struct { + _ struct{} `type:"structure"` + + // The ID of the environment to retrieve AWS resource usage data. + // + // Condition: You must specify either this or an EnvironmentName, or both. + // If you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentId *string `type:"string"` + + // The name of the environment to retrieve AWS resource usage data. + // + // Condition: You must specify either this or an EnvironmentId, or both. If + // you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentName *string `min:"4" type:"string"` +} + +// String returns the string representation +func (s DescribeEnvironmentResourcesInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeEnvironmentResourcesInput) GoString() string { + return s.String() +} + +// Result message containing a list of environment resource descriptions. +type DescribeEnvironmentResourcesOutput struct { + _ struct{} `type:"structure"` + + // A list of EnvironmentResourceDescription. + EnvironmentResources *EnvironmentResourceDescription `type:"structure"` +} + +// String returns the string representation +func (s DescribeEnvironmentResourcesOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeEnvironmentResourcesOutput) GoString() string { + return s.String() +} + +type DescribeEnvironmentsInput struct { + _ struct{} `type:"structure"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // include only those that are associated with this application. + ApplicationName *string `min:"1" type:"string"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // include only those that have the specified IDs. + EnvironmentIds []*string `type:"list"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // include only those that have the specified names. + EnvironmentNames []*string `type:"list"` + + // Indicates whether to include deleted environments: + // + // true: Environments that have been deleted after IncludedDeletedBackTo are + // displayed. + // + // false: Do not include deleted environments. + IncludeDeleted *bool `type:"boolean"` + + // If specified when IncludeDeleted is set to true, then environments deleted + // after this date are displayed. + IncludedDeletedBackTo *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // include only those that are associated with this application version. + VersionLabel *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s DescribeEnvironmentsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeEnvironmentsInput) GoString() string { + return s.String() +} + +type DescribeEventsInput struct { + _ struct{} `type:"structure"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // include only those associated with this application. + ApplicationName *string `min:"1" type:"string"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // those that occur up to, but not including, the EndTime. + EndTime *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // those associated with this environment. + EnvironmentId *string `type:"string"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // those associated with this environment. + EnvironmentName *string `min:"4" type:"string"` + + // Specifies the maximum number of events that can be returned, beginning with + // the most recent event. + MaxRecords *int64 `min:"1" type:"integer"` + + // Pagination token. If specified, the events return the next batch of results. + NextToken *string `type:"string"` + + // If specified, AWS Elastic Beanstalk restricts the described events to include + // only those associated with this request ID. + RequestId *string `type:"string"` + + // If specified, limits the events returned from this call to include only those + // with the specified severity or higher. + Severity *string `type:"string" enum:"EventSeverity"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // those that occur on or after this time. + StartTime *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // those that are associated with this environment configuration. + TemplateName *string `min:"1" type:"string"` + + // If specified, AWS Elastic Beanstalk restricts the returned descriptions to + // those associated with this application version. + VersionLabel *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s DescribeEventsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeEventsInput) GoString() string { + return s.String() +} + +// Result message wrapping a list of event descriptions. +type DescribeEventsOutput struct { + _ struct{} `type:"structure"` + + // A list of EventDescription. + Events []*EventDescription `type:"list"` + + // If returned, this indicates that there are more results to obtain. Use this + // token in the next DescribeEvents call to get the next batch of events. + NextToken *string `type:"string"` +} + +// String returns the string representation +func (s DescribeEventsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeEventsOutput) GoString() string { + return s.String() +} + +// See the example below to learn how to create a request body. +type DescribeInstancesHealthInput struct { + _ struct{} `type:"structure"` + + // Specifies the response elements you wish to receive. If no attribute names + // are specified, AWS Elastic Beanstalk only returns a list of instances. + AttributeNames []*string `type:"list"` + + // Specifies the AWS Elastic Beanstalk environment ID. + EnvironmentId *string `type:"string"` + + // Specifies the AWS Elastic Beanstalk environment name. + EnvironmentName *string `min:"4" type:"string"` + + // Specifies the next token of the request. + NextToken *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s DescribeInstancesHealthInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeInstancesHealthInput) GoString() string { + return s.String() +} + +// See the example below for a sample response. +type DescribeInstancesHealthOutput struct { + _ struct{} `type:"structure"` + + // Contains the response body with information about the health of the instance. + InstanceHealthList []*SingleInstanceHealth `type:"list"` + + // The next token. + NextToken *string `min:"1" type:"string"` + + // The date and time the information was last refreshed. + RefreshedAt *time.Time `type:"timestamp" timestampFormat:"iso8601"` +} + +// String returns the string representation +func (s DescribeInstancesHealthOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeInstancesHealthOutput) GoString() string { + return s.String() +} + +// Describes the properties of an environment. +type EnvironmentDescription struct { + _ struct{} `type:"structure"` + + // Indicates if there is an in-progress environment configuration update or + // application version deployment that you can cancel. + // + // true: There is an update in progress. + // + // false: There are no updates currently in progress. + AbortableOperationInProgress *bool `type:"boolean"` + + // The name of the application associated with this environment. + ApplicationName *string `min:"1" type:"string"` + + // The URL to the CNAME for this environment. + CNAME *string `min:"1" type:"string"` + + // The creation date for this environment. + DateCreated *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // The last modified date for this environment. + DateUpdated *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // Describes this environment. + Description *string `type:"string"` + + // For load-balanced, autoscaling environments, the URL to the LoadBalancer. + // For single-instance environments, the IP address of the instance. + EndpointURL *string `type:"string"` + + // The ID of this environment. + EnvironmentId *string `type:"string"` + + // A list of links to other environments in the same group. + EnvironmentLinks []*EnvironmentLink `type:"list"` + + // The name of this environment. + EnvironmentName *string `min:"4" type:"string"` + + // Describes the health status of the environment. AWS Elastic Beanstalk indicates + // the failure levels for a running environment: + // + // Red: Indicates the environment is not responsive. Occurs when three or + // more consecutive failures occur for an environment. Yellow: Indicates that + // something is wrong. Occurs when two consecutive failures occur for an environment. + // Green: Indicates the environment is healthy and fully functional. Grey: + // Default health for a new environment. The environment is not fully launched + // and health checks have not started or health checks are suspended during + // an UpdateEnvironment or RestartEnvironement request. Default: Grey + Health *string `type:"string" enum:"EnvironmentHealth"` + + // Returns the health status of the application running in your environment. + // For more information, see Health Colors and Statuses (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html). + HealthStatus *string `type:"string" enum:"EnvironmentHealthStatus"` + + // The description of the AWS resources used by this environment. + Resources *EnvironmentResourcesDescription `type:"structure"` + + // The name of the SolutionStack deployed with this environment. + SolutionStackName *string `type:"string"` + + // The current operational status of the environment: + // + // Launching: Environment is in the process of initial deployment. Updating: + // Environment is in the process of updating its configuration settings or application + // version. Ready: Environment is available to have an action performed on + // it, such as update or terminate. Terminating: Environment is in the shut-down + // process. Terminated: Environment is not running. + Status *string `type:"string" enum:"EnvironmentStatus"` + + // The name of the configuration template used to originally launch this environment. + TemplateName *string `min:"1" type:"string"` + + // Describes the current tier of this environment. + Tier *EnvironmentTier `type:"structure"` + + // The application version deployed in this environment. + VersionLabel *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s EnvironmentDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnvironmentDescription) GoString() string { + return s.String() +} + +// Result message containing a list of environment descriptions. +type EnvironmentDescriptionsMessage struct { + _ struct{} `type:"structure"` + + // Returns an EnvironmentDescription list. + Environments []*EnvironmentDescription `type:"list"` +} + +// String returns the string representation +func (s EnvironmentDescriptionsMessage) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnvironmentDescriptionsMessage) GoString() string { + return s.String() +} + +// The information retrieved from the Amazon EC2 instances. +type EnvironmentInfoDescription struct { + _ struct{} `type:"structure"` + + // The Amazon EC2 Instance ID for this information. + Ec2InstanceId *string `type:"string"` + + // The type of information retrieved. + InfoType *string `type:"string" enum:"EnvironmentInfoType"` + + // The retrieved information. + Message *string `type:"string"` + + // The time stamp when this information was retrieved. + SampleTimestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"` +} + +// String returns the string representation +func (s EnvironmentInfoDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnvironmentInfoDescription) GoString() string { + return s.String() +} + +// A link to another environment, defined in the environment's manifest. Links +// provide connection information in system properties that can be used to connect +// to another environment in the same group. See Environment Manifest (env.yaml) +// (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environment-mgmt-compose.html#environment-mgmt-compose-envyaml) +// for details. +type EnvironmentLink struct { + _ struct{} `type:"structure"` + + // The name of the linked environment (the dependency). + EnvironmentName *string `type:"string"` + + // The name of the link. + LinkName *string `type:"string"` +} + +// String returns the string representation +func (s EnvironmentLink) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnvironmentLink) GoString() string { + return s.String() +} + +// Describes the AWS resources in use by this environment. This data is live. +type EnvironmentResourceDescription struct { + _ struct{} `type:"structure"` + + // The AutoScalingGroups used by this environment. + AutoScalingGroups []*AutoScalingGroup `type:"list"` + + // The name of the environment. + EnvironmentName *string `min:"4" type:"string"` + + // The Amazon EC2 instances used by this environment. + Instances []*Instance `type:"list"` + + // The Auto Scaling launch configurations in use by this environment. + LaunchConfigurations []*LaunchConfiguration `type:"list"` + + // The LoadBalancers in use by this environment. + LoadBalancers []*LoadBalancer `type:"list"` + + // The queues used by this environment. + Queues []*Queue `type:"list"` + + // The AutoScaling triggers in use by this environment. + Triggers []*Trigger `type:"list"` +} + +// String returns the string representation +func (s EnvironmentResourceDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnvironmentResourceDescription) GoString() string { + return s.String() +} + +// Describes the AWS resources in use by this environment. This data is not +// live data. +type EnvironmentResourcesDescription struct { + _ struct{} `type:"structure"` + + // Describes the LoadBalancer. + LoadBalancer *LoadBalancerDescription `type:"structure"` +} + +// String returns the string representation +func (s EnvironmentResourcesDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnvironmentResourcesDescription) GoString() string { + return s.String() +} + +// Describes the properties of an environment tier +type EnvironmentTier struct { + _ struct{} `type:"structure"` + + // The name of this environment tier. + Name *string `type:"string"` + + // The type of this environment tier. + Type *string `type:"string"` + + // The version of this environment tier. + Version *string `type:"string"` +} + +// String returns the string representation +func (s EnvironmentTier) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnvironmentTier) GoString() string { + return s.String() +} + +// Describes an event. +type EventDescription struct { + _ struct{} `type:"structure"` + + // The application associated with the event. + ApplicationName *string `min:"1" type:"string"` + + // The name of the environment associated with this event. + EnvironmentName *string `min:"4" type:"string"` + + // The date when the event occurred. + EventDate *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // The event message. + Message *string `type:"string"` + + // The web service request ID for the activity of this event. + RequestId *string `type:"string"` + + // The severity level of this event. + Severity *string `type:"string" enum:"EventSeverity"` + + // The name of the configuration associated with this event. + TemplateName *string `min:"1" type:"string"` + + // The release label for the application version associated with this event. + VersionLabel *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s EventDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EventDescription) GoString() string { + return s.String() +} + +// The description of an Amazon EC2 instance. +type Instance struct { + _ struct{} `type:"structure"` + + // The ID of the Amazon EC2 instance. + Id *string `type:"string"` +} + +// String returns the string representation +func (s Instance) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Instance) GoString() string { + return s.String() +} + +// Represents summary information about the health of an instance. For more +// information, see Health Colors and Statuses (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html). +type InstanceHealthSummary struct { + _ struct{} `type:"structure"` + + // Red. The health agent is reporting a high number of request failures or other + // issues for an instance or environment. + Degraded *int64 `type:"integer"` + + // Green. An operation is in progress on an instance. + Info *int64 `type:"integer"` + + // Grey. AWS Elastic Beanstalk and the health agent are reporting no data on + // an instance. + NoData *int64 `type:"integer"` + + // Green. An instance is passing health checks and the health agent is not reporting + // any problems. + Ok *int64 `type:"integer"` + + // Grey. An operation is in progress on an instance within the command timeout. + Pending *int64 `type:"integer"` + + // Red. The health agent is reporting a very high number of request failures + // or other issues for an instance or environment. + Severe *int64 `type:"integer"` + + // Grey. AWS Elastic Beanstalk and the health agent are reporting an insufficient + // amount of data on an instance. + Unknown *int64 `type:"integer"` + + // Yellow. The health agent is reporting a moderate number of request failures + // or other issues for an instance or environment. + Warning *int64 `type:"integer"` +} + +// String returns the string representation +func (s InstanceHealthSummary) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s InstanceHealthSummary) GoString() string { + return s.String() +} + +// Represents the average latency for the slowest X percent of requests over +// the last 10 seconds. +type Latency struct { + _ struct{} `type:"structure"` + + // The average latency for the slowest 90 percent of requests over the last + // 10 seconds. + P10 *float64 `type:"double"` + + // The average latency for the slowest 50 percent of requests over the last + // 10 seconds. + P50 *float64 `type:"double"` + + // The average latency for the slowest 25 percent of requests over the last + // 10 seconds. + P75 *float64 `type:"double"` + + // The average latency for the slowest 15 percent of requests over the last + // 10 seconds. + P85 *float64 `type:"double"` + + // The average latency for the slowest 10 percent of requests over the last + // 10 seconds. + P90 *float64 `type:"double"` + + // The average latency for the slowest 5 percent of requests over the last 10 + // seconds. + P95 *float64 `type:"double"` + + // The average latency for the slowest 1 percent of requests over the last 10 + // seconds. + P99 *float64 `type:"double"` + + // The average latency for the slowest 0.1 percent of requests over the last + // 10 seconds. + P999 *float64 `type:"double"` +} + +// String returns the string representation +func (s Latency) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Latency) GoString() string { + return s.String() +} + +// Describes an Auto Scaling launch configuration. +type LaunchConfiguration struct { + _ struct{} `type:"structure"` + + // The name of the launch configuration. + Name *string `type:"string"` +} + +// String returns the string representation +func (s LaunchConfiguration) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s LaunchConfiguration) GoString() string { + return s.String() +} + +type ListAvailableSolutionStacksInput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s ListAvailableSolutionStacksInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListAvailableSolutionStacksInput) GoString() string { + return s.String() +} + +// A list of available AWS Elastic Beanstalk solution stacks. +type ListAvailableSolutionStacksOutput struct { + _ struct{} `type:"structure"` + + // A list of available solution stacks and their SolutionStackDescription. + SolutionStackDetails []*SolutionStackDescription `type:"list"` + + // A list of available solution stacks. + SolutionStacks []*string `type:"list"` +} + +// String returns the string representation +func (s ListAvailableSolutionStacksOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListAvailableSolutionStacksOutput) GoString() string { + return s.String() +} + +// Describes the properties of a Listener for the LoadBalancer. +type Listener struct { + _ struct{} `type:"structure"` + + // The port that is used by the Listener. + Port *int64 `type:"integer"` + + // The protocol that is used by the Listener. + Protocol *string `type:"string"` +} + +// String returns the string representation +func (s Listener) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Listener) GoString() string { + return s.String() +} + +// Describes a LoadBalancer. +type LoadBalancer struct { + _ struct{} `type:"structure"` + + // The name of the LoadBalancer. + Name *string `type:"string"` +} + +// String returns the string representation +func (s LoadBalancer) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s LoadBalancer) GoString() string { + return s.String() +} + +// Describes the details of a LoadBalancer. +type LoadBalancerDescription struct { + _ struct{} `type:"structure"` + + // The domain name of the LoadBalancer. + Domain *string `type:"string"` + + // A list of Listeners used by the LoadBalancer. + Listeners []*Listener `type:"list"` + + // The name of the LoadBalancer. + LoadBalancerName *string `type:"string"` +} + +// String returns the string representation +func (s LoadBalancerDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s LoadBalancerDescription) GoString() string { + return s.String() +} + +// A regular expression representing a restriction on a string configuration +// option value. +type OptionRestrictionRegex struct { + _ struct{} `type:"structure"` + + // A unique name representing this regular expression. + Label *string `type:"string"` + + // The regular expression pattern that a string configuration option value with + // this restriction must match. + Pattern *string `type:"string"` +} + +// String returns the string representation +func (s OptionRestrictionRegex) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s OptionRestrictionRegex) GoString() string { + return s.String() +} + +// A specification identifying an individual configuration option. +type OptionSpecification struct { + _ struct{} `type:"structure"` + + // A unique namespace identifying the option's associated AWS resource. + Namespace *string `type:"string"` + + // The name of the configuration option. + OptionName *string `type:"string"` + + // A unique resource name for a time-based scaling configuration option. + ResourceName *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s OptionSpecification) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s OptionSpecification) GoString() string { + return s.String() +} + +// Describes a queue. +type Queue struct { + _ struct{} `type:"structure"` + + // The name of the queue. + Name *string `type:"string"` + + // The URL of the queue. + URL *string `type:"string"` +} + +// String returns the string representation +func (s Queue) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Queue) GoString() string { + return s.String() +} + +type RebuildEnvironmentInput struct { + _ struct{} `type:"structure"` + + // The ID of the environment to rebuild. + // + // Condition: You must specify either this or an EnvironmentName, or both. + // If you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentId *string `type:"string"` + + // The name of the environment to rebuild. + // + // Condition: You must specify either this or an EnvironmentId, or both. If + // you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentName *string `min:"4" type:"string"` +} + +// String returns the string representation +func (s RebuildEnvironmentInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RebuildEnvironmentInput) GoString() string { + return s.String() +} + +type RebuildEnvironmentOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s RebuildEnvironmentOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RebuildEnvironmentOutput) GoString() string { + return s.String() +} + +type RequestEnvironmentInfoInput struct { + _ struct{} `type:"structure"` + + // The ID of the environment of the requested data. + // + // If no such environment is found, RequestEnvironmentInfo returns an InvalidParameterValue + // error. + // + // Condition: You must specify either this or an EnvironmentName, or both. + // If you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentId *string `type:"string"` + + // The name of the environment of the requested data. + // + // If no such environment is found, RequestEnvironmentInfo returns an InvalidParameterValue + // error. + // + // Condition: You must specify either this or an EnvironmentId, or both. If + // you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentName *string `min:"4" type:"string"` + + // The type of information to request. + InfoType *string `type:"string" required:"true" enum:"EnvironmentInfoType"` +} + +// String returns the string representation +func (s RequestEnvironmentInfoInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RequestEnvironmentInfoInput) GoString() string { + return s.String() +} + +type RequestEnvironmentInfoOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s RequestEnvironmentInfoOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RequestEnvironmentInfoOutput) GoString() string { + return s.String() +} + +type RestartAppServerInput struct { + _ struct{} `type:"structure"` + + // The ID of the environment to restart the server for. + // + // Condition: You must specify either this or an EnvironmentName, or both. + // If you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentId *string `type:"string"` + + // The name of the environment to restart the server for. + // + // Condition: You must specify either this or an EnvironmentId, or both. If + // you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentName *string `min:"4" type:"string"` +} + +// String returns the string representation +func (s RestartAppServerInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RestartAppServerInput) GoString() string { + return s.String() +} + +type RestartAppServerOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s RestartAppServerOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RestartAppServerOutput) GoString() string { + return s.String() +} + +type RetrieveEnvironmentInfoInput struct { + _ struct{} `type:"structure"` + + // The ID of the data's environment. + // + // If no such environment is found, returns an InvalidParameterValue error. + // + // Condition: You must specify either this or an EnvironmentName, or both. + // If you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentId *string `type:"string"` + + // The name of the data's environment. + // + // If no such environment is found, returns an InvalidParameterValue error. + // + // Condition: You must specify either this or an EnvironmentId, or both. If + // you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentName *string `min:"4" type:"string"` + + // The type of information to retrieve. + InfoType *string `type:"string" required:"true" enum:"EnvironmentInfoType"` +} + +// String returns the string representation +func (s RetrieveEnvironmentInfoInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RetrieveEnvironmentInfoInput) GoString() string { + return s.String() +} + +// Result message containing a description of the requested environment info. +type RetrieveEnvironmentInfoOutput struct { + _ struct{} `type:"structure"` + + // The EnvironmentInfoDescription of the environment. + EnvironmentInfo []*EnvironmentInfoDescription `type:"list"` +} + +// String returns the string representation +func (s RetrieveEnvironmentInfoOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RetrieveEnvironmentInfoOutput) GoString() string { + return s.String() +} + +// A specification of a location in Amazon S3. +type S3Location struct { + _ struct{} `type:"structure"` + + // The Amazon S3 bucket where the data is located. + S3Bucket *string `type:"string"` + + // The Amazon S3 key where the data is located. + S3Key *string `type:"string"` +} + +// String returns the string representation +func (s S3Location) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s S3Location) GoString() string { + return s.String() +} + +// Represents health information from the specified instance that belongs to +// the AWS Elastic Beanstalk environment. Use the InstanceId property to specify +// the application instance for which you'd like to return data. +type SingleInstanceHealth struct { + _ struct{} `type:"structure"` + + // Represents the application metrics for a specified environment. + ApplicationMetrics *ApplicationMetrics `type:"structure"` + + // Represents the causes, which provide more information about the current health + // status. + Causes []*string `type:"list"` + + // Represents the color indicator that gives you information about the health + // of the EC2 instance. For more information, see Health Colors and Statuses + // (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html). + Color *string `type:"string"` + + // Returns the health status of the specified instance. For more information, + // see Health Colors and Statuses (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html). + HealthStatus *string `type:"string"` + + // The ID of the Amazon EC2 instance. + InstanceId *string `min:"1" type:"string"` + + // The time at which the EC2 instance was launched. + LaunchedAt *time.Time `type:"timestamp" timestampFormat:"iso8601"` + + // Represents CPU utilization and load average information for applications + // running in the specified environment. + System *SystemStatus `type:"structure"` +} + +// String returns the string representation +func (s SingleInstanceHealth) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SingleInstanceHealth) GoString() string { + return s.String() +} + +// Describes the solution stack. +type SolutionStackDescription struct { + _ struct{} `type:"structure"` + + // The permitted file types allowed for a solution stack. + PermittedFileTypes []*string `type:"list"` + + // The name of the solution stack. + SolutionStackName *string `type:"string"` +} + +// String returns the string representation +func (s SolutionStackDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SolutionStackDescription) GoString() string { + return s.String() +} + +// A specification for an environment configuration +type SourceConfiguration struct { + _ struct{} `type:"structure"` + + // The name of the application associated with the configuration. + ApplicationName *string `min:"1" type:"string"` + + // The name of the configuration template. + TemplateName *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s SourceConfiguration) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SourceConfiguration) GoString() string { + return s.String() +} + +// Represents the percentage of requests over the last 10 seconds that resulted +// in each type of status code response. For more information, see Status Code +// Definitions (http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html). +type StatusCodes struct { + _ struct{} `type:"structure"` + + // The percentage of requests over the last 10 seconds that resulted in a 2xx + // (200, 201, etc.) status code. + Status2xx *int64 `type:"integer"` + + // The percentage of requests over the last 10 seconds that resulted in a 3xx + // (300, 301, etc.) status code. + Status3xx *int64 `type:"integer"` + + // The percentage of requests over the last 10 seconds that resulted in a 4xx + // (400, 401, etc.) status code. + Status4xx *int64 `type:"integer"` + + // The percentage of requests over the last 10 seconds that resulted in a 5xx + // (500, 501, etc.) status code. + Status5xx *int64 `type:"integer"` +} + +// String returns the string representation +func (s StatusCodes) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s StatusCodes) GoString() string { + return s.String() +} + +// Swaps the CNAMEs of two environments. +type SwapEnvironmentCNAMEsInput struct { + _ struct{} `type:"structure"` + + // The ID of the destination environment. + // + // Condition: You must specify at least the DestinationEnvironmentID or the + // DestinationEnvironmentName. You may also specify both. You must specify the + // SourceEnvironmentId with the DestinationEnvironmentId. + DestinationEnvironmentId *string `type:"string"` + + // The name of the destination environment. + // + // Condition: You must specify at least the DestinationEnvironmentID or the + // DestinationEnvironmentName. You may also specify both. You must specify the + // SourceEnvironmentName with the DestinationEnvironmentName. + DestinationEnvironmentName *string `min:"4" type:"string"` + + // The ID of the source environment. + // + // Condition: You must specify at least the SourceEnvironmentID or the SourceEnvironmentName. + // You may also specify both. If you specify the SourceEnvironmentId, you must + // specify the DestinationEnvironmentId. + SourceEnvironmentId *string `type:"string"` + + // The name of the source environment. + // + // Condition: You must specify at least the SourceEnvironmentID or the SourceEnvironmentName. + // You may also specify both. If you specify the SourceEnvironmentName, you + // must specify the DestinationEnvironmentName. + SourceEnvironmentName *string `min:"4" type:"string"` +} + +// String returns the string representation +func (s SwapEnvironmentCNAMEsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SwapEnvironmentCNAMEsInput) GoString() string { + return s.String() +} + +type SwapEnvironmentCNAMEsOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s SwapEnvironmentCNAMEsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SwapEnvironmentCNAMEsOutput) GoString() string { + return s.String() +} + +// Represents CPU utilization and load average information for applications +// running in the specified environment. +type SystemStatus struct { + _ struct{} `type:"structure"` + + // Represents CPU utilization information from the specified instance that belongs + // to the AWS Elastic Beanstalk environment. Use the instanceId property to + // specify the application instance for which you'd like to return data. + CPUUtilization *CPUUtilization `type:"structure"` + + // Load average in the last 1-minute and 5-minute periods. For more information, + // see Operating System Metrics (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-metrics.html#health-enhanced-metrics-os). + LoadAverage []*float64 `type:"list"` +} + +// String returns the string representation +func (s SystemStatus) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SystemStatus) GoString() string { + return s.String() +} + +// Describes a tag applied to a resource in an environment. +type Tag struct { + _ struct{} `type:"structure"` + + // The key of the tag. + Key *string `min:"1" type:"string"` + + // The value of the tag. + Value *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s Tag) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Tag) GoString() string { + return s.String() +} + +type TerminateEnvironmentInput struct { + _ struct{} `type:"structure"` + + // The ID of the environment to terminate. + // + // Condition: You must specify either this or an EnvironmentName, or both. + // If you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentId *string `type:"string"` + + // The name of the environment to terminate. + // + // Condition: You must specify either this or an EnvironmentId, or both. If + // you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentName *string `min:"4" type:"string"` + + // Terminates the target environment even if another environment in the same + // group is dependent on it. + ForceTerminate *bool `type:"boolean"` + + // Indicates whether the associated AWS resources should shut down when the + // environment is terminated: + // + // true: The specified environment as well as the associated AWS resources, + // such as Auto Scaling group and LoadBalancer, are terminated. false: AWS + // Elastic Beanstalk resource management is removed from the environment, but + // the AWS resources continue to operate. For more information, see the + // AWS Elastic Beanstalk User Guide. (http://docs.aws.amazon.com/elasticbeanstalk/latest/ug/) + // + // Default: true + // + // Valid Values: true | false + TerminateResources *bool `type:"boolean"` +} + +// String returns the string representation +func (s TerminateEnvironmentInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s TerminateEnvironmentInput) GoString() string { + return s.String() +} + +// Describes a trigger. +type Trigger struct { + _ struct{} `type:"structure"` + + // The name of the trigger. + Name *string `type:"string"` +} + +// String returns the string representation +func (s Trigger) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Trigger) GoString() string { + return s.String() +} + +type UpdateApplicationInput struct { + _ struct{} `type:"structure"` + + // The name of the application to update. If no such application is found, UpdateApplication + // returns an InvalidParameterValue error. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // A new description for the application. + // + // Default: If not specified, AWS Elastic Beanstalk does not update the description. + Description *string `type:"string"` +} + +// String returns the string representation +func (s UpdateApplicationInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateApplicationInput) GoString() string { + return s.String() +} + +type UpdateApplicationVersionInput struct { + _ struct{} `type:"structure"` + + // The name of the application associated with this version. + // + // If no application is found with this name, UpdateApplication returns an + // InvalidParameterValue error. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // A new description for this release. + Description *string `type:"string"` + + // The name of the version to update. + // + // If no application version is found with this label, UpdateApplication returns + // an InvalidParameterValue error. + VersionLabel *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s UpdateApplicationVersionInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateApplicationVersionInput) GoString() string { + return s.String() +} + +// The result message containing the options for the specified solution stack. +type UpdateConfigurationTemplateInput struct { + _ struct{} `type:"structure"` + + // The name of the application associated with the configuration template to + // update. + // + // If no application is found with this name, UpdateConfigurationTemplate + // returns an InvalidParameterValue error. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // A new description for the configuration. + Description *string `type:"string"` + + // A list of configuration option settings to update with the new specified + // option value. + OptionSettings []*ConfigurationOptionSetting `type:"list"` + + // A list of configuration options to remove from the configuration set. + // + // Constraint: You can remove only UserDefined configuration options. + OptionsToRemove []*OptionSpecification `type:"list"` + + // The name of the configuration template to update. + // + // If no configuration template is found with this name, UpdateConfigurationTemplate + // returns an InvalidParameterValue error. + TemplateName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s UpdateConfigurationTemplateInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateConfigurationTemplateInput) GoString() string { + return s.String() +} + +type UpdateEnvironmentInput struct { + _ struct{} `type:"structure"` + + // The name of the application with which the environment is associated. + ApplicationName *string `min:"1" type:"string"` + + // If this parameter is specified, AWS Elastic Beanstalk updates the description + // of this environment. + Description *string `type:"string"` + + // The ID of the environment to update. + // + // If no environment with this ID exists, AWS Elastic Beanstalk returns an + // InvalidParameterValue error. + // + // Condition: You must specify either this or an EnvironmentName, or both. + // If you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentId *string `type:"string"` + + // The name of the environment to update. If no environment with this name exists, + // AWS Elastic Beanstalk returns an InvalidParameterValue error. + // + // Condition: You must specify either this or an EnvironmentId, or both. If + // you do not specify either, AWS Elastic Beanstalk returns MissingRequiredParameter + // error. + EnvironmentName *string `min:"4" type:"string"` + + // The name of the group to which the target environment belongs. Specify a + // group name only if the environment's name is specified in an environment + // manifest and not with the environment name or environment ID parameters. + // See Environment Manifest (env.yaml) (http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environment-mgmt-compose.html#environment-mgmt-compose-envyaml) + // for details. + GroupName *string `min:"1" type:"string"` + + // If specified, AWS Elastic Beanstalk updates the configuration set associated + // with the running environment and sets the specified configuration options + // to the requested value. + OptionSettings []*ConfigurationOptionSetting `type:"list"` + + // A list of custom user-defined configuration options to remove from the configuration + // set for this environment. + OptionsToRemove []*OptionSpecification `type:"list"` + + // This specifies the platform version that the environment will run after the + // environment is updated. + SolutionStackName *string `type:"string"` + + // If this parameter is specified, AWS Elastic Beanstalk deploys this configuration + // template to the environment. If no such configuration template is found, + // AWS Elastic Beanstalk returns an InvalidParameterValue error. + TemplateName *string `min:"1" type:"string"` + + // This specifies the tier to use to update the environment. + // + // Condition: At this time, if you change the tier version, name, or type, + // AWS Elastic Beanstalk returns InvalidParameterValue error. + Tier *EnvironmentTier `type:"structure"` + + // If this parameter is specified, AWS Elastic Beanstalk deploys the named application + // version to the environment. If no such application version is found, returns + // an InvalidParameterValue error. + VersionLabel *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s UpdateEnvironmentInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateEnvironmentInput) GoString() string { + return s.String() +} + +// A list of validation messages for a specified configuration template. +type ValidateConfigurationSettingsInput struct { + _ struct{} `type:"structure"` + + // The name of the application that the configuration template or environment + // belongs to. + ApplicationName *string `min:"1" type:"string" required:"true"` + + // The name of the environment to validate the settings against. + // + // Condition: You cannot specify both this and a configuration template name. + EnvironmentName *string `min:"4" type:"string"` + + // A list of the options and desired values to evaluate. + OptionSettings []*ConfigurationOptionSetting `type:"list" required:"true"` + + // The name of the configuration template to validate the settings against. + // + // Condition: You cannot specify both this and an environment name. + TemplateName *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s ValidateConfigurationSettingsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ValidateConfigurationSettingsInput) GoString() string { + return s.String() +} + +// Provides a list of validation messages. +type ValidateConfigurationSettingsOutput struct { + _ struct{} `type:"structure"` + + // A list of ValidationMessage. + Messages []*ValidationMessage `type:"list"` +} + +// String returns the string representation +func (s ValidateConfigurationSettingsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ValidateConfigurationSettingsOutput) GoString() string { + return s.String() +} + +// An error or warning for a desired configuration option value. +type ValidationMessage struct { + _ struct{} `type:"structure"` + + // A message describing the error or warning. + Message *string `type:"string"` + + Namespace *string `type:"string"` + + OptionName *string `type:"string"` + + // An indication of the severity of this message: + // + // error: This message indicates that this is not a valid setting for an + // option. warning: This message is providing information you should take + // into account. + Severity *string `type:"string" enum:"ValidationSeverity"` +} + +// String returns the string representation +func (s ValidationMessage) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ValidationMessage) GoString() string { + return s.String() +} + +const ( + // @enum ApplicationVersionStatus + ApplicationVersionStatusProcessed = "Processed" + // @enum ApplicationVersionStatus + ApplicationVersionStatusUnprocessed = "Unprocessed" + // @enum ApplicationVersionStatus + ApplicationVersionStatusFailed = "Failed" + // @enum ApplicationVersionStatus + ApplicationVersionStatusProcessing = "Processing" +) + +const ( + // @enum ConfigurationDeploymentStatus + ConfigurationDeploymentStatusDeployed = "deployed" + // @enum ConfigurationDeploymentStatus + ConfigurationDeploymentStatusPending = "pending" + // @enum ConfigurationDeploymentStatus + ConfigurationDeploymentStatusFailed = "failed" +) + +const ( + // @enum ConfigurationOptionValueType + ConfigurationOptionValueTypeScalar = "Scalar" + // @enum ConfigurationOptionValueType + ConfigurationOptionValueTypeList = "List" +) + +const ( + // @enum EnvironmentHealth + EnvironmentHealthGreen = "Green" + // @enum EnvironmentHealth + EnvironmentHealthYellow = "Yellow" + // @enum EnvironmentHealth + EnvironmentHealthRed = "Red" + // @enum EnvironmentHealth + EnvironmentHealthGrey = "Grey" +) + +const ( + // @enum EnvironmentHealthAttribute + EnvironmentHealthAttributeStatus = "Status" + // @enum EnvironmentHealthAttribute + EnvironmentHealthAttributeColor = "Color" + // @enum EnvironmentHealthAttribute + EnvironmentHealthAttributeCauses = "Causes" + // @enum EnvironmentHealthAttribute + EnvironmentHealthAttributeApplicationMetrics = "ApplicationMetrics" + // @enum EnvironmentHealthAttribute + EnvironmentHealthAttributeInstancesHealth = "InstancesHealth" + // @enum EnvironmentHealthAttribute + EnvironmentHealthAttributeAll = "All" + // @enum EnvironmentHealthAttribute + EnvironmentHealthAttributeHealthStatus = "HealthStatus" + // @enum EnvironmentHealthAttribute + EnvironmentHealthAttributeRefreshedAt = "RefreshedAt" +) + +const ( + // @enum EnvironmentHealthStatus + EnvironmentHealthStatusNoData = "NoData" + // @enum EnvironmentHealthStatus + EnvironmentHealthStatusUnknown = "Unknown" + // @enum EnvironmentHealthStatus + EnvironmentHealthStatusPending = "Pending" + // @enum EnvironmentHealthStatus + EnvironmentHealthStatusOk = "Ok" + // @enum EnvironmentHealthStatus + EnvironmentHealthStatusInfo = "Info" + // @enum EnvironmentHealthStatus + EnvironmentHealthStatusWarning = "Warning" + // @enum EnvironmentHealthStatus + EnvironmentHealthStatusDegraded = "Degraded" + // @enum EnvironmentHealthStatus + EnvironmentHealthStatusSevere = "Severe" +) + +const ( + // @enum EnvironmentInfoType + EnvironmentInfoTypeTail = "tail" + // @enum EnvironmentInfoType + EnvironmentInfoTypeBundle = "bundle" +) + +const ( + // @enum EnvironmentStatus + EnvironmentStatusLaunching = "Launching" + // @enum EnvironmentStatus + EnvironmentStatusUpdating = "Updating" + // @enum EnvironmentStatus + EnvironmentStatusReady = "Ready" + // @enum EnvironmentStatus + EnvironmentStatusTerminating = "Terminating" + // @enum EnvironmentStatus + EnvironmentStatusTerminated = "Terminated" +) + +const ( + // @enum EventSeverity + EventSeverityTrace = "TRACE" + // @enum EventSeverity + EventSeverityDebug = "DEBUG" + // @enum EventSeverity + EventSeverityInfo = "INFO" + // @enum EventSeverity + EventSeverityWarn = "WARN" + // @enum EventSeverity + EventSeverityError = "ERROR" + // @enum EventSeverity + EventSeverityFatal = "FATAL" +) + +const ( + // @enum InstancesHealthAttribute + InstancesHealthAttributeHealthStatus = "HealthStatus" + // @enum InstancesHealthAttribute + InstancesHealthAttributeColor = "Color" + // @enum InstancesHealthAttribute + InstancesHealthAttributeCauses = "Causes" + // @enum InstancesHealthAttribute + InstancesHealthAttributeApplicationMetrics = "ApplicationMetrics" + // @enum InstancesHealthAttribute + InstancesHealthAttributeRefreshedAt = "RefreshedAt" + // @enum InstancesHealthAttribute + InstancesHealthAttributeLaunchedAt = "LaunchedAt" + // @enum InstancesHealthAttribute + InstancesHealthAttributeSystem = "System" + // @enum InstancesHealthAttribute + InstancesHealthAttributeAll = "All" +) + +const ( + // @enum ValidationSeverity + ValidationSeverityError = "error" + // @enum ValidationSeverity + ValidationSeverityWarning = "warning" +) diff --git a/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/elasticbeanstalkiface/interface.go b/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/elasticbeanstalkiface/interface.go new file mode 100644 index 0000000000..7af685f336 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/elasticbeanstalkiface/interface.go @@ -0,0 +1,148 @@ +// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. + +// Package elasticbeanstalkiface provides an interface for the AWS Elastic Beanstalk. +package elasticbeanstalkiface + +import ( + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" +) + +// ElasticBeanstalkAPI is the interface type for elasticbeanstalk.ElasticBeanstalk. +type ElasticBeanstalkAPI interface { + AbortEnvironmentUpdateRequest(*elasticbeanstalk.AbortEnvironmentUpdateInput) (*request.Request, *elasticbeanstalk.AbortEnvironmentUpdateOutput) + + AbortEnvironmentUpdate(*elasticbeanstalk.AbortEnvironmentUpdateInput) (*elasticbeanstalk.AbortEnvironmentUpdateOutput, error) + + CheckDNSAvailabilityRequest(*elasticbeanstalk.CheckDNSAvailabilityInput) (*request.Request, *elasticbeanstalk.CheckDNSAvailabilityOutput) + + CheckDNSAvailability(*elasticbeanstalk.CheckDNSAvailabilityInput) (*elasticbeanstalk.CheckDNSAvailabilityOutput, error) + + ComposeEnvironmentsRequest(*elasticbeanstalk.ComposeEnvironmentsInput) (*request.Request, *elasticbeanstalk.EnvironmentDescriptionsMessage) + + ComposeEnvironments(*elasticbeanstalk.ComposeEnvironmentsInput) (*elasticbeanstalk.EnvironmentDescriptionsMessage, error) + + CreateApplicationRequest(*elasticbeanstalk.CreateApplicationInput) (*request.Request, *elasticbeanstalk.ApplicationDescriptionMessage) + + CreateApplication(*elasticbeanstalk.CreateApplicationInput) (*elasticbeanstalk.ApplicationDescriptionMessage, error) + + CreateApplicationVersionRequest(*elasticbeanstalk.CreateApplicationVersionInput) (*request.Request, *elasticbeanstalk.ApplicationVersionDescriptionMessage) + + CreateApplicationVersion(*elasticbeanstalk.CreateApplicationVersionInput) (*elasticbeanstalk.ApplicationVersionDescriptionMessage, error) + + CreateConfigurationTemplateRequest(*elasticbeanstalk.CreateConfigurationTemplateInput) (*request.Request, *elasticbeanstalk.ConfigurationSettingsDescription) + + CreateConfigurationTemplate(*elasticbeanstalk.CreateConfigurationTemplateInput) (*elasticbeanstalk.ConfigurationSettingsDescription, error) + + CreateEnvironmentRequest(*elasticbeanstalk.CreateEnvironmentInput) (*request.Request, *elasticbeanstalk.EnvironmentDescription) + + CreateEnvironment(*elasticbeanstalk.CreateEnvironmentInput) (*elasticbeanstalk.EnvironmentDescription, error) + + CreateStorageLocationRequest(*elasticbeanstalk.CreateStorageLocationInput) (*request.Request, *elasticbeanstalk.CreateStorageLocationOutput) + + CreateStorageLocation(*elasticbeanstalk.CreateStorageLocationInput) (*elasticbeanstalk.CreateStorageLocationOutput, error) + + DeleteApplicationRequest(*elasticbeanstalk.DeleteApplicationInput) (*request.Request, *elasticbeanstalk.DeleteApplicationOutput) + + DeleteApplication(*elasticbeanstalk.DeleteApplicationInput) (*elasticbeanstalk.DeleteApplicationOutput, error) + + DeleteApplicationVersionRequest(*elasticbeanstalk.DeleteApplicationVersionInput) (*request.Request, *elasticbeanstalk.DeleteApplicationVersionOutput) + + DeleteApplicationVersion(*elasticbeanstalk.DeleteApplicationVersionInput) (*elasticbeanstalk.DeleteApplicationVersionOutput, error) + + DeleteConfigurationTemplateRequest(*elasticbeanstalk.DeleteConfigurationTemplateInput) (*request.Request, *elasticbeanstalk.DeleteConfigurationTemplateOutput) + + DeleteConfigurationTemplate(*elasticbeanstalk.DeleteConfigurationTemplateInput) (*elasticbeanstalk.DeleteConfigurationTemplateOutput, error) + + DeleteEnvironmentConfigurationRequest(*elasticbeanstalk.DeleteEnvironmentConfigurationInput) (*request.Request, *elasticbeanstalk.DeleteEnvironmentConfigurationOutput) + + DeleteEnvironmentConfiguration(*elasticbeanstalk.DeleteEnvironmentConfigurationInput) (*elasticbeanstalk.DeleteEnvironmentConfigurationOutput, error) + + DescribeApplicationVersionsRequest(*elasticbeanstalk.DescribeApplicationVersionsInput) (*request.Request, *elasticbeanstalk.DescribeApplicationVersionsOutput) + + DescribeApplicationVersions(*elasticbeanstalk.DescribeApplicationVersionsInput) (*elasticbeanstalk.DescribeApplicationVersionsOutput, error) + + DescribeApplicationsRequest(*elasticbeanstalk.DescribeApplicationsInput) (*request.Request, *elasticbeanstalk.DescribeApplicationsOutput) + + DescribeApplications(*elasticbeanstalk.DescribeApplicationsInput) (*elasticbeanstalk.DescribeApplicationsOutput, error) + + DescribeConfigurationOptionsRequest(*elasticbeanstalk.DescribeConfigurationOptionsInput) (*request.Request, *elasticbeanstalk.DescribeConfigurationOptionsOutput) + + DescribeConfigurationOptions(*elasticbeanstalk.DescribeConfigurationOptionsInput) (*elasticbeanstalk.DescribeConfigurationOptionsOutput, error) + + DescribeConfigurationSettingsRequest(*elasticbeanstalk.DescribeConfigurationSettingsInput) (*request.Request, *elasticbeanstalk.DescribeConfigurationSettingsOutput) + + DescribeConfigurationSettings(*elasticbeanstalk.DescribeConfigurationSettingsInput) (*elasticbeanstalk.DescribeConfigurationSettingsOutput, error) + + DescribeEnvironmentHealthRequest(*elasticbeanstalk.DescribeEnvironmentHealthInput) (*request.Request, *elasticbeanstalk.DescribeEnvironmentHealthOutput) + + DescribeEnvironmentHealth(*elasticbeanstalk.DescribeEnvironmentHealthInput) (*elasticbeanstalk.DescribeEnvironmentHealthOutput, error) + + DescribeEnvironmentResourcesRequest(*elasticbeanstalk.DescribeEnvironmentResourcesInput) (*request.Request, *elasticbeanstalk.DescribeEnvironmentResourcesOutput) + + DescribeEnvironmentResources(*elasticbeanstalk.DescribeEnvironmentResourcesInput) (*elasticbeanstalk.DescribeEnvironmentResourcesOutput, error) + + DescribeEnvironmentsRequest(*elasticbeanstalk.DescribeEnvironmentsInput) (*request.Request, *elasticbeanstalk.EnvironmentDescriptionsMessage) + + DescribeEnvironments(*elasticbeanstalk.DescribeEnvironmentsInput) (*elasticbeanstalk.EnvironmentDescriptionsMessage, error) + + DescribeEventsRequest(*elasticbeanstalk.DescribeEventsInput) (*request.Request, *elasticbeanstalk.DescribeEventsOutput) + + DescribeEvents(*elasticbeanstalk.DescribeEventsInput) (*elasticbeanstalk.DescribeEventsOutput, error) + + DescribeEventsPages(*elasticbeanstalk.DescribeEventsInput, func(*elasticbeanstalk.DescribeEventsOutput, bool) bool) error + + DescribeInstancesHealthRequest(*elasticbeanstalk.DescribeInstancesHealthInput) (*request.Request, *elasticbeanstalk.DescribeInstancesHealthOutput) + + DescribeInstancesHealth(*elasticbeanstalk.DescribeInstancesHealthInput) (*elasticbeanstalk.DescribeInstancesHealthOutput, error) + + ListAvailableSolutionStacksRequest(*elasticbeanstalk.ListAvailableSolutionStacksInput) (*request.Request, *elasticbeanstalk.ListAvailableSolutionStacksOutput) + + ListAvailableSolutionStacks(*elasticbeanstalk.ListAvailableSolutionStacksInput) (*elasticbeanstalk.ListAvailableSolutionStacksOutput, error) + + RebuildEnvironmentRequest(*elasticbeanstalk.RebuildEnvironmentInput) (*request.Request, *elasticbeanstalk.RebuildEnvironmentOutput) + + RebuildEnvironment(*elasticbeanstalk.RebuildEnvironmentInput) (*elasticbeanstalk.RebuildEnvironmentOutput, error) + + RequestEnvironmentInfoRequest(*elasticbeanstalk.RequestEnvironmentInfoInput) (*request.Request, *elasticbeanstalk.RequestEnvironmentInfoOutput) + + RequestEnvironmentInfo(*elasticbeanstalk.RequestEnvironmentInfoInput) (*elasticbeanstalk.RequestEnvironmentInfoOutput, error) + + RestartAppServerRequest(*elasticbeanstalk.RestartAppServerInput) (*request.Request, *elasticbeanstalk.RestartAppServerOutput) + + RestartAppServer(*elasticbeanstalk.RestartAppServerInput) (*elasticbeanstalk.RestartAppServerOutput, error) + + RetrieveEnvironmentInfoRequest(*elasticbeanstalk.RetrieveEnvironmentInfoInput) (*request.Request, *elasticbeanstalk.RetrieveEnvironmentInfoOutput) + + RetrieveEnvironmentInfo(*elasticbeanstalk.RetrieveEnvironmentInfoInput) (*elasticbeanstalk.RetrieveEnvironmentInfoOutput, error) + + SwapEnvironmentCNAMEsRequest(*elasticbeanstalk.SwapEnvironmentCNAMEsInput) (*request.Request, *elasticbeanstalk.SwapEnvironmentCNAMEsOutput) + + SwapEnvironmentCNAMEs(*elasticbeanstalk.SwapEnvironmentCNAMEsInput) (*elasticbeanstalk.SwapEnvironmentCNAMEsOutput, error) + + TerminateEnvironmentRequest(*elasticbeanstalk.TerminateEnvironmentInput) (*request.Request, *elasticbeanstalk.EnvironmentDescription) + + TerminateEnvironment(*elasticbeanstalk.TerminateEnvironmentInput) (*elasticbeanstalk.EnvironmentDescription, error) + + UpdateApplicationRequest(*elasticbeanstalk.UpdateApplicationInput) (*request.Request, *elasticbeanstalk.ApplicationDescriptionMessage) + + UpdateApplication(*elasticbeanstalk.UpdateApplicationInput) (*elasticbeanstalk.ApplicationDescriptionMessage, error) + + UpdateApplicationVersionRequest(*elasticbeanstalk.UpdateApplicationVersionInput) (*request.Request, *elasticbeanstalk.ApplicationVersionDescriptionMessage) + + UpdateApplicationVersion(*elasticbeanstalk.UpdateApplicationVersionInput) (*elasticbeanstalk.ApplicationVersionDescriptionMessage, error) + + UpdateConfigurationTemplateRequest(*elasticbeanstalk.UpdateConfigurationTemplateInput) (*request.Request, *elasticbeanstalk.ConfigurationSettingsDescription) + + UpdateConfigurationTemplate(*elasticbeanstalk.UpdateConfigurationTemplateInput) (*elasticbeanstalk.ConfigurationSettingsDescription, error) + + UpdateEnvironmentRequest(*elasticbeanstalk.UpdateEnvironmentInput) (*request.Request, *elasticbeanstalk.EnvironmentDescription) + + UpdateEnvironment(*elasticbeanstalk.UpdateEnvironmentInput) (*elasticbeanstalk.EnvironmentDescription, error) + + ValidateConfigurationSettingsRequest(*elasticbeanstalk.ValidateConfigurationSettingsInput) (*request.Request, *elasticbeanstalk.ValidateConfigurationSettingsOutput) + + ValidateConfigurationSettings(*elasticbeanstalk.ValidateConfigurationSettingsInput) (*elasticbeanstalk.ValidateConfigurationSettingsOutput, error) +} + +var _ ElasticBeanstalkAPI = (*elasticbeanstalk.ElasticBeanstalk)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/examples_test.go b/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/examples_test.go new file mode 100644 index 0000000000..4884fecbd3 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/examples_test.go @@ -0,0 +1,839 @@ +// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. + +package elasticbeanstalk_test + +import ( + "bytes" + "fmt" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/elasticbeanstalk" +) + +var _ time.Duration +var _ bytes.Buffer + +func ExampleElasticBeanstalk_AbortEnvironmentUpdate() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.AbortEnvironmentUpdateInput{ + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + } + resp, err := svc.AbortEnvironmentUpdate(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 ExampleElasticBeanstalk_CheckDNSAvailability() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.CheckDNSAvailabilityInput{ + CNAMEPrefix: aws.String("DNSCnamePrefix"), // Required + } + resp, err := svc.CheckDNSAvailability(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 ExampleElasticBeanstalk_ComposeEnvironments() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.ComposeEnvironmentsInput{ + ApplicationName: aws.String("ApplicationName"), + GroupName: aws.String("GroupName"), + VersionLabels: []*string{ + aws.String("VersionLabel"), // Required + // More values... + }, + } + resp, err := svc.ComposeEnvironments(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 ExampleElasticBeanstalk_CreateApplication() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.CreateApplicationInput{ + ApplicationName: aws.String("ApplicationName"), // Required + Description: aws.String("Description"), + } + resp, err := svc.CreateApplication(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 ExampleElasticBeanstalk_CreateApplicationVersion() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.CreateApplicationVersionInput{ + ApplicationName: aws.String("ApplicationName"), // Required + VersionLabel: aws.String("VersionLabel"), // Required + AutoCreateApplication: aws.Bool(true), + Description: aws.String("Description"), + Process: aws.Bool(true), + SourceBundle: &elasticbeanstalk.S3Location{ + S3Bucket: aws.String("S3Bucket"), + S3Key: aws.String("S3Key"), + }, + } + resp, err := svc.CreateApplicationVersion(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 ExampleElasticBeanstalk_CreateConfigurationTemplate() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.CreateConfigurationTemplateInput{ + ApplicationName: aws.String("ApplicationName"), // Required + TemplateName: aws.String("ConfigurationTemplateName"), // Required + Description: aws.String("Description"), + EnvironmentId: aws.String("EnvironmentId"), + OptionSettings: []*elasticbeanstalk.ConfigurationOptionSetting{ + { // Required + Namespace: aws.String("OptionNamespace"), + OptionName: aws.String("ConfigurationOptionName"), + ResourceName: aws.String("ResourceName"), + Value: aws.String("ConfigurationOptionValue"), + }, + // More values... + }, + SolutionStackName: aws.String("SolutionStackName"), + SourceConfiguration: &elasticbeanstalk.SourceConfiguration{ + ApplicationName: aws.String("ApplicationName"), + TemplateName: aws.String("ConfigurationTemplateName"), + }, + } + resp, err := svc.CreateConfigurationTemplate(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 ExampleElasticBeanstalk_CreateEnvironment() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.CreateEnvironmentInput{ + ApplicationName: aws.String("ApplicationName"), // Required + CNAMEPrefix: aws.String("DNSCnamePrefix"), + Description: aws.String("Description"), + EnvironmentName: aws.String("EnvironmentName"), + GroupName: aws.String("GroupName"), + OptionSettings: []*elasticbeanstalk.ConfigurationOptionSetting{ + { // Required + Namespace: aws.String("OptionNamespace"), + OptionName: aws.String("ConfigurationOptionName"), + ResourceName: aws.String("ResourceName"), + Value: aws.String("ConfigurationOptionValue"), + }, + // More values... + }, + OptionsToRemove: []*elasticbeanstalk.OptionSpecification{ + { // Required + Namespace: aws.String("OptionNamespace"), + OptionName: aws.String("ConfigurationOptionName"), + ResourceName: aws.String("ResourceName"), + }, + // More values... + }, + SolutionStackName: aws.String("SolutionStackName"), + Tags: []*elasticbeanstalk.Tag{ + { // Required + Key: aws.String("TagKey"), + Value: aws.String("TagValue"), + }, + // More values... + }, + TemplateName: aws.String("ConfigurationTemplateName"), + Tier: &elasticbeanstalk.EnvironmentTier{ + Name: aws.String("String"), + Type: aws.String("String"), + Version: aws.String("String"), + }, + VersionLabel: aws.String("VersionLabel"), + } + resp, err := svc.CreateEnvironment(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 ExampleElasticBeanstalk_CreateStorageLocation() { + svc := elasticbeanstalk.New(session.New()) + + var params *elasticbeanstalk.CreateStorageLocationInput + resp, err := svc.CreateStorageLocation(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 ExampleElasticBeanstalk_DeleteApplication() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DeleteApplicationInput{ + ApplicationName: aws.String("ApplicationName"), // Required + TerminateEnvByForce: aws.Bool(true), + } + resp, err := svc.DeleteApplication(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 ExampleElasticBeanstalk_DeleteApplicationVersion() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DeleteApplicationVersionInput{ + ApplicationName: aws.String("ApplicationName"), // Required + VersionLabel: aws.String("VersionLabel"), // Required + DeleteSourceBundle: aws.Bool(true), + } + resp, err := svc.DeleteApplicationVersion(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 ExampleElasticBeanstalk_DeleteConfigurationTemplate() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DeleteConfigurationTemplateInput{ + ApplicationName: aws.String("ApplicationName"), // Required + TemplateName: aws.String("ConfigurationTemplateName"), // Required + } + resp, err := svc.DeleteConfigurationTemplate(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 ExampleElasticBeanstalk_DeleteEnvironmentConfiguration() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DeleteEnvironmentConfigurationInput{ + ApplicationName: aws.String("ApplicationName"), // Required + EnvironmentName: aws.String("EnvironmentName"), // Required + } + resp, err := svc.DeleteEnvironmentConfiguration(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 ExampleElasticBeanstalk_DescribeApplicationVersions() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DescribeApplicationVersionsInput{ + ApplicationName: aws.String("ApplicationName"), + VersionLabels: []*string{ + aws.String("VersionLabel"), // Required + // More values... + }, + } + resp, err := svc.DescribeApplicationVersions(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 ExampleElasticBeanstalk_DescribeApplications() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DescribeApplicationsInput{ + ApplicationNames: []*string{ + aws.String("ApplicationName"), // Required + // More values... + }, + } + resp, err := svc.DescribeApplications(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 ExampleElasticBeanstalk_DescribeConfigurationOptions() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DescribeConfigurationOptionsInput{ + ApplicationName: aws.String("ApplicationName"), + EnvironmentName: aws.String("EnvironmentName"), + Options: []*elasticbeanstalk.OptionSpecification{ + { // Required + Namespace: aws.String("OptionNamespace"), + OptionName: aws.String("ConfigurationOptionName"), + ResourceName: aws.String("ResourceName"), + }, + // More values... + }, + SolutionStackName: aws.String("SolutionStackName"), + TemplateName: aws.String("ConfigurationTemplateName"), + } + resp, err := svc.DescribeConfigurationOptions(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 ExampleElasticBeanstalk_DescribeConfigurationSettings() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DescribeConfigurationSettingsInput{ + ApplicationName: aws.String("ApplicationName"), // Required + EnvironmentName: aws.String("EnvironmentName"), + TemplateName: aws.String("ConfigurationTemplateName"), + } + resp, err := svc.DescribeConfigurationSettings(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 ExampleElasticBeanstalk_DescribeEnvironmentHealth() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DescribeEnvironmentHealthInput{ + AttributeNames: []*string{ + aws.String("EnvironmentHealthAttribute"), // Required + // More values... + }, + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + } + resp, err := svc.DescribeEnvironmentHealth(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 ExampleElasticBeanstalk_DescribeEnvironmentResources() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DescribeEnvironmentResourcesInput{ + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + } + resp, err := svc.DescribeEnvironmentResources(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 ExampleElasticBeanstalk_DescribeEnvironments() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DescribeEnvironmentsInput{ + ApplicationName: aws.String("ApplicationName"), + EnvironmentIds: []*string{ + aws.String("EnvironmentId"), // Required + // More values... + }, + EnvironmentNames: []*string{ + aws.String("EnvironmentName"), // Required + // More values... + }, + IncludeDeleted: aws.Bool(true), + IncludedDeletedBackTo: aws.Time(time.Now()), + VersionLabel: aws.String("VersionLabel"), + } + resp, err := svc.DescribeEnvironments(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 ExampleElasticBeanstalk_DescribeEvents() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DescribeEventsInput{ + ApplicationName: aws.String("ApplicationName"), + EndTime: aws.Time(time.Now()), + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + MaxRecords: aws.Int64(1), + NextToken: aws.String("Token"), + RequestId: aws.String("RequestId"), + Severity: aws.String("EventSeverity"), + StartTime: aws.Time(time.Now()), + TemplateName: aws.String("ConfigurationTemplateName"), + VersionLabel: aws.String("VersionLabel"), + } + resp, err := svc.DescribeEvents(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 ExampleElasticBeanstalk_DescribeInstancesHealth() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.DescribeInstancesHealthInput{ + AttributeNames: []*string{ + aws.String("InstancesHealthAttribute"), // Required + // More values... + }, + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + NextToken: aws.String("NextToken"), + } + resp, err := svc.DescribeInstancesHealth(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 ExampleElasticBeanstalk_ListAvailableSolutionStacks() { + svc := elasticbeanstalk.New(session.New()) + + var params *elasticbeanstalk.ListAvailableSolutionStacksInput + resp, err := svc.ListAvailableSolutionStacks(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 ExampleElasticBeanstalk_RebuildEnvironment() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.RebuildEnvironmentInput{ + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + } + resp, err := svc.RebuildEnvironment(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 ExampleElasticBeanstalk_RequestEnvironmentInfo() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.RequestEnvironmentInfoInput{ + InfoType: aws.String("EnvironmentInfoType"), // Required + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + } + resp, err := svc.RequestEnvironmentInfo(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 ExampleElasticBeanstalk_RestartAppServer() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.RestartAppServerInput{ + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + } + resp, err := svc.RestartAppServer(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 ExampleElasticBeanstalk_RetrieveEnvironmentInfo() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.RetrieveEnvironmentInfoInput{ + InfoType: aws.String("EnvironmentInfoType"), // Required + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + } + resp, err := svc.RetrieveEnvironmentInfo(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 ExampleElasticBeanstalk_SwapEnvironmentCNAMEs() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.SwapEnvironmentCNAMEsInput{ + DestinationEnvironmentId: aws.String("EnvironmentId"), + DestinationEnvironmentName: aws.String("EnvironmentName"), + SourceEnvironmentId: aws.String("EnvironmentId"), + SourceEnvironmentName: aws.String("EnvironmentName"), + } + resp, err := svc.SwapEnvironmentCNAMEs(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 ExampleElasticBeanstalk_TerminateEnvironment() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.TerminateEnvironmentInput{ + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + ForceTerminate: aws.Bool(true), + TerminateResources: aws.Bool(true), + } + resp, err := svc.TerminateEnvironment(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 ExampleElasticBeanstalk_UpdateApplication() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.UpdateApplicationInput{ + ApplicationName: aws.String("ApplicationName"), // Required + Description: aws.String("Description"), + } + resp, err := svc.UpdateApplication(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 ExampleElasticBeanstalk_UpdateApplicationVersion() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.UpdateApplicationVersionInput{ + ApplicationName: aws.String("ApplicationName"), // Required + VersionLabel: aws.String("VersionLabel"), // Required + Description: aws.String("Description"), + } + resp, err := svc.UpdateApplicationVersion(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 ExampleElasticBeanstalk_UpdateConfigurationTemplate() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.UpdateConfigurationTemplateInput{ + ApplicationName: aws.String("ApplicationName"), // Required + TemplateName: aws.String("ConfigurationTemplateName"), // Required + Description: aws.String("Description"), + OptionSettings: []*elasticbeanstalk.ConfigurationOptionSetting{ + { // Required + Namespace: aws.String("OptionNamespace"), + OptionName: aws.String("ConfigurationOptionName"), + ResourceName: aws.String("ResourceName"), + Value: aws.String("ConfigurationOptionValue"), + }, + // More values... + }, + OptionsToRemove: []*elasticbeanstalk.OptionSpecification{ + { // Required + Namespace: aws.String("OptionNamespace"), + OptionName: aws.String("ConfigurationOptionName"), + ResourceName: aws.String("ResourceName"), + }, + // More values... + }, + } + resp, err := svc.UpdateConfigurationTemplate(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 ExampleElasticBeanstalk_UpdateEnvironment() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.UpdateEnvironmentInput{ + ApplicationName: aws.String("ApplicationName"), + Description: aws.String("Description"), + EnvironmentId: aws.String("EnvironmentId"), + EnvironmentName: aws.String("EnvironmentName"), + GroupName: aws.String("GroupName"), + OptionSettings: []*elasticbeanstalk.ConfigurationOptionSetting{ + { // Required + Namespace: aws.String("OptionNamespace"), + OptionName: aws.String("ConfigurationOptionName"), + ResourceName: aws.String("ResourceName"), + Value: aws.String("ConfigurationOptionValue"), + }, + // More values... + }, + OptionsToRemove: []*elasticbeanstalk.OptionSpecification{ + { // Required + Namespace: aws.String("OptionNamespace"), + OptionName: aws.String("ConfigurationOptionName"), + ResourceName: aws.String("ResourceName"), + }, + // More values... + }, + SolutionStackName: aws.String("SolutionStackName"), + TemplateName: aws.String("ConfigurationTemplateName"), + Tier: &elasticbeanstalk.EnvironmentTier{ + Name: aws.String("String"), + Type: aws.String("String"), + Version: aws.String("String"), + }, + VersionLabel: aws.String("VersionLabel"), + } + resp, err := svc.UpdateEnvironment(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 ExampleElasticBeanstalk_ValidateConfigurationSettings() { + svc := elasticbeanstalk.New(session.New()) + + params := &elasticbeanstalk.ValidateConfigurationSettingsInput{ + ApplicationName: aws.String("ApplicationName"), // Required + OptionSettings: []*elasticbeanstalk.ConfigurationOptionSetting{ // Required + { // Required + Namespace: aws.String("OptionNamespace"), + OptionName: aws.String("ConfigurationOptionName"), + ResourceName: aws.String("ResourceName"), + Value: aws.String("ConfigurationOptionValue"), + }, + // More values... + }, + EnvironmentName: aws.String("EnvironmentName"), + TemplateName: aws.String("ConfigurationTemplateName"), + } + resp, err := svc.ValidateConfigurationSettings(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) +} diff --git a/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/service.go b/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/service.go new file mode 100644 index 0000000000..dd71e05142 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/service.go @@ -0,0 +1,106 @@ +// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. + +package elasticbeanstalk + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/client" + "github.com/aws/aws-sdk-go/aws/client/metadata" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/private/protocol/query" + "github.com/aws/aws-sdk-go/private/signer/v4" +) + +// This is the AWS Elastic Beanstalk API Reference. This guide provides detailed +// information about AWS Elastic Beanstalk actions, data types, parameters, +// and errors. +// +// AWS Elastic Beanstalk is a tool that makes it easy for you to create, deploy, +// and manage scalable, fault-tolerant applications running on Amazon Web Services +// cloud resources. +// +// For more information about this product, go to the AWS Elastic Beanstalk +// (http://aws.amazon.com/elasticbeanstalk/) details page. The location of the +// latest AWS Elastic Beanstalk WSDL is http://elasticbeanstalk.s3.amazonaws.com/doc/2010-12-01/AWSElasticBeanstalk.wsdl +// (http://elasticbeanstalk.s3.amazonaws.com/doc/2010-12-01/AWSElasticBeanstalk.wsdl). +// To install the Software Development Kits (SDKs), Integrated Development Environment +// (IDE) Toolkits, and command line tools that enable you to access the API, +// go to Tools for Amazon Web Services (https://aws.amazon.com/tools/). +// +// Endpoints +// +// For a list of region-specific endpoints that AWS Elastic Beanstalk supports, +// go to Regions and Endpoints (http://docs.aws.amazon.com/general/latest/gr/rande.html#elasticbeanstalk_region) +// in the Amazon Web Services Glossary. +//The service client's operations are safe to be used concurrently. +// It is not safe to mutate any of the client's properties though. +type ElasticBeanstalk struct { + *client.Client +} + +// Used for custom client initialization logic +var initClient func(*client.Client) + +// Used for custom request initialization logic +var initRequest func(*request.Request) + +// A ServiceName is the name of the service the client will make API calls to. +const ServiceName = "elasticbeanstalk" + +// New creates a new instance of the ElasticBeanstalk client with a session. +// If additional configuration is needed for the client instance use the optional +// aws.Config parameter to add your extra config. +// +// Example: +// // Create a ElasticBeanstalk client from just a session. +// svc := elasticbeanstalk.New(mySession) +// +// // Create a ElasticBeanstalk client with additional configuration +// svc := elasticbeanstalk.New(mySession, aws.NewConfig().WithRegion("us-west-2")) +func New(p client.ConfigProvider, cfgs ...*aws.Config) *ElasticBeanstalk { + c := p.ClientConfig(ServiceName, cfgs...) + return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion) +} + +// newClient creates, initializes and returns a new service client instance. +func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion string) *ElasticBeanstalk { + svc := &ElasticBeanstalk{ + Client: client.New( + cfg, + metadata.ClientInfo{ + ServiceName: ServiceName, + SigningRegion: signingRegion, + Endpoint: endpoint, + APIVersion: "2010-12-01", + }, + handlers, + ), + } + + // Handlers + svc.Handlers.Sign.PushBack(v4.Sign) + svc.Handlers.Build.PushBack(query.Build) + svc.Handlers.Unmarshal.PushBack(query.Unmarshal) + svc.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta) + svc.Handlers.UnmarshalError.PushBack(query.UnmarshalError) + + // Run custom client initialization if present + if initClient != nil { + initClient(svc.Client) + } + + return svc +} + +// newRequest creates a new request for a ElasticBeanstalk operation and runs any +// custom request initialization. +func (c *ElasticBeanstalk) newRequest(op *request.Operation, params, data interface{}) *request.Request { + req := c.NewRequest(op, params, data) + + // Run custom request initialization if present + if initRequest != nil { + initRequest(req) + } + + return req +} diff --git a/website/source/docs/providers/aws/r/elastic_beanstalk_application.html.markdown b/website/source/docs/providers/aws/r/elastic_beanstalk_application.html.markdown new file mode 100644 index 0000000000..25bbe7f66a --- /dev/null +++ b/website/source/docs/providers/aws/r/elastic_beanstalk_application.html.markdown @@ -0,0 +1,39 @@ +--- +layout: "aws" +page_title: "AWS: aws_elastic_beanstalk_application" +sidebar_current: "docs-aws-resource-elastic-beanstalk-application" +description: |- + Provides an Elastic Beanstalk Application Resource +--- + +# aws\_elastic\_beanstalk\_application + +Provides an Elastic Beanstalk Application Resource. Elastic Beanstalk allows +you to deploy and manage applications in the AWS cloud without worrying about +the infrastructure that runs those applications. + +This resource creates an application that has one configuration template named +`default`, and no application versions + +## Example Usage + +``` +resource "aws_elastic_beanstalk_application" "tftest" { + name = "tf-test-name" + description = "tf-test-desc" +} +``` + +## Argument Reference + +The following arguments are supported: + +* `name` - (Required) The name of the application, must be unique within your account +* `description` - (Optional) Short description of the application + +## Attributes Reference + +The following attributes are exported: + +* `name` +* `description` diff --git a/website/source/docs/providers/aws/r/elastic_beanstalk_configuration_template.html.markdown b/website/source/docs/providers/aws/r/elastic_beanstalk_configuration_template.html.markdown new file mode 100644 index 0000000000..3ca4e7da89 --- /dev/null +++ b/website/source/docs/providers/aws/r/elastic_beanstalk_configuration_template.html.markdown @@ -0,0 +1,59 @@ +--- +layout: "aws" +page_title: "AWS: aws_elastic_beanstalk_configuration_template" +sidebar_current: "docs-aws-resource-elastic-configuration-template" +description: |- + Provides an Elastic Beanstalk Configuration Template +--- + +# aws\_elastic\_beanstalk\_configuration\_template + +Provides an Elastic Beanstalk Configuration Template, which are associated with +a specific application and are used to deploy different versions of the +application with the same configuration settings. + +## Example Usage + + +``` +resource "aws_elastic_beanstalk_application" "tftest" { + name = "tf-test-name" + description = "tf-test-desc" +} + +resource "aws_elastic_beanstalk_configuration_template" "tf_template" { + name = "tf-test-template-config" + application = "${aws_elastic_beanstalk_application.tftest.name}" + solution_stack_name = "64bit Amazon Linux 2015.09 v2.0.8 running Go 1.4" +} +``` + +## Argument Reference + +The following arguments are supported: + +* `name` - (Required) A unique name for this Template. +* `application` – (Required) name of the application to associate with this configuration template +* `description` - (Optional) Short description of the Template +* `environment_id` – (Optional) The ID of the environment used with this configuration template +* `option_settings` – (Optional) Option settings to configure the new Environment. These + override specific values that are set as defaults. The format is detailed + below in [Option Settings](#option-settings) +* `solution_stack_name` – (Optional) A solution stack to base your Template +off of. Example stacks can be found in the [Amazon API documentation][1] + + +## Attributes Reference + +The following attributes are exported: + +* `name` +* `application` +* `description` +* `environment_id` +* `option_settings` +* `solution_stack_name` + +[1]: http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/concepts.platforms.html + + diff --git a/website/source/docs/providers/aws/r/elastic_beanstalk_environment.html.markdown b/website/source/docs/providers/aws/r/elastic_beanstalk_environment.html.markdown new file mode 100644 index 0000000000..8b842f954d --- /dev/null +++ b/website/source/docs/providers/aws/r/elastic_beanstalk_environment.html.markdown @@ -0,0 +1,83 @@ +--- +layout: "aws" +page_title: "AWS: aws_elastic_beanstalk_environment" +sidebar_current: "docs-aws-resource-elastic-beanstalk-environment" +description: |- + Provides an Elastic Beanstalk Environment Resource +--- + +# aws\_elastic\_beanstalk\_environment + +Provides an Elastic Beanstalk Environment Resource. Elastic Beanstalk allows +you to deploy and manage applications in the AWS cloud without worrying about +the infrastructure that runs those applications. + +Environments are often things such as `development`, `integration`, or +`production`. + +## Example Usage + + +``` +resource "aws_elastic_beanstalk_application" "tftest" { + name = "tf-test-name" + description = "tf-test-desc" +} + +resource "aws_elastic_beanstalk_environment" "tfenvtest" { + name = "tf-test-name" + application = "${aws_elastic_beanstalk_application.tftest.name}" + solution_stack_name = "64bit Amazon Linux 2015.03 v2.0.3 running Go 1.4" +} +``` + +## Argument Reference + +The following arguments are supported: + +* `name` - (Required) A unique name for this Environment. This name is used + in the application URL +* `application` – (Required) Name of the application that contains the version + to be deployed +* `description` - (Optional) Short description of the Environment +* `tier` - (Optional) Elastic Beanstalk Environment tier. Valid values are `Worker` + or `WebServer`. If tier is left blank `WebServer` will be used. +* `setting` – (Optional) Option settings to configure the new Environment. These + override specific values that are set as defaults. The format is detailed + below in [Option Settings](#option-settings) +* `solution_stack_name` – (Optional) A solution stack to base your environment +off of. Example stacks can be found in the [Amazon API documentation][1] +* `template_name` – (Optional) The name of the Elastic Beanstalk Configuration + template to use in deployment +* `tags` – (Optional) A set of tags to apply to the Environment. **Note:** at +this time the Elastic Beanstalk API does not provide a programatic way of +changing these tags after initial application + + + +## Option Settings + +The `setting` and `all_settings` mappings support the following format: + +* `namespace` - (Optional) unique namespace identifying the option's + associated AWS resource +* `name` - (Optional) name of the configuration option +* `value` - (Optional) value for the configuration option + +## Attributes Reference + +The following attributes are exported: + +* `name` +* `description` +* `tier` - the environment tier specified. +* `application` – the application specified +* `setting` – Settings specifically set for this Environment +* `all_settings` – List of all option settings configured in the Environment. These + are a combination of default settings and their overrides from `settings` in + the configuration + + +[1]: http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/concepts.platforms.html + + diff --git a/website/source/layouts/aws.erb b/website/source/layouts/aws.erb index 7781df6e5b..32d577ceb0 100644 --- a/website/source/layouts/aws.erb +++ b/website/source/layouts/aws.erb @@ -132,7 +132,7 @@ - > + > EC2 Resources