func resourceAwsApiGatewayIntegrationResponseRead(d *schema.ResourceData, meta interface{}) error {
conn := meta.(*AWSClient).apigateway
log.Printf("[DEBUG] Reading API Gateway Integration Response %s", d.Id())
integrationResponse, err := conn.GetIntegrationResponse(&apigateway.GetIntegrationResponseInput{
HttpMethod: aws.String(d.Get("http_method").(string)),
ResourceId: aws.String(d.Get("resource_id").(string)),
RestApiId: aws.String(d.Get("rest_api_id").(string)),
StatusCode: aws.String(d.Get("status_code").(string)),
})
if err != nil {
if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NotFoundException" {
d.SetId("")
return nil
}
return err
}
log.Printf("[DEBUG] Received API Gateway Integration Response: %s", integrationResponse)
d.SetId(fmt.Sprintf("agir-%s-%s-%s-%s", d.Get("rest_api_id").(string), d.Get("resource_id").(string), d.Get("http_method").(string), d.Get("status_code").(string)))
d.Set("response_templates", integrationResponse.ResponseTemplates)
d.Set("selection_pattern", integrationResponse.SelectionPattern)
d.Set("response_parameters", aws.StringValueMap(integrationResponse.ResponseParameters))
d.Set("response_parameters_in_json", aws.StringValueMap(integrationResponse.ResponseParameters))
return nil
}
func TestConvertToTaskDefinitionWithLogConfiguration(t *testing.T) {
taskDefinition := convertToTaskDefinitionInTest(t, "name", &libcompose.ServiceConfig{})
containerDef := *taskDefinition.ContainerDefinitions[0]
if containerDef.LogConfiguration != nil {
t.Errorf("Expected empty log configuration. But was [%v]", containerDef.LogConfiguration)
}
logDriver := "json-file"
logOpts := map[string]string{
"max-file": "50",
"max-size": "50k",
}
serviceConfig := &libcompose.ServiceConfig{
LogDriver: logDriver,
LogOpt: logOpts,
}
taskDefinition = convertToTaskDefinitionInTest(t, "name", serviceConfig)
containerDef = *taskDefinition.ContainerDefinitions[0]
if logDriver != aws.StringValue(containerDef.LogConfiguration.LogDriver) {
t.Errorf("Expected Log driver [%s]. But was [%s]", containerDef.LogConfiguration)
}
if !reflect.DeepEqual(logOpts, aws.StringValueMap(containerDef.LogConfiguration.Options)) {
t.Errorf("Expected Log options [%v]. But was [%v]", logOpts, aws.StringValueMap(containerDef.LogConfiguration.Options))
}
}
func resourceAwsApiGatewayIntegrationRead(d *schema.ResourceData, meta interface{}) error {
conn := meta.(*AWSClient).apigateway
log.Printf("[DEBUG] Reading API Gateway Integration %s", d.Id())
integration, err := conn.GetIntegration(&apigateway.GetIntegrationInput{
HttpMethod: aws.String(d.Get("http_method").(string)),
ResourceId: aws.String(d.Get("resource_id").(string)),
RestApiId: aws.String(d.Get("rest_api_id").(string)),
})
if err != nil {
if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NotFoundException" {
d.SetId("")
return nil
}
return err
}
log.Printf("[DEBUG] Received API Gateway Integration: %s", integration)
d.SetId(fmt.Sprintf("agi-%s-%s-%s", d.Get("rest_api_id").(string), d.Get("resource_id").(string), d.Get("http_method").(string)))
// AWS converts "" to null on their side, convert it back
if v, ok := integration.RequestTemplates["application/json"]; ok && v == nil {
integration.RequestTemplates["application/json"] = aws.String("")
}
d.Set("request_templates", aws.StringValueMap(integration.RequestTemplates))
d.Set("credentials", integration.Credentials)
d.Set("type", integration.Type)
d.Set("uri", integration.Uri)
d.Set("request_parameters", aws.StringValueMap(integration.RequestParameters))
d.Set("request_parameters_in_json", aws.StringValueMap(integration.RequestParameters))
d.Set("passthrough_behavior", integration.PassthroughBehavior)
d.Set("content_handling", integration.ContentHandling)
return nil
}
func TestConvertToTaskDefinitionWithDockerLabels(t *testing.T) {
dockerLabels := map[string]string{
"label1": "",
"com.foo.label2": "value",
}
serviceConfig := &libcompose.ServiceConfig{Labels: libcompose.NewSliceorMap(dockerLabels)}
taskDefinition := convertToTaskDefinitionInTest(t, "name", serviceConfig)
containerDef := *taskDefinition.ContainerDefinitions[0]
if !reflect.DeepEqual(dockerLabels, aws.StringValueMap(containerDef.DockerLabels)) {
t.Errorf("Expected dockerLabels [%v] But was [%v]", dockerLabels, aws.StringValueMap(containerDef.DockerLabels))
}
}
func (s *SQSQueue) getQueueAttributes(queueURL string) (map[string]string, error) {
getQueueAttributesInput := &sqs.GetQueueAttributesInput{
QueueUrl: aws.String(queueURL),
AttributeNames: aws.StringSlice([]string{"All"}),
}
s.logger.Debug("get-queue-attributes", lager.Data{"input": getQueueAttributesInput})
getQueueAttributesOutput, err := s.sqssvc.GetQueueAttributes(getQueueAttributesInput)
if err != nil {
s.logger.Error("aws-sqs-error", err)
if awsErr, ok := err.(awserr.Error); ok {
if reqErr, ok := err.(awserr.RequestFailure); ok {
// AWS SQS returns a 400 if Queue is not found
if reqErr.StatusCode() == 400 || reqErr.StatusCode() == 404 {
return nil, ErrQueueDoesNotExist
}
}
return nil, errors.New(awsErr.Code() + ": " + awsErr.Message())
}
return nil, err
}
s.logger.Debug("get-queue-attributes", lager.Data{"output": getQueueAttributesOutput})
return aws.StringValueMap(getQueueAttributesOutput.Attributes), nil
}
// GetMessages queries queue for messages.
// The parameters are ignored if their value is less than 0.
func (this *NiceSQS) GetMessages(limit, visibilityTimeout, waitTimeout int64) ([]*SimpleMessage, error) {
var msgs []*SimpleMessage
rmi := &sqs.ReceiveMessageInput{
QueueUrl: this.queueUrl,
}
if limit >= 0 {
rmi.MaxNumberOfMessages = aws.Int64(limit)
}
if visibilityTimeout >= 0 {
rmi.VisibilityTimeout = aws.Int64(visibilityTimeout)
}
if waitTimeout >= 0 {
rmi.WaitTimeSeconds = aws.Int64(waitTimeout)
}
if out, err := this.Sqs.ReceiveMessage(rmi); err != nil {
return nil, err
} else {
for _, m := range out.Messages {
msgs = append(msgs, &SimpleMessage{
Id: *m.MessageId,
ReceiptHandle: *m.ReceiptHandle,
Body: *m.Body,
BodyMd5: *m.MD5OfBody,
Attributes: aws.StringValueMap(m.Attributes),
})
}
return msgs, nil
}
}
func resourceAwsApiGatewayMethodRead(d *schema.ResourceData, meta interface{}) error {
conn := meta.(*AWSClient).apigateway
log.Printf("[DEBUG] Reading API Gateway Method %s", d.Id())
out, err := conn.GetMethod(&apigateway.GetMethodInput{
HttpMethod: aws.String(d.Get("http_method").(string)),
ResourceId: aws.String(d.Get("resource_id").(string)),
RestApiId: aws.String(d.Get("rest_api_id").(string)),
})
if err != nil {
if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NotFoundException" {
d.SetId("")
return nil
}
return err
}
log.Printf("[DEBUG] Received API Gateway Method: %s", out)
d.SetId(fmt.Sprintf("agm-%s-%s-%s", d.Get("rest_api_id").(string), d.Get("resource_id").(string), d.Get("http_method").(string)))
d.Set("request_parameters", aws.BoolValueMap(out.RequestParameters))
d.Set("request_parameters_in_json", aws.BoolValueMap(out.RequestParameters))
d.Set("api_key_required", out.ApiKeyRequired)
d.Set("authorization_type", out.AuthorizationType)
d.Set("authorizer_id", out.AuthorizerId)
d.Set("request_models", aws.StringValueMap(out.RequestModels))
return nil
}
// GetAttributes returns a list of queue attributes. All attributes are
// returned if not provided.
func (this *NiceSQS) GetAttributes(attrs []string) (map[string]string, error) {
a := &sqs.GetQueueAttributesInput{
QueueUrl: this.queueUrl,
}
if len(attrs) > 0 {
a.AttributeNames = aws.StringSlice(attrs)
} else {
a.AttributeNames = []*string{aws.String("All")}
}
resp, err := this.Sqs.GetQueueAttributes(a)
if err != nil {
return nil, err
}
return aws.StringValueMap(resp.Attributes), nil
}
func TestStringMap(t *testing.T) {
for idx, in := range testCasesStringMap {
if in == nil {
continue
}
out := aws.StringMap(in)
assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
for i := range out {
assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
}
out2 := aws.StringValueMap(out)
assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
}
}
func dataSourceAwsEcsContainerDefinitionRead(d *schema.ResourceData, meta interface{}) error {
conn := meta.(*AWSClient).ecsconn
desc, err := conn.DescribeTaskDefinition(&ecs.DescribeTaskDefinitionInput{
TaskDefinition: aws.String(d.Get("task_definition").(string)),
})
if err != nil {
return err
}
taskDefinition := *desc.TaskDefinition
for _, def := range taskDefinition.ContainerDefinitions {
if aws.StringValue(def.Name) != d.Get("container_name").(string) {
continue
}
d.SetId(fmt.Sprintf("%s/%s", aws.StringValue(taskDefinition.TaskDefinitionArn), d.Get("container_name").(string)))
d.Set("image", aws.StringValue(def.Image))
image := aws.StringValue(def.Image)
if strings.Contains(image, ":") {
d.Set("image_digest", strings.Split(image, ":")[1])
}
d.Set("cpu", aws.Int64Value(def.Cpu))
d.Set("memory", aws.Int64Value(def.Memory))
d.Set("memory_reservation", aws.Int64Value(def.MemoryReservation))
d.Set("disable_networking", aws.BoolValue(def.DisableNetworking))
d.Set("docker_labels", aws.StringValueMap(def.DockerLabels))
var environment = map[string]string{}
for _, keyValuePair := range def.Environment {
environment[aws.StringValue(keyValuePair.Name)] = aws.StringValue(keyValuePair.Value)
}
d.Set("environment", environment)
}
if d.Id() == "" {
return fmt.Errorf("container with name %q not found in task definition %q", d.Get("container_name").(string), d.Get("task_definition").(string))
}
return nil
}
func resourceAwsApiGatewayMethodResponseRead(d *schema.ResourceData, meta interface{}) error {
conn := meta.(*AWSClient).apigateway
log.Printf("[DEBUG] Reading API Gateway Method %s", d.Id())
methodResponse, err := conn.GetMethodResponse(&apigateway.GetMethodResponseInput{
HttpMethod: aws.String(d.Get("http_method").(string)),
ResourceId: aws.String(d.Get("resource_id").(string)),
RestApiId: aws.String(d.Get("rest_api_id").(string)),
StatusCode: aws.String(d.Get("status_code").(string)),
})
if err != nil {
if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NotFoundException" {
d.SetId("")
return nil
}
return err
}
log.Printf("[DEBUG] Received API Gateway Method: %s", methodResponse)
d.Set("response_models", aws.StringValueMap(methodResponse.ResponseModels))
d.SetId(fmt.Sprintf("agmr-%s-%s-%s-%s", d.Get("rest_api_id").(string), d.Get("resource_id").(string), d.Get("http_method").(string), d.Get("status_code").(string)))
return nil
}
func testAccCheckAWSOpsworksUpdateAppAttributes(
opsapp *opsworks.App) resource.TestCheckFunc {
return func(s *terraform.State) error {
if *opsapp.Type != "rails" {
return fmt.Errorf("Unnexpected type: %s", *opsapp.Type)
}
if !*opsapp.EnableSsl {
return fmt.Errorf("Unexpected enable ssl: %t", *opsapp.EnableSsl)
}
if *opsapp.SslConfiguration.Certificate != "-----BEGIN CERTIFICATE-----\nMIIBkDCB+gIJALoScFD0sJq3MA0GCSqGSIb3DQEBBQUAMA0xCzAJBgNVBAYTAkRF\nMB4XDTE1MTIxOTIwMzU1MVoXDTE2MDExODIwMzU1MVowDTELMAkGA1UEBhMCREUw\ngZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAKKQKbTTH/Julz16xY7ArYlzJYCP\nedTCx1bopuryCx/+d1gC94MtRdlPSpQl8mfc9iBdtXbJppp73Qh/DzLzO9Ns25xZ\n+kUQMhbIyLsaCBzuEGLgAaVdGpNvRBw++UoYtd0U7QczFAreTGLH8n8+FIzuI5Mc\n+MJ1TKbbt5gFfRSzAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEALARo96wCDmaHKCaX\nS0IGLGnZCfiIUfCmBxOXBSJxDBwter95QHR0dMGxYIujee5n4vvavpVsqZnfMC3I\nOZWPlwiUJbNIpK+04Bg2vd5m/NMMrvi75RfmyeMtSfq/NrIX2Q3+nyWI7DLq7yZI\nV/YEvOqdAiy5NEWBztHx8HvB9G4=\n-----END CERTIFICATE-----" {
return fmt.Errorf("Unexpected ssl configuration certificate: %s", *opsapp.SslConfiguration.Certificate)
}
if *opsapp.SslConfiguration.PrivateKey != "-----BEGIN RSA PRIVATE KEY-----\nMIICXQIBAAKBgQCikCm00x/ybpc9esWOwK2JcyWAj3nUwsdW6Kbq8gsf/ndYAveD\nLUXZT0qUJfJn3PYgXbV2yaaae90Ifw8y8zvTbNucWfpFEDIWyMi7Gggc7hBi4AGl\nXRqTb0QcPvlKGLXdFO0HMxQK3kxix/J/PhSM7iOTHPjCdUym27eYBX0UswIDAQAB\nAoGBAIYcrvuqDboguI8U4TUjCkfSAgds1pLLWk79wu8jXkA329d1IyNKT0y3WIye\nPbyoEzmidZmZROQ/+ZsPz8c12Y0DrX73WSVzKNyJeP7XMk9HSzA1D9RX0U0S+5Kh\nFAMc2NEVVFIfQtVtoVmHdKDpnRYtOCHLW9rRpvqOOjd4mYk5AkEAzeiFr1mtlnsa\n67shMxzDaOTAFMchRz6G7aSovvCztxcB63ulFI/w9OTUMdTQ7ff7pet+lVihLc2W\nefIL0HvsjQJBAMocNTKaR/TnsV5GSk2kPAdR+zFP5sQy8sfMy0lEXTylc7zN4ajX\nMeHVoxp+GZgpfDcZ3ya808H1umyXh+xA1j8CQE9x9ZKQYT98RAjL7KVR5btk9w+N\nPTPF1j1+mHUDXfO4ds8qp6jlWKzEVXLcj7ghRADiebaZuaZ4eiSW1SQdjEkCQQC4\nwDhQ3X9RfEpCp3ZcqvjEqEg6t5N3XitYQPjDLN8eBRBbUsgpEy3iBuxl10eGNMX7\niIbYXlwkPYAArDPv3wT5AkAwp4vym+YKmDqh6gseKfRDuJqRiW9yD5A8VGr/w88k\n5rkuduVGP7tK3uIp00Its3aEyKF8mLGWYszVGeeLxAMH\n-----END RSA PRIVATE KEY-----" {
return fmt.Errorf("Unexpected ssl configuration private key: %s", *opsapp.SslConfiguration.PrivateKey)
}
expectedAttrs := map[string]*string{
"DocumentRoot": aws.String("root"),
"RailsEnv": aws.String("staging"),
"AutoBundleOnDeploy": aws.String("true"),
"AwsFlowRubySettings": nil,
}
if !reflect.DeepEqual(expectedAttrs, opsapp.Attributes) {
return fmt.Errorf("Unnexpected Attributes: %v", aws.StringValueMap(opsapp.Attributes))
}
expectedAppSource := &opsworks.Source{
Type: aws.String("git"),
Revision: aws.String("master"),
Url: aws.String("https://github.com/aws/example.git"),
}
if !reflect.DeepEqual(expectedAppSource, opsapp.AppSource) {
return fmt.Errorf("Unnexpected appsource: %s", opsapp.AppSource)
}
expectedEnv := []*opsworks.EnvironmentVariable{
&opsworks.EnvironmentVariable{
Key: aws.String("key2"),
Value: aws.String("*****FILTERED*****"),
Secure: aws.Bool(true),
},
&opsworks.EnvironmentVariable{
Key: aws.String("key1"),
Value: aws.String("value1"),
Secure: aws.Bool(false),
},
}
if !reflect.DeepEqual(expectedEnv, opsapp.Environment) {
return fmt.Errorf("Unnexpected environment: %s", opsapp.Environment)
}
expectedDomains := []*string{
aws.String("example.com"),
aws.String("sub.example.com"),
}
if !reflect.DeepEqual(expectedDomains, opsapp.Domains) {
return fmt.Errorf("Unnexpected Daomins : %v", aws.StringValueSlice(opsapp.Domains))
}
return nil
}
}