github.com/hobbeswalsh/terraform@v0.3.7-0.20150619183303-ad17cf55a0fa/builtin/providers/aws/resource_aws_kinesis_stream.go (about)

     1  package aws
     2  
     3  import (
     4  	"fmt"
     5  	"time"
     6  
     7  	"github.com/aws/aws-sdk-go/aws"
     8  	"github.com/aws/aws-sdk-go/aws/awserr"
     9  	"github.com/aws/aws-sdk-go/service/kinesis"
    10  	"github.com/hashicorp/terraform/helper/resource"
    11  	"github.com/hashicorp/terraform/helper/schema"
    12  )
    13  
    14  func resourceAwsKinesisStream() *schema.Resource {
    15  	return &schema.Resource{
    16  		Create: resourceAwsKinesisStreamCreate,
    17  		Read:   resourceAwsKinesisStreamRead,
    18  		Delete: resourceAwsKinesisStreamDelete,
    19  
    20  		Schema: map[string]*schema.Schema{
    21  			"name": &schema.Schema{
    22  				Type:     schema.TypeString,
    23  				Required: true,
    24  				ForceNew: true,
    25  			},
    26  
    27  			"shard_count": &schema.Schema{
    28  				Type:     schema.TypeInt,
    29  				Required: true,
    30  				ForceNew: true,
    31  			},
    32  
    33  			"arn": &schema.Schema{
    34  				Type:     schema.TypeString,
    35  				Optional: true,
    36  				Computed: true,
    37  			},
    38  		},
    39  	}
    40  }
    41  
    42  func resourceAwsKinesisStreamCreate(d *schema.ResourceData, meta interface{}) error {
    43  	conn := meta.(*AWSClient).kinesisconn
    44  	sn := d.Get("name").(string)
    45  	createOpts := &kinesis.CreateStreamInput{
    46  		ShardCount: aws.Long(int64(d.Get("shard_count").(int))),
    47  		StreamName: aws.String(sn),
    48  	}
    49  
    50  	_, err := conn.CreateStream(createOpts)
    51  	if err != nil {
    52  		if awsErr, ok := err.(awserr.Error); ok {
    53  			return fmt.Errorf("[WARN] Error creating Kinesis Stream: \"%s\", code: \"%s\"", awsErr.Message(), awsErr.Code())
    54  		}
    55  		return err
    56  	}
    57  
    58  	stateConf := &resource.StateChangeConf{
    59  		Pending:    []string{"CREATING"},
    60  		Target:     "ACTIVE",
    61  		Refresh:    streamStateRefreshFunc(conn, sn),
    62  		Timeout:    5 * time.Minute,
    63  		Delay:      10 * time.Second,
    64  		MinTimeout: 3 * time.Second,
    65  	}
    66  
    67  	streamRaw, err := stateConf.WaitForState()
    68  	if err != nil {
    69  		return fmt.Errorf(
    70  			"Error waiting for Kinesis Stream (%s) to become active: %s",
    71  			sn, err)
    72  	}
    73  
    74  	s := streamRaw.(*kinesis.StreamDescription)
    75  	d.SetId(*s.StreamARN)
    76  	d.Set("arn", s.StreamARN)
    77  
    78  	return nil
    79  }
    80  
    81  func resourceAwsKinesisStreamRead(d *schema.ResourceData, meta interface{}) error {
    82  	conn := meta.(*AWSClient).kinesisconn
    83  	describeOpts := &kinesis.DescribeStreamInput{
    84  		StreamName: aws.String(d.Get("name").(string)),
    85  		Limit:      aws.Long(1),
    86  	}
    87  	resp, err := conn.DescribeStream(describeOpts)
    88  	if err != nil {
    89  		if awsErr, ok := err.(awserr.Error); ok {
    90  			if awsErr.Code() == "ResourceNotFoundException" {
    91  				d.SetId("")
    92  				return nil
    93  			}
    94  			return fmt.Errorf("[WARN] Error reading Kinesis Stream: \"%s\", code: \"%s\"", awsErr.Message(), awsErr.Code())
    95  		}
    96  		return err
    97  	}
    98  
    99  	s := resp.StreamDescription
   100  	d.Set("arn", *s.StreamARN)
   101  	d.Set("shard_count", len(s.Shards))
   102  
   103  	return nil
   104  }
   105  
   106  func resourceAwsKinesisStreamDelete(d *schema.ResourceData, meta interface{}) error {
   107  	conn := meta.(*AWSClient).kinesisconn
   108  	sn := d.Get("name").(string)
   109  	_, err := conn.DeleteStream(&kinesis.DeleteStreamInput{
   110  		StreamName: aws.String(sn),
   111  	})
   112  
   113  	if err != nil {
   114  		return err
   115  	}
   116  
   117  	stateConf := &resource.StateChangeConf{
   118  		Pending:    []string{"DELETING"},
   119  		Target:     "DESTROYED",
   120  		Refresh:    streamStateRefreshFunc(conn, sn),
   121  		Timeout:    5 * time.Minute,
   122  		Delay:      10 * time.Second,
   123  		MinTimeout: 3 * time.Second,
   124  	}
   125  
   126  	_, err = stateConf.WaitForState()
   127  	if err != nil {
   128  		return fmt.Errorf(
   129  			"Error waiting for Stream (%s) to be destroyed: %s",
   130  			sn, err)
   131  	}
   132  
   133  	d.SetId("")
   134  	return nil
   135  }
   136  
   137  func streamStateRefreshFunc(conn *kinesis.Kinesis, sn string) resource.StateRefreshFunc {
   138  	return func() (interface{}, string, error) {
   139  		describeOpts := &kinesis.DescribeStreamInput{
   140  			StreamName: aws.String(sn),
   141  			Limit:      aws.Long(1),
   142  		}
   143  		resp, err := conn.DescribeStream(describeOpts)
   144  		if err != nil {
   145  			if awsErr, ok := err.(awserr.Error); ok {
   146  				if awsErr.Code() == "ResourceNotFoundException" {
   147  					return 42, "DESTROYED", nil
   148  				}
   149  				return nil, awsErr.Code(), err
   150  			}
   151  			return nil, "failed", err
   152  		}
   153  
   154  		return resp.StreamDescription, *resp.StreamDescription.StreamStatus, nil
   155  	}
   156  }