github.com/IBM-Cloud/terraform@v0.6.4-0.20170726051544-8872b87621df/builtin/providers/aws/resource_aws_cloudwatch_log_group.go (about) 1 package aws 2 3 import ( 4 "fmt" 5 "log" 6 7 "github.com/hashicorp/terraform/helper/resource" 8 "github.com/hashicorp/terraform/helper/schema" 9 10 "github.com/aws/aws-sdk-go/aws" 11 "github.com/aws/aws-sdk-go/aws/awserr" 12 "github.com/aws/aws-sdk-go/service/cloudwatchlogs" 13 "github.com/hashicorp/errwrap" 14 ) 15 16 func resourceAwsCloudWatchLogGroup() *schema.Resource { 17 return &schema.Resource{ 18 Create: resourceAwsCloudWatchLogGroupCreate, 19 Read: resourceAwsCloudWatchLogGroupRead, 20 Update: resourceAwsCloudWatchLogGroupUpdate, 21 Delete: resourceAwsCloudWatchLogGroupDelete, 22 Importer: &schema.ResourceImporter{ 23 State: schema.ImportStatePassthrough, 24 }, 25 26 Schema: map[string]*schema.Schema{ 27 "name": { 28 Type: schema.TypeString, 29 Optional: true, 30 Computed: true, 31 ForceNew: true, 32 ConflictsWith: []string{"name_prefix"}, 33 ValidateFunc: validateLogGroupName, 34 }, 35 "name_prefix": { 36 Type: schema.TypeString, 37 Optional: true, 38 ForceNew: true, 39 ValidateFunc: validateLogGroupNamePrefix, 40 }, 41 42 "retention_in_days": { 43 Type: schema.TypeInt, 44 Optional: true, 45 Default: 0, 46 }, 47 48 "arn": { 49 Type: schema.TypeString, 50 Computed: true, 51 }, 52 53 "tags": tagsSchema(), 54 }, 55 } 56 } 57 58 func resourceAwsCloudWatchLogGroupCreate(d *schema.ResourceData, meta interface{}) error { 59 conn := meta.(*AWSClient).cloudwatchlogsconn 60 61 var logGroupName string 62 if v, ok := d.GetOk("name"); ok { 63 logGroupName = v.(string) 64 } else if v, ok := d.GetOk("name_prefix"); ok { 65 logGroupName = resource.PrefixedUniqueId(v.(string)) 66 } else { 67 logGroupName = resource.UniqueId() 68 } 69 70 log.Printf("[DEBUG] Creating CloudWatch Log Group: %s", logGroupName) 71 72 _, err := conn.CreateLogGroup(&cloudwatchlogs.CreateLogGroupInput{ 73 LogGroupName: aws.String(logGroupName), 74 }) 75 if err != nil { 76 if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "ResourceAlreadyExistsException" { 77 return fmt.Errorf("Creating CloudWatch Log Group failed: %s: The CloudWatch Log Group '%s' already exists.", err, d.Get("name").(string)) 78 } 79 return fmt.Errorf("Creating CloudWatch Log Group failed: %s '%s'", err, d.Get("name")) 80 } 81 82 d.SetId(logGroupName) 83 84 log.Println("[INFO] CloudWatch Log Group created") 85 86 return resourceAwsCloudWatchLogGroupUpdate(d, meta) 87 } 88 89 func resourceAwsCloudWatchLogGroupRead(d *schema.ResourceData, meta interface{}) error { 90 conn := meta.(*AWSClient).cloudwatchlogsconn 91 log.Printf("[DEBUG] Reading CloudWatch Log Group: %q", d.Get("name").(string)) 92 lg, exists, err := lookupCloudWatchLogGroup(conn, d.Id(), nil) 93 if err != nil { 94 return err 95 } 96 97 if !exists { 98 log.Printf("[DEBUG] CloudWatch Group %q Not Found", d.Id()) 99 d.SetId("") 100 return nil 101 } 102 103 log.Printf("[DEBUG] Found Log Group: %#v", *lg) 104 105 d.Set("arn", lg.Arn) 106 d.Set("name", lg.LogGroupName) 107 108 if lg.RetentionInDays != nil { 109 d.Set("retention_in_days", lg.RetentionInDays) 110 } 111 112 if !meta.(*AWSClient).IsChinaCloud() && !meta.(*AWSClient).IsGovCloud() { 113 tags, err := flattenCloudWatchTags(d, conn) 114 if err != nil { 115 return err 116 } 117 d.Set("tags", tags) 118 } 119 120 return nil 121 } 122 123 func lookupCloudWatchLogGroup(conn *cloudwatchlogs.CloudWatchLogs, 124 name string, nextToken *string) (*cloudwatchlogs.LogGroup, bool, error) { 125 input := &cloudwatchlogs.DescribeLogGroupsInput{ 126 LogGroupNamePrefix: aws.String(name), 127 NextToken: nextToken, 128 } 129 resp, err := conn.DescribeLogGroups(input) 130 if err != nil { 131 return nil, true, err 132 } 133 134 for _, lg := range resp.LogGroups { 135 if *lg.LogGroupName == name { 136 return lg, true, nil 137 } 138 } 139 140 if resp.NextToken != nil { 141 return lookupCloudWatchLogGroup(conn, name, resp.NextToken) 142 } 143 144 return nil, false, nil 145 } 146 147 func resourceAwsCloudWatchLogGroupUpdate(d *schema.ResourceData, meta interface{}) error { 148 conn := meta.(*AWSClient).cloudwatchlogsconn 149 150 name := d.Get("name").(string) 151 log.Printf("[DEBUG] Updating CloudWatch Log Group: %q", name) 152 153 if d.HasChange("retention_in_days") { 154 var err error 155 156 if v, ok := d.GetOk("retention_in_days"); ok { 157 input := cloudwatchlogs.PutRetentionPolicyInput{ 158 LogGroupName: aws.String(name), 159 RetentionInDays: aws.Int64(int64(v.(int))), 160 } 161 log.Printf("[DEBUG] Setting retention for CloudWatch Log Group: %q: %s", name, input) 162 _, err = conn.PutRetentionPolicy(&input) 163 } else { 164 log.Printf("[DEBUG] Deleting retention for CloudWatch Log Group: %q", name) 165 _, err = conn.DeleteRetentionPolicy(&cloudwatchlogs.DeleteRetentionPolicyInput{ 166 LogGroupName: aws.String(name), 167 }) 168 } 169 170 if err != nil { 171 return err 172 } 173 } 174 175 restricted := meta.(*AWSClient).IsChinaCloud() || meta.(*AWSClient).IsGovCloud() 176 177 if !restricted && d.HasChange("tags") { 178 oraw, nraw := d.GetChange("tags") 179 o := oraw.(map[string]interface{}) 180 n := nraw.(map[string]interface{}) 181 create, remove := diffCloudWatchTags(o, n) 182 183 if len(remove) > 0 { 184 log.Printf("[DEBUG] Removing tags from %s", name) 185 _, err := conn.UntagLogGroup(&cloudwatchlogs.UntagLogGroupInput{ 186 LogGroupName: aws.String(name), 187 Tags: remove, 188 }) 189 if err != nil { 190 return err 191 } 192 } 193 194 if len(create) > 0 { 195 log.Printf("[DEBUG] Creating tags on %s", name) 196 _, err := conn.TagLogGroup(&cloudwatchlogs.TagLogGroupInput{ 197 LogGroupName: aws.String(name), 198 Tags: create, 199 }) 200 if err != nil { 201 return err 202 } 203 } 204 } 205 206 return resourceAwsCloudWatchLogGroupRead(d, meta) 207 } 208 209 func diffCloudWatchTags(oldTags map[string]interface{}, newTags map[string]interface{}) (map[string]*string, []*string) { 210 create := make(map[string]*string) 211 for k, v := range newTags { 212 create[k] = aws.String(v.(string)) 213 } 214 215 var remove []*string 216 for _, t := range oldTags { 217 old, ok := create[t.(string)] 218 if !ok || *old != t.(string) { 219 remove = append(remove, aws.String(t.(string))) 220 } 221 } 222 223 return create, remove 224 } 225 226 func resourceAwsCloudWatchLogGroupDelete(d *schema.ResourceData, meta interface{}) error { 227 conn := meta.(*AWSClient).cloudwatchlogsconn 228 log.Printf("[INFO] Deleting CloudWatch Log Group: %s", d.Id()) 229 _, err := conn.DeleteLogGroup(&cloudwatchlogs.DeleteLogGroupInput{ 230 LogGroupName: aws.String(d.Get("name").(string)), 231 }) 232 if err != nil { 233 return fmt.Errorf("Error deleting CloudWatch Log Group: %s", err) 234 } 235 log.Println("[INFO] CloudWatch Log Group deleted") 236 237 d.SetId("") 238 239 return nil 240 } 241 242 func flattenCloudWatchTags(d *schema.ResourceData, conn *cloudwatchlogs.CloudWatchLogs) (map[string]interface{}, error) { 243 tagsOutput, err := conn.ListTagsLogGroup(&cloudwatchlogs.ListTagsLogGroupInput{ 244 LogGroupName: aws.String(d.Get("name").(string)), 245 }) 246 if err != nil { 247 return nil, errwrap.Wrapf("Error Getting CloudWatch Logs Tag List: {{err}}", err) 248 } 249 if tagsOutput != nil { 250 output := make(map[string]interface{}, len(tagsOutput.Tags)) 251 252 for i, v := range tagsOutput.Tags { 253 output[i] = *v 254 } 255 256 return output, nil 257 } 258 259 return make(map[string]interface{}), nil 260 }