134 lines
3.4 KiB
Go
134 lines
3.4 KiB
Go
package aws
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"regexp"
|
|
|
|
"github.com/aws/aws-sdk-go/aws"
|
|
"github.com/aws/aws-sdk-go/service/cloudwatchlogs"
|
|
"github.com/hashicorp/errwrap"
|
|
"github.com/hashicorp/terraform/helper/schema"
|
|
)
|
|
|
|
func resourceAwsCloudWatchLogStream() *schema.Resource {
|
|
return &schema.Resource{
|
|
Create: resourceAwsCloudWatchLogStreamCreate,
|
|
Read: resourceAwsCloudWatchLogStreamRead,
|
|
Delete: resourceAwsCloudWatchLogStreamDelete,
|
|
|
|
Schema: map[string]*schema.Schema{
|
|
"arn": {
|
|
Type: schema.TypeString,
|
|
Computed: true,
|
|
},
|
|
|
|
"name": {
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
ForceNew: true,
|
|
ValidateFunc: validateCloudWatchLogStreamName,
|
|
},
|
|
|
|
"log_group_name": {
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
ForceNew: true,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func resourceAwsCloudWatchLogStreamCreate(d *schema.ResourceData, meta interface{}) error {
|
|
conn := meta.(*AWSClient).cloudwatchlogsconn
|
|
|
|
log.Printf("[DEBUG] Creating CloudWatch Log Stream: %s", d.Get("name").(string))
|
|
_, err := conn.CreateLogStream(&cloudwatchlogs.CreateLogStreamInput{
|
|
LogGroupName: aws.String(d.Get("log_group_name").(string)),
|
|
LogStreamName: aws.String(d.Get("name").(string)),
|
|
})
|
|
if err != nil {
|
|
return errwrap.Wrapf("Creating CloudWatch Log Stream failed: {{err}}", err)
|
|
}
|
|
|
|
d.SetId(d.Get("name").(string))
|
|
|
|
return resourceAwsCloudWatchLogStreamRead(d, meta)
|
|
}
|
|
|
|
func resourceAwsCloudWatchLogStreamRead(d *schema.ResourceData, meta interface{}) error {
|
|
conn := meta.(*AWSClient).cloudwatchlogsconn
|
|
|
|
ls, exists, err := lookupCloudWatchLogStream(conn, d.Id(), d.Get("log_group_name").(string), nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !exists {
|
|
log.Printf("[DEBUG] CloudWatch Stream %q Not Found. Removing from state", d.Id())
|
|
d.SetId("")
|
|
return nil
|
|
}
|
|
|
|
d.Set("arn", ls.Arn)
|
|
d.Set("name", ls.LogStreamName)
|
|
|
|
return nil
|
|
}
|
|
|
|
func resourceAwsCloudWatchLogStreamDelete(d *schema.ResourceData, meta interface{}) error {
|
|
conn := meta.(*AWSClient).cloudwatchlogsconn
|
|
|
|
log.Printf("[INFO] Deleting CloudWatch Log Stream: %s", d.Id())
|
|
params := &cloudwatchlogs.DeleteLogStreamInput{
|
|
LogGroupName: aws.String(d.Get("log_group_name").(string)),
|
|
LogStreamName: aws.String(d.Id()),
|
|
}
|
|
_, err := conn.DeleteLogStream(params)
|
|
if err != nil {
|
|
return errwrap.Wrapf("Error deleting CloudWatch Log Stream: {{err}}", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func lookupCloudWatchLogStream(conn *cloudwatchlogs.CloudWatchLogs,
|
|
name string, logStreamName string, nextToken *string) (*cloudwatchlogs.LogStream, bool, error) {
|
|
input := &cloudwatchlogs.DescribeLogStreamsInput{
|
|
LogStreamNamePrefix: aws.String(name),
|
|
LogGroupName: aws.String(logStreamName),
|
|
NextToken: nextToken,
|
|
}
|
|
resp, err := conn.DescribeLogStreams(input)
|
|
if err != nil {
|
|
return nil, true, err
|
|
}
|
|
|
|
for _, ls := range resp.LogStreams {
|
|
if *ls.LogStreamName == name {
|
|
return ls, true, nil
|
|
}
|
|
}
|
|
|
|
if resp.NextToken != nil {
|
|
return lookupCloudWatchLogStream(conn, name, logStreamName, resp.NextToken)
|
|
}
|
|
|
|
return nil, false, nil
|
|
}
|
|
|
|
func validateCloudWatchLogStreamName(v interface{}, k string) (ws []string, errors []error) {
|
|
value := v.(string)
|
|
if regexp.MustCompile(`:`).MatchString(value) {
|
|
errors = append(errors, fmt.Errorf(
|
|
"colons not allowed in %q:", k))
|
|
}
|
|
if len(value) < 1 || len(value) > 512 {
|
|
errors = append(errors, fmt.Errorf(
|
|
"%q must be between 1 and 512 characters: %q", k, value))
|
|
}
|
|
|
|
return
|
|
|
|
}
|