github.com/mohanarpit/terraform@v0.6.16-0.20160909104007-291f29853544/builtin/providers/aws/resource_aws_cloudwatch_log_subscription_filter.go (about) 1 package aws 2 3 import ( 4 "bytes" 5 "fmt" 6 "log" 7 "time" 8 9 "github.com/aws/aws-sdk-go/aws" 10 "github.com/aws/aws-sdk-go/aws/awserr" 11 "github.com/aws/aws-sdk-go/service/cloudwatchlogs" 12 "github.com/hashicorp/terraform/helper/hashcode" 13 "github.com/hashicorp/terraform/helper/resource" 14 "github.com/hashicorp/terraform/helper/schema" 15 ) 16 17 func resourceAwsCloudwatchLogSubscriptionFilter() *schema.Resource { 18 return &schema.Resource{ 19 Create: resourceAwsCloudwatchLogSubscriptionFilterCreate, 20 Read: resourceAwsCloudwatchLogSubscriptionFilterRead, 21 Update: resourceAwsCloudwatchLogSubscriptionFilterUpdate, 22 Delete: resourceAwsCloudwatchLogSubscriptionFilterDelete, 23 24 Schema: map[string]*schema.Schema{ 25 "name": &schema.Schema{ 26 Type: schema.TypeString, 27 Required: true, 28 ForceNew: true, 29 }, 30 "destination_arn": &schema.Schema{ 31 Type: schema.TypeString, 32 Required: true, 33 ForceNew: true, 34 }, 35 "filter_pattern": &schema.Schema{ 36 Type: schema.TypeString, 37 Required: true, 38 ForceNew: false, 39 }, 40 "log_group_name": &schema.Schema{ 41 Type: schema.TypeString, 42 Required: true, 43 ForceNew: true, 44 }, 45 "role_arn": &schema.Schema{ 46 Type: schema.TypeString, 47 Optional: true, 48 Computed: true, 49 }, 50 }, 51 } 52 } 53 54 func resourceAwsCloudwatchLogSubscriptionFilterCreate(d *schema.ResourceData, meta interface{}) error { 55 conn := meta.(*AWSClient).cloudwatchlogsconn 56 params := getAwsCloudWatchLogsSubscriptionFilterInput(d) 57 log.Printf("[DEBUG] Creating SubscriptionFilter %#v", params) 58 59 return resource.Retry(30*time.Second, func() *resource.RetryError { 60 _, err := conn.PutSubscriptionFilter(¶ms) 61 62 if err == nil { 63 d.SetId(cloudwatchLogsSubscriptionFilterId(d.Get("log_group_name").(string))) 64 log.Printf("[DEBUG] Cloudwatch logs subscription %q created", d.Id()) 65 } 66 67 awsErr, ok := err.(awserr.Error) 68 if !ok { 69 return resource.RetryableError(err) 70 } 71 72 if awsErr.Code() == "InvalidParameterException" { 73 log.Printf("[DEBUG] Caught message: %q, code: %q: Retrying", awsErr.Message(), awsErr.Code()) 74 resource.NonRetryableError(err) 75 } 76 77 return resource.NonRetryableError(err) 78 }) 79 } 80 81 func resourceAwsCloudwatchLogSubscriptionFilterUpdate(d *schema.ResourceData, meta interface{}) error { 82 conn := meta.(*AWSClient).cloudwatchlogsconn 83 84 params := getAwsCloudWatchLogsSubscriptionFilterInput(d) 85 86 log.Printf("[DEBUG] Update SubscriptionFilter %#v", params) 87 _, err := conn.PutSubscriptionFilter(¶ms) 88 if err != nil { 89 if awsErr, ok := err.(awserr.Error); ok { 90 return fmt.Errorf("[WARN] Error updating SubscriptionFilter (%s) for LogGroup (%s), message: \"%s\", code: \"%s\"", 91 d.Get("name").(string), d.Get("log_group_name").(string), awsErr.Message(), awsErr.Code()) 92 } 93 return err 94 } 95 96 d.SetId(cloudwatchLogsSubscriptionFilterId(d.Get("log_group_name").(string))) 97 return resourceAwsCloudwatchLogSubscriptionFilterRead(d, meta) 98 } 99 100 func getAwsCloudWatchLogsSubscriptionFilterInput(d *schema.ResourceData) cloudwatchlogs.PutSubscriptionFilterInput { 101 name := d.Get("name").(string) 102 destination_arn := d.Get("destination_arn").(string) 103 filter_pattern := d.Get("filter_pattern").(string) 104 log_group_name := d.Get("log_group_name").(string) 105 106 params := cloudwatchlogs.PutSubscriptionFilterInput{ 107 FilterName: aws.String(name), 108 DestinationArn: aws.String(destination_arn), 109 FilterPattern: aws.String(filter_pattern), 110 LogGroupName: aws.String(log_group_name), 111 } 112 113 if _, ok := d.GetOk("role_arn"); ok { 114 params.RoleArn = aws.String(d.Get("role_arn").(string)) 115 } 116 117 return params 118 } 119 120 func resourceAwsCloudwatchLogSubscriptionFilterRead(d *schema.ResourceData, meta interface{}) error { 121 conn := meta.(*AWSClient).cloudwatchlogsconn 122 123 log_group_name := d.Get("log_group_name").(string) 124 name := d.Get("name").(string) // "name" is a required field in the schema 125 126 req := &cloudwatchlogs.DescribeSubscriptionFiltersInput{ 127 LogGroupName: aws.String(log_group_name), 128 FilterNamePrefix: aws.String(name), 129 } 130 131 resp, err := conn.DescribeSubscriptionFilters(req) 132 if err != nil { 133 return fmt.Errorf("Error reading SubscriptionFilters for log group %s with name prefix %s: %#v", log_group_name, d.Get("name").(string), err) 134 } 135 136 for _, subscriptionFilter := range resp.SubscriptionFilters { 137 if *subscriptionFilter.LogGroupName == log_group_name { 138 d.SetId(cloudwatchLogsSubscriptionFilterId(log_group_name)) 139 return nil // OK, matching subscription filter found 140 } 141 } 142 143 return fmt.Errorf("Subscription filter for log group %s with name prefix %s not found!", log_group_name, d.Get("name").(string)) 144 } 145 146 func resourceAwsCloudwatchLogSubscriptionFilterDelete(d *schema.ResourceData, meta interface{}) error { 147 conn := meta.(*AWSClient).cloudwatchlogsconn 148 log.Printf("[INFO] Deleting CloudWatch Log Group Subscription: %s", d.Id()) 149 log_group_name := d.Get("log_group_name").(string) 150 name := d.Get("name").(string) 151 152 params := &cloudwatchlogs.DeleteSubscriptionFilterInput{ 153 FilterName: aws.String(name), // Required 154 LogGroupName: aws.String(log_group_name), // Required 155 } 156 _, err := conn.DeleteSubscriptionFilter(params) 157 if err != nil { 158 return fmt.Errorf( 159 "Error deleting Subscription Filter from log group: %s with name filter name %s", log_group_name, name) 160 } 161 d.SetId("") 162 return nil 163 } 164 165 func cloudwatchLogsSubscriptionFilterId(log_group_name string) string { 166 var buf bytes.Buffer 167 168 buf.WriteString(fmt.Sprintf("%s-", log_group_name)) // only one filter allowed per log_group_name at the moment 169 170 return fmt.Sprintf("cwlsf-%d", hashcode.String(buf.String())) 171 }