github.com/anuaimi/terraform@v0.6.4-0.20150904235404-2bf9aec61da8/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.Int64(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  	}
    86  	resp, err := conn.DescribeStream(describeOpts)
    87  	if err != nil {
    88  		if awsErr, ok := err.(awserr.Error); ok {
    89  			if awsErr.Code() == "ResourceNotFoundException" {
    90  				d.SetId("")
    91  				return nil
    92  			}
    93  			return fmt.Errorf("[WARN] Error reading Kinesis Stream: \"%s\", code: \"%s\"", awsErr.Message(), awsErr.Code())
    94  		}
    95  		return err
    96  	}
    97  
    98  	s := resp.StreamDescription
    99  	d.Set("arn", *s.StreamARN)
   100  	d.Set("shard_count", len(s.Shards))
   101  
   102  	return nil
   103  }
   104  
   105  func resourceAwsKinesisStreamDelete(d *schema.ResourceData, meta interface{}) error {
   106  	conn := meta.(*AWSClient).kinesisconn
   107  	sn := d.Get("name").(string)
   108  	_, err := conn.DeleteStream(&kinesis.DeleteStreamInput{
   109  		StreamName: aws.String(sn),
   110  	})
   111  
   112  	if err != nil {
   113  		return err
   114  	}
   115  
   116  	stateConf := &resource.StateChangeConf{
   117  		Pending:    []string{"DELETING"},
   118  		Target:     "DESTROYED",
   119  		Refresh:    streamStateRefreshFunc(conn, sn),
   120  		Timeout:    5 * time.Minute,
   121  		Delay:      10 * time.Second,
   122  		MinTimeout: 3 * time.Second,
   123  	}
   124  
   125  	_, err = stateConf.WaitForState()
   126  	if err != nil {
   127  		return fmt.Errorf(
   128  			"Error waiting for Stream (%s) to be destroyed: %s",
   129  			sn, err)
   130  	}
   131  
   132  	d.SetId("")
   133  	return nil
   134  }
   135  
   136  func streamStateRefreshFunc(conn *kinesis.Kinesis, sn string) resource.StateRefreshFunc {
   137  	return func() (interface{}, string, error) {
   138  		describeOpts := &kinesis.DescribeStreamInput{
   139  			StreamName: aws.String(sn),
   140  		}
   141  		resp, err := conn.DescribeStream(describeOpts)
   142  		if err != nil {
   143  			if awsErr, ok := err.(awserr.Error); ok {
   144  				if awsErr.Code() == "ResourceNotFoundException" {
   145  					return 42, "DESTROYED", nil
   146  				}
   147  				return nil, awsErr.Code(), err
   148  			}
   149  			return nil, "failed", err
   150  		}
   151  
   152  		return resp.StreamDescription, *resp.StreamDescription.StreamStatus, nil
   153  	}
   154  }