Merge remote-tracking branch 'upstream/master'

CHANGELOG.md

@@ -3,6 +3,8 @@
 FEATURES:
  * **New provider: `vcd` - VMware vCloud Director** [GH-3785]
  * **New provider: `postgresql` - Create PostgreSQL databases and roles** [GH-3653]
+ * **New provider: `chef` - Create chef environments, roles, etc** [GH-3084]
+ * **New resource: `aws_autoscaling_schedule`** [GH-4256]
  * **New resource: `google_pubsub_topic`** [GH-3671]
  * **New resource: `google_pubsub_subscription`** [GH-3671]
  * **New resource: `tls_locally_signed_cert`** [GH-3930]
@@ -19,6 +21,7 @@ IMPROVEMENTS:
  * provider/aws: Add support for `skip_final_snapshot` to `aws_db_instance` [GH-3853]
  * provider/aws: Adding support for Tags to DB SecurityGroup [GH-4260]
  * provider/aws: Adding Tag support for DB Param Groups [GH-4259]
+ * provider/aws: Validate IOPs for EBS Volumes [GH-4146]
  * provider/aws: DB Subnet group arn output [GH-4261]
  * provider/cloudstack: performance improvements [GH-4150]
  * provider/docker: Add support for setting the entry point on `docker_container` resources [GH-3761]
@@ -32,6 +35,7 @@ IMPROVEMENTS:
  * provider/vsphere: Add folder handling for folder-qualified vm names [GH-3939]
  * provider/vsphere: Change ip_address parameter for ipv6 support [GH-4035]
  * provider/openstack: Increase instance timeout from 10 to 30 minutes [GH-4223]
+ * provider/google: Add `restart_policy` attribute to `google_managed_instance_group` [GH-3892]
 
 BUG FIXES:
 
@@ -48,6 +52,8 @@ BUG FIXES:
  * provider/aws: Fix missing AMI issue with Launch Configurations [GH-4242]
  * provider/aws: Opsworks stack SSH key is write-only [GH-4241]
  * provider/aws: Fix issue with ElasticSearch Domain `access_policies` always appear changed [GH-4245]
+ * provider/aws: Fix issue with nil parameter group value causing panic in `aws_db_parameter_group` [GH-4318]
+ * provider/azure: Update for [breaking change to upstream client library](https://github.com/Azure/azure-sdk-for-go/commit/68d50cb53a73edfeb7f17f5e86cdc8eb359a9528). [GH-4300]
  * provider/digitalocean: Fix issue where a floating IP attached to a missing droplet causes a panic [GH-4214]
  * provider/openstack: Handle volumes in "deleting" state [GH-4204]
  * provider/vsphere: Create and attach additional disks before bootup [GH-4196]

builtin/bins/provider-chef/main.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+ "github.com/hashicorp/terraform/builtin/providers/chef"
+ "github.com/hashicorp/terraform/plugin"
+)
+
+func main() {
+ plugin.Serve(&plugin.ServeOpts{
+ ProviderFunc: chef.Provider,
+ })
+}

builtin/providers/aws/provider.go

@@ -174,6 +174,7 @@ func Provider() terraform.ResourceProvider {
  "aws_autoscaling_group": resourceAwsAutoscalingGroup(),
  "aws_autoscaling_notification": resourceAwsAutoscalingNotification(),
  "aws_autoscaling_policy": resourceAwsAutoscalingPolicy(),
+ "aws_autoscaling_schedule": resourceAwsAutoscalingSchedule(),
  "aws_cloudformation_stack": resourceAwsCloudFormationStack(),
  "aws_cloudtrail": resourceAwsCloudTrail(),
  "aws_cloudwatch_log_group": resourceAwsCloudWatchLogGroup(),

builtin/providers/aws/resource_aws_autoscaling_schedule.go

@@ -0,0 +1,189 @@
+package aws
+
+import (
+ "fmt"
+ "log"
+ "time"
+
+ "github.com/aws/aws-sdk-go/aws"
+ "github.com/aws/aws-sdk-go/service/autoscaling"
+ "github.com/hashicorp/terraform/helper/schema"
+)
+
+const awsAutoscalingScheduleTimeLayout = "2006-01-02T15:04:05Z"
+
+func resourceAwsAutoscalingSchedule() *schema.Resource {
+ return &schema.Resource{
+ Create: resourceAwsAutoscalingScheduleCreate,
+ Read: resourceAwsAutoscalingScheduleRead,
+ Update: resourceAwsAutoscalingScheduleCreate,
+ Delete: resourceAwsAutoscalingScheduleDelete,
+
+ Schema: map[string]*schema.Schema{
+ "arn": &schema.Schema{
+ Type: schema.TypeString,
+ Computed: true,
+ },
+ "scheduled_action_name": &schema.Schema{
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+ "autoscaling_group_name": &schema.Schema{
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+ "start_time": &schema.Schema{
+ Type: schema.TypeString,
+ Optional: true,
+ Computed: true,
+ ValidateFunc: validateASGScheduleTimestamp,
+ },
+ "end_time": &schema.Schema{
+ Type: schema.TypeString,
+ Optional: true,
+ Computed: true,
+ ValidateFunc: validateASGScheduleTimestamp,
+ },
+ "recurrence": &schema.Schema{
+ Type: schema.TypeString,
+ Optional: true,
+ Computed: true,
+ },
+ "min_size": &schema.Schema{
+ Type: schema.TypeInt,
+ Optional: true,
+ Computed: true,
+ },
+ "max_size": &schema.Schema{
+ Type: schema.TypeInt,
+ Optional: true,
+ Computed: true,
+ },
+ "desired_capacity": &schema.Schema{
+ Type: schema.TypeInt,
+ Optional: true,
+ Computed: true,
+ },
+ },
+ }
+}
+
+func resourceAwsAutoscalingScheduleCreate(d *schema.ResourceData, meta interface{}) error {
+ autoscalingconn := meta.(*AWSClient).autoscalingconn
+ params := &autoscaling.PutScheduledUpdateGroupActionInput{
+ AutoScalingGroupName: aws.String(d.Get("autoscaling_group_name").(string)),
+ ScheduledActionName: aws.String(d.Get("scheduled_action_name").(string)),
+ }
+
+ if attr, ok := d.GetOk("start_time"); ok {
+ t, err := time.Parse(awsAutoscalingScheduleTimeLayout, attr.(string))
+ if err != nil {
+ return fmt.Errorf("Error Parsing AWS Autoscaling Group Schedule Start Time: %s", err.Error())
+ }
+ params.StartTime = aws.Time(t)
+ }
+
+ if attr, ok := d.GetOk("end_time"); ok {
+ t, err := time.Parse(awsAutoscalingScheduleTimeLayout, attr.(string))
+ if err != nil {
+ return fmt.Errorf("Error Parsing AWS Autoscaling Group Schedule End Time: %s", err.Error())
+ }
+ params.EndTime = aws.Time(t)
+ }
+
+ if attr, ok := d.GetOk("recurrance"); ok {
+ params.Recurrence = aws.String(attr.(string))
+ }
+
+ if attr, ok := d.GetOk("min_size"); ok {
+ params.MinSize = aws.Int64(int64(attr.(int)))
+ }
+
+ if attr, ok := d.GetOk("max_size"); ok {
+ params.MaxSize = aws.Int64(int64(attr.(int)))
+ }
+
+ if attr, ok := d.GetOk("desired_capacity"); ok {
+ params.DesiredCapacity = aws.Int64(int64(attr.(int)))
+ }
+
+ log.Printf("[INFO] Creating Autoscaling Scheduled Action: %s", d.Get("scheduled_action_name").(string))
+ _, err := autoscalingconn.PutScheduledUpdateGroupAction(params)
+ if err != nil {
+ return fmt.Errorf("Error Creating Autoscaling Scheduled Action: %s", err.Error())
+ }
+
+ d.SetId(d.Get("scheduled_action_name").(string))
+
+ return resourceAwsAutoscalingScheduleRead(d, meta)
+}
+
+func resourceAwsAutoscalingScheduleRead(d *schema.ResourceData, meta interface{}) error {
+ sa, err := resourceAwsASGScheduledActionRetrieve(d, meta)
+ if err != nil {
+ return err
+ }
+
+ d.Set("autoscaling_group_name", sa.AutoScalingGroupName)
+ d.Set("arn", sa.ScheduledActionARN)
+ d.Set("desired_capacity", sa.DesiredCapacity)
+ d.Set("min_size", sa.MinSize)
+ d.Set("max_size", sa.MaxSize)
+ d.Set("recurrance", sa.Recurrence)
+ d.Set("start_time", sa.StartTime.Format(awsAutoscalingScheduleTimeLayout))
+ d.Set("end_time", sa.EndTime.Format(awsAutoscalingScheduleTimeLayout))
+
+ return nil
+}
+
+func resourceAwsAutoscalingScheduleDelete(d *schema.ResourceData, meta interface{}) error {
+ autoscalingconn := meta.(*AWSClient).autoscalingconn
+
+ params := &autoscaling.DeleteScheduledActionInput{
+ AutoScalingGroupName: aws.String(d.Get("autoscaling_group_name").(string)),
+ ScheduledActionName: aws.String(d.Id()),
+ }
+
+ log.Printf("[INFO] Deleting Autoscaling Scheduled Action: %s", d.Id())
+ _, err := autoscalingconn.DeleteScheduledAction(params)
+ if err != nil {
+ return fmt.Errorf("Error deleting Autoscaling Scheduled Action: %s", err.Error())
+ }
+
+ return nil
+}
+
+func resourceAwsASGScheduledActionRetrieve(d *schema.ResourceData, meta interface{}) (*autoscaling.ScheduledUpdateGroupAction, error) {
+ autoscalingconn := meta.(*AWSClient).autoscalingconn
+
+ params := &autoscaling.DescribeScheduledActionsInput{
+ AutoScalingGroupName: aws.String(d.Get("autoscaling_group_name").(string)),
+ ScheduledActionNames: []*string{aws.String(d.Id())},
+ }
+
+ log.Printf("[INFO] Describing Autoscaling Scheduled Action: %+v", params)
+ actions, err := autoscalingconn.DescribeScheduledActions(params)
+ if err != nil {
+ return nil, fmt.Errorf("Error retrieving Autoscaling Scheduled Actions: %s", err)
+ }
+
+ if len(actions.ScheduledUpdateGroupActions) != 1 ||
+ *actions.ScheduledUpdateGroupActions[0].ScheduledActionName != d.Id() {
+ return nil, fmt.Errorf("Unable to find Autoscaling Scheduled Action: %#v", actions.ScheduledUpdateGroupActions)
+ }
+
+ return actions.ScheduledUpdateGroupActions[0], nil
+}
+
+func validateASGScheduleTimestamp(v interface{}, k string) (ws []string, errors []error) {
+ value := v.(string)
+ _, err := time.Parse(awsAutoscalingScheduleTimeLayout, value)
+ if err != nil {
+ errors = append(errors, fmt.Errorf(
+ "%q cannot be parsed as iso8601 Timestamp Format", value))
+ }
+
+ return
+}

builtin/providers/aws/resource_aws_autoscaling_schedule_test.go

@@ -0,0 +1,117 @@
+package aws
+
+import (
+ "fmt"
+ "testing"
+
+ "github.com/aws/aws-sdk-go/aws"
+ "github.com/aws/aws-sdk-go/service/autoscaling"
+ "github.com/hashicorp/terraform/helper/resource"
+ "github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAWSAutoscalingSchedule_basic(t *testing.T) {
+ var schedule autoscaling.ScheduledUpdateGroupAction
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testAccCheckAWSAutoscalingScheduleDestroy,
+ Steps: []resource.TestStep{
+ resource.TestStep{
+ Config: testAccAWSAutoscalingScheduleConfig,
+ Check: resource.ComposeTestCheckFunc(
+ testAccCheckScalingScheduleExists("aws_autoscaling_schedule.foobar", &schedule),
+ ),
+ },
+ },
+ })
+}
+
+func testAccCheckScalingScheduleExists(n string, policy *autoscaling.ScheduledUpdateGroupAction) resource.TestCheckFunc {
+ return func(s *terraform.State) error {
+ rs, ok := s.RootModule().Resources[n]
+ if !ok {
+ return fmt.Errorf("Not found: %s", n)
+ }
+
+ autoScalingGroup, _ := rs.Primary.Attributes["autoscaling_group_name"]
+ conn := testAccProvider.Meta().(*AWSClient).autoscalingconn
+ params := &autoscaling.DescribeScheduledActionsInput{
+ AutoScalingGroupName: aws.String(autoScalingGroup),
+ ScheduledActionNames: []*string{aws.String(rs.Primary.ID)},
+ }
+
+ resp, err := conn.DescribeScheduledActions(params)
+ if err != nil {
+ return err
+ }
+ if len(resp.ScheduledUpdateGroupActions) == 0 {
+ return fmt.Errorf("Scaling Schedule not found")
+ }
+
+ return nil
+ }
+}
+
+func testAccCheckAWSAutoscalingScheduleDestroy(s *terraform.State) error {
+ conn := testAccProvider.Meta().(*AWSClient).autoscalingconn
+
+ for _, rs := range s.RootModule().Resources {
+ if rs.Type != "aws_autoscaling_schedule" {
+ continue
+ }
+
+ autoScalingGroup, _ := rs.Primary.Attributes["autoscaling_group_name"]
+ params := &autoscaling.DescribeScheduledActionsInput{
+ AutoScalingGroupName: aws.String(autoScalingGroup),
+ ScheduledActionNames: []*string{aws.String(rs.Primary.ID)},
+ }
+
+ resp, err := conn.DescribeScheduledActions(params)
+
+ if err == nil {
+ if len(resp.ScheduledUpdateGroupActions) != 0 &&
+ *resp.ScheduledUpdateGroupActions[0].ScheduledActionName == rs.Primary.ID {
+ return fmt.Errorf("Scaling Schedule Still Exists: %s", rs.Primary.ID)
+ }
+ }
+ }
+
+ return nil
+}
+
+var testAccAWSAutoscalingScheduleConfig = fmt.Sprintf(`
+resource "aws_launch_configuration" "foobar" {
+ name = "terraform-test-foobar5"
+ image_id = "ami-21f78e11"
+ instance_type = "t1.micro"
+}
+
+resource "aws_autoscaling_group" "foobar" {
+ availability_zones = ["us-west-2a"]
+ name = "terraform-test-foobar5"
+ max_size = 1
+ min_size = 1
+ health_check_grace_period = 300
+ health_check_type = "ELB"
+ force_delete = true
+ termination_policies = ["OldestInstance"]
+ launch_configuration = "${aws_launch_configuration.foobar.name}"
+ tag {
+ key = "Foo"
+ value = "foo-bar"
+ propagate_at_launch = true
+ }
+}
+
+resource "aws_autoscaling_schedule" "foobar" {
+ scheduled_action_name = "foobar"
+ min_size = 0
+ max_size = 1
+ desired_capacity = 0
+ start_time = "2016-12-11T18:00:00Z"
+ end_time = "2016-12-12T06:00:00Z"
+ autoscaling_group_name = "${aws_autoscaling_group.foobar.name}"
+}
+`)