provider/aws: Add support for AWS IoT

builtin/providers/aws/config.go

@@ -48,6 +48,7 @@ import (
 	"github.com/aws/aws-sdk-go/service/glacier"
 	"github.com/aws/aws-sdk-go/service/iam"
 	"github.com/aws/aws-sdk-go/service/inspector"
+	"github.com/aws/aws-sdk-go/service/iot"
 	"github.com/aws/aws-sdk-go/service/kinesis"
 	"github.com/aws/aws-sdk-go/service/kms"
 	"github.com/aws/aws-sdk-go/service/lambda"
@@ -161,6 +162,7 @@ type AWSClient struct {
 	sfnconn               *sfn.SFN
 	ssmconn               *ssm.SSM
 	wafconn               *waf.WAF
+	iotconn               *iot.IoT
 }
 
 func (c *AWSClient) S3() *s3.S3 {
@@ -274,6 +276,46 @@ func (c *Config) Client() (interface{}, error) {
 			client.partition = partition
 			client.accountid = accountId
 		}
+
+		client.apigateway = apigateway.New(sess)
+		client.appautoscalingconn = applicationautoscaling.New(sess)
+		client.autoscalingconn = autoscaling.New(sess)
+		client.cfconn = cloudformation.New(sess)
+		client.cloudfrontconn = cloudfront.New(sess)
+		client.cloudtrailconn = cloudtrail.New(sess)
+		client.cloudwatchconn = cloudwatch.New(sess)
+		client.cloudwatcheventsconn = cloudwatchevents.New(sess)
+		client.cloudwatchlogsconn = cloudwatchlogs.New(sess)
+		client.codecommitconn = codecommit.New(usEast1Sess)
+		client.codedeployconn = codedeploy.New(sess)
+		client.dsconn = directoryservice.New(sess)
+		client.dynamodbconn = dynamodb.New(dynamoSess)
+		client.ec2conn = ec2.New(awsEc2Sess)
+		client.ecrconn = ecr.New(sess)
+		client.ecsconn = ecs.New(sess)
+		client.efsconn = efs.New(sess)
+		client.elasticacheconn = elasticache.New(sess)
+		client.elasticbeanstalkconn = elasticbeanstalk.New(sess)
+		client.elastictranscoderconn = elastictranscoder.New(sess)
+		client.elbconn = elb.New(awsElbSess)
+		client.elbv2conn = elbv2.New(awsElbSess)
+		client.emrconn = emr.New(sess)
+		client.esconn = elasticsearch.New(sess)
+		client.firehoseconn = firehose.New(sess)
+		client.glacierconn = glacier.New(sess)
+		client.iotconn = iot.New(sess)
+		client.kinesisconn = kinesis.New(kinesisSess)
+		client.kmsconn = kms.New(sess)
+		client.lambdaconn = lambda.New(sess)
+		client.opsworksconn = opsworks.New(usEast1Sess)
+		client.r53conn = route53.New(usEast1Sess)
+		client.rdsconn = rds.New(sess)
+		client.redshiftconn = redshift.New(sess)
+		client.simpledbconn = simpledb.New(sess)
+		client.s3conn = s3.New(awsS3Sess)
+		client.sesConn = ses.New(sess)
+		client.snsconn = sns.New(sess)
+		client.sqsconn = sqs.New(sess)
 	}
 
 	authErr := c.ValidateAccountId(client.accountid)

builtin/providers/aws/provider.go

@@ -341,6 +341,11 @@ func Provider() terraform.ResourceProvider {
 			"aws_inspector_resource_group":                 resourceAWSInspectorResourceGroup(),
 			"aws_instance":                                 resourceAwsInstance(),
 			"aws_internet_gateway":                         resourceAwsInternetGateway(),
+			"aws_iot_thing":                                resourceAwsIotThing(),
+			"aws_iot_certificate":                          resourceAwsIotCertificate(),
+			"aws_iot_policy":                               resourceAwsIotPolicy(),
+			"aws_iot_policy_attachment":                    resourceAwsIotPolicyAttachment(),
+			"aws_iot_topic_rule":                           resourceAwsIotTopicRule(),
 			"aws_key_pair":                                 resourceAwsKeyPair(),
 			"aws_kinesis_firehose_delivery_stream":         resourceAwsKinesisFirehoseDeliveryStream(),
 			"aws_kinesis_stream":                           resourceAwsKinesisStream(),

builtin/providers/aws/resource_aws_iot_certificate.go

@@ -0,0 +1,146 @@
+package aws
+
+import (
+	"log"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/iot"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func resourceAwsIotCertificate() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsIotCertificateCreate,
+		Read:   resourceAwsIotCertificateRead,
+		Update: resourceAwsIotCertificateUpdate,
+		Delete: resourceAwsIotCertificateDelete,
+		Schema: map[string]*schema.Schema{
+			"csr": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"active": &schema.Schema{
+				Type:     schema.TypeBool,
+				Required: true,
+			},
+			"arn": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func resourceAwsIotCertificateCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).iotconn
+
+	log.Printf("[DEBUG] Creating certificate from csr")
+	out, err := conn.CreateCertificateFromCsr(&iot.CreateCertificateFromCsrInput{
+		CertificateSigningRequest: aws.String(d.Get("csr").(string)),
+		SetAsActive:               aws.Bool(d.Get("active").(bool)),
+	})
+
+	if err != nil {
+		log.Printf("[ERROR] %s", err)
+		return err
+	}
+	log.Printf("[DEBUG] Created certificate from csr")
+
+	d.SetId(*out.CertificateId)
+
+	return resourceAwsIotCertificateRead(d, meta)
+}
+
+func resourceAwsIotCertificateRead(d *schema.ResourceData, meta interface{}) error {
+
+	conn := meta.(*AWSClient).iotconn
+
+	out, err := conn.DescribeCertificate(&iot.DescribeCertificateInput{
+		CertificateId: aws.String(d.Id()),
+	})
+
+	if err != nil {
+		log.Printf("[ERROR] %s", err)
+		return err
+	}
+
+	d.Set("arn", out.CertificateDescription.CertificateArn)
+
+	return nil
+}
+
+func resourceAwsIotCertificateUpdate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).iotconn
+
+	if d.HasChange("csr") {
+		// First create certificate with new CSR
+		out, err := conn.CreateCertificateFromCsr(&iot.CreateCertificateFromCsrInput{
+			CertificateSigningRequest: aws.String(d.Get("csr").(string)),
+			SetAsActive:               aws.Bool(d.Get("active").(bool)),
+		})
+
+		if err != nil {
+			log.Printf("[ERROR] %s", err)
+			return nil
+		}
+
+		// If everything worked, make the old one inactive
+		_, err = conn.UpdateCertificate(&iot.UpdateCertificateInput{
+			CertificateId: aws.String(d.Id()),
+			NewStatus:     aws.String("INACTIVE"),
+		})
+
+		if err != nil {
+			log.Printf("[ERROR] %s", err)
+			return err
+		}
+
+		d.SetId(*out.CertificateId)
+
+	} else {
+
+		if d.HasChange("active") {
+			status := "INACTIVE"
+			if d.Get("active").(bool) {
+				status = "ACTIVE"
+			}
+
+			_, err := conn.UpdateCertificate(&iot.UpdateCertificateInput{
+				CertificateId: aws.String(d.Id()),
+				NewStatus:     aws.String(status),
+			})
+
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return resourceAwsIotCertificateRead(d, meta)
+}
+
+func resourceAwsIotCertificateDelete(d *schema.ResourceData, meta interface{}) error {
+
+	conn := meta.(*AWSClient).iotconn
+
+	_, err := conn.UpdateCertificate(&iot.UpdateCertificateInput{
+		CertificateId: aws.String(d.Id()),
+		NewStatus:     aws.String("INACTIVE"),
+	})
+
+	if err != nil {
+		log.Printf("[ERROR], %s", err)
+		return err
+	}
+
+	_, err = conn.DeleteCertificate(&iot.DeleteCertificateInput{
+		CertificateId: aws.String(d.Id()),
+	})
+
+	if err != nil {
+		log.Printf("[ERROR] %s", err)
+		return err
+	}
+
+	return nil
+}

builtin/providers/aws/resource_aws_iot_certificate_test.go

@@ -0,0 +1,69 @@
+package aws
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/service/iot"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAWSIoTCertificate_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAWSIoTCertificateDestroy_basic,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccAWSIoTCertificate_basic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAWSIoTCertificateExists_basic("aws_iot_certificate.foo_cert"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckAWSIoTCertificateDestroy_basic(s *terraform.State) error {
+	conn := testAccProvider.Meta().(*AWSClient).iotconn
+
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "aws_iot_certificate" {
+			continue
+		}
+
+		out, err := conn.ListCertificates(&iot.ListCertificatesInput{})
+
+		if err != nil {
+			return err
+		}
+
+		for _, t := range out.Certificates {
+			if *t.CertificateId == rs.Primary.ID {
+				return fmt.Errorf("IoT certificate still exists:\n%s", t)
+			}
+		}
+
+	}
+
+	return nil
+}
+
+func testAccCheckAWSIoTCertificateExists_basic(name string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		_, ok := s.RootModule().Resources[name]
+		if !ok {
+			return fmt.Errorf("Not found: %s", name)
+		}
+
+		return nil
+	}
+}
+
+var testAccAWSIoTCertificate_basic = `
+resource "aws_iot_certificate" "foo_cert" {
+	csr = "${file("test-fixtures/csr.pem")}"
+  active = true
+}
+`