github.com/danrjohnson/terraform@v0.7.0-rc2.0.20160627135212-d0fc1fa086ff/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/schema"
     8  
     9  	"github.com/aws/aws-sdk-go/aws"
    10  	"github.com/aws/aws-sdk-go/service/cloudwatchlogs"
    11  )
    12  
    13  func resourceAwsCloudWatchLogGroup() *schema.Resource {
    14  	return &schema.Resource{
    15  		Create: resourceAwsCloudWatchLogGroupCreate,
    16  		Read:   resourceAwsCloudWatchLogGroupRead,
    17  		Update: resourceAwsCloudWatchLogGroupUpdate,
    18  		Delete: resourceAwsCloudWatchLogGroupDelete,
    19  		Importer: &schema.ResourceImporter{
    20  			State: schema.ImportStatePassthrough,
    21  		},
    22  
    23  		Schema: map[string]*schema.Schema{
    24  			"name": &schema.Schema{
    25  				Type:         schema.TypeString,
    26  				Required:     true,
    27  				ForceNew:     true,
    28  				ValidateFunc: validateLogGroupName,
    29  			},
    30  
    31  			"retention_in_days": &schema.Schema{
    32  				Type:     schema.TypeInt,
    33  				Optional: true,
    34  				Default:  0,
    35  			},
    36  
    37  			"arn": &schema.Schema{
    38  				Type:     schema.TypeString,
    39  				Computed: true,
    40  			},
    41  		},
    42  	}
    43  }
    44  
    45  func resourceAwsCloudWatchLogGroupCreate(d *schema.ResourceData, meta interface{}) error {
    46  	conn := meta.(*AWSClient).cloudwatchlogsconn
    47  
    48  	log.Printf("[DEBUG] Creating CloudWatch Log Group: %s", d.Get("name").(string))
    49  	_, err := conn.CreateLogGroup(&cloudwatchlogs.CreateLogGroupInput{
    50  		LogGroupName: aws.String(d.Get("name").(string)),
    51  	})
    52  	if err != nil {
    53  		return fmt.Errorf("Creating CloudWatch Log Group failed: %s", err)
    54  	}
    55  
    56  	d.SetId(d.Get("name").(string))
    57  
    58  	log.Println("[INFO] CloudWatch Log Group created")
    59  
    60  	return resourceAwsCloudWatchLogGroupUpdate(d, meta)
    61  }
    62  
    63  func resourceAwsCloudWatchLogGroupRead(d *schema.ResourceData, meta interface{}) error {
    64  	conn := meta.(*AWSClient).cloudwatchlogsconn
    65  	log.Printf("[DEBUG] Reading CloudWatch Log Group: %q", d.Get("name").(string))
    66  	lg, err := lookupCloudWatchLogGroup(conn, d.Id(), nil)
    67  	if err != nil {
    68  		return err
    69  	}
    70  
    71  	log.Printf("[DEBUG] Found Log Group: %#v", *lg)
    72  
    73  	d.Set("arn", *lg.Arn)
    74  	d.Set("name", *lg.LogGroupName)
    75  
    76  	if lg.RetentionInDays != nil {
    77  		d.Set("retention_in_days", *lg.RetentionInDays)
    78  	}
    79  
    80  	return nil
    81  }
    82  
    83  func lookupCloudWatchLogGroup(conn *cloudwatchlogs.CloudWatchLogs,
    84  	name string, nextToken *string) (*cloudwatchlogs.LogGroup, error) {
    85  	input := &cloudwatchlogs.DescribeLogGroupsInput{
    86  		LogGroupNamePrefix: aws.String(name),
    87  		NextToken:          nextToken,
    88  	}
    89  	resp, err := conn.DescribeLogGroups(input)
    90  	if err != nil {
    91  		return nil, err
    92  	}
    93  
    94  	for _, lg := range resp.LogGroups {
    95  		if *lg.LogGroupName == name {
    96  			return lg, nil
    97  		}
    98  	}
    99  
   100  	if resp.NextToken != nil {
   101  		return lookupCloudWatchLogGroup(conn, name, resp.NextToken)
   102  	}
   103  
   104  	return nil, fmt.Errorf("CloudWatch Log Group %q not found", name)
   105  }
   106  
   107  func resourceAwsCloudWatchLogGroupUpdate(d *schema.ResourceData, meta interface{}) error {
   108  	conn := meta.(*AWSClient).cloudwatchlogsconn
   109  
   110  	name := d.Get("name").(string)
   111  	log.Printf("[DEBUG] Updating CloudWatch Log Group: %q", name)
   112  
   113  	if d.HasChange("retention_in_days") {
   114  		var err error
   115  
   116  		if v, ok := d.GetOk("retention_in_days"); ok {
   117  			input := cloudwatchlogs.PutRetentionPolicyInput{
   118  				LogGroupName:    aws.String(name),
   119  				RetentionInDays: aws.Int64(int64(v.(int))),
   120  			}
   121  			log.Printf("[DEBUG] Setting retention for CloudWatch Log Group: %q: %s", name, input)
   122  			_, err = conn.PutRetentionPolicy(&input)
   123  		} else {
   124  			log.Printf("[DEBUG] Deleting retention for CloudWatch Log Group: %q", name)
   125  			_, err = conn.DeleteRetentionPolicy(&cloudwatchlogs.DeleteRetentionPolicyInput{
   126  				LogGroupName: aws.String(name),
   127  			})
   128  		}
   129  
   130  		if err != nil {
   131  			return err
   132  		}
   133  	}
   134  
   135  	return resourceAwsCloudWatchLogGroupRead(d, meta)
   136  }
   137  
   138  func resourceAwsCloudWatchLogGroupDelete(d *schema.ResourceData, meta interface{}) error {
   139  	conn := meta.(*AWSClient).cloudwatchlogsconn
   140  	log.Printf("[INFO] Deleting CloudWatch Log Group: %s", d.Id())
   141  	_, err := conn.DeleteLogGroup(&cloudwatchlogs.DeleteLogGroupInput{
   142  		LogGroupName: aws.String(d.Get("name").(string)),
   143  	})
   144  	if err != nil {
   145  		return fmt.Errorf("Error deleting CloudWatch Log Group: %s", err)
   146  	}
   147  	log.Println("[INFO] CloudWatch Log Group deleted")
   148  
   149  	d.SetId("")
   150  
   151  	return nil
   152  }