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  }