Merge pull request aliyun#68 from xiaozhu36/database

add new resource db_database and db_backup_policy
dimitar-kostadinov · Jan 4, 2018 · 91e47a6 · 91e47a6
2 parents b557f03 + c1e9b30
commit 91e47a6
Show file tree

Hide file tree

Showing 16 changed files with 771 additions and 4 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,8 @@
 
 IMPROVEMENTS:
 
+- *New Resource*: _alicloud_db_database_ ([#68](https://github.com/terraform-providers/terraform-provider-alicloud/pull/68))
+- *New Resource*: _alicloud_db_backup_policy_ ([#68](https://github.com/terraform-providers/terraform-provider-alicloud/pull/68))
 - *New Resource*: _alicloud_db_connection_ ([#67](https://github.com/terraform-providers/terraform-provider-alicloud/pull/67))
 - *New Resource*: _alicloud_db_account_ ([#66](https://github.com/terraform-providers/terraform-provider-alicloud/pull/66))
 - *New Resource*: _alicloud_db_account_privilege_ ([#66](https://github.com/terraform-providers/terraform-provider-alicloud/pull/66))

diff --git a/alicloud/import_alicloud_db_backup_policy_test.go b/alicloud/import_alicloud_db_backup_policy_test.go
@@ -0,0 +1,29 @@
+package alicloud
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccAlicloudDBBackupPolicy_import(t *testing.T) {
+	resourceName := "alicloud_db_backup_policy.policy"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckInstanceDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccDBBackupPolicy_basic,
+			},
+
+			resource.TestStep{
+				ResourceName:            resourceName,
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"log_retention_period"},
+			},
+		},
+	})
+}
diff --git a/alicloud/import_alicloud_db_database_test.go b/alicloud/import_alicloud_db_database_test.go
@@ -0,0 +1,28 @@
+package alicloud
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccAlicloudDBDatabase_import(t *testing.T) {
+	resourceName := "alicloud_db_database.db"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckInstanceDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccDBDatabase_basic,
+			},
+
+			resource.TestStep{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
diff --git a/alicloud/provider.go b/alicloud/provider.go
@@ -66,8 +66,10 @@ func Provider() terraform.ResourceProvider {
 			"alicloud_disk_attachment":           resourceAliyunDiskAttachment(),
 			"alicloud_security_group":            resourceAliyunSecurityGroup(),
 			"alicloud_security_group_rule":       resourceAliyunSecurityGroupRule(),
+			"alicloud_db_database":               resourceAlicloudDBDatabase(),
 			"alicloud_db_account":                resourceAlicloudDBAccount(),
 			"alicloud_db_account_privilege":      resourceAlicloudDBAccountPrivilege(),
+			"alicloud_db_backup_policy":          resourceAlicloudDBBackupPolicy(),
 			"alicloud_db_connection":             resourceAlicloudDBConnection(),
 			"alicloud_db_instance":               resourceAlicloudDBInstance(),
 			"alicloud_ess_scaling_group":         resourceAlicloudEssScalingGroup(),

diff --git a/alicloud/resource_alicloud_db_backup_policy.go b/alicloud/resource_alicloud_db_backup_policy.go
@@ -0,0 +1,186 @@
+package alicloud
+
+import (
+	"fmt"
+	"github.com/denverdino/aliyungo/rds"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/helper/schema"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func resourceAlicloudDBBackupPolicy() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAlicloudDBBackupPolicyCreate,
+		Read:   resourceAlicloudDBBackupPolicyRead,
+		Update: resourceAlicloudDBBackupPolicyUpdate,
+		Delete: resourceAlicloudDBBackupPolicyDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"instance_id": &schema.Schema{
+				Type:     schema.TypeString,
+				ForceNew: true,
+				Required: true,
+			},
+
+			"backup_period": &schema.Schema{
+				Type: schema.TypeSet,
+				Elem: &schema.Schema{Type: schema.TypeString},
+				// terraform does not support ValidateFunc of TypeList attr
+				// ValidateFunc: validateAllowedStringValue([]string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}),
+				Optional: true,
+				Computed: true,
+			},
+
+			"backup_time": &schema.Schema{
+				Type:         schema.TypeString,
+				ValidateFunc: validateAllowedStringValue(rds.BACKUP_TIME),
+				Optional:     true,
+				Default:      "02:00Z-03:00Z",
+			},
+
+			"retention_period": &schema.Schema{
+				Type:         schema.TypeInt,
+				ValidateFunc: validateIntegerInRange(7, 730),
+				Optional:     true,
+				Default:      7,
+			},
+
+			"log_backup": &schema.Schema{
+				Type:     schema.TypeBool,
+				Optional: true,
+				Default:  true,
+			},
+
+			"log_retention_period": &schema.Schema{
+				Type:             schema.TypeInt,
+				ValidateFunc:     validateIntegerInRange(7, 730),
+				Optional:         true,
+				Default:          7,
+				DiffSuppressFunc: logRetentionPeriodDiffSuppressFunc,
+			},
+		},
+	}
+}
+
+func resourceAlicloudDBBackupPolicyCreate(d *schema.ResourceData, meta interface{}) error {
+
+	d.SetId(d.Get("instance_id").(string))
+
+	return resourceAlicloudDBBackupPolicyUpdate(d, meta)
+}
+
+func resourceAlicloudDBBackupPolicyRead(d *schema.ResourceData, meta interface{}) error {
+
+	resp, err := meta.(*AliyunClient).rdsconn.DescribeBackupPolicy(&rds.DescribeBackupPolicyArgs{
+		DBInstanceId: d.Id(),
+	})
+	if err != nil {
+		if NotFoundError(err) || IsExceptedError(err, InvalidDBInstanceNameNotFound) {
+			d.SetId("")
+			return nil
+		}
+		return fmt.Errorf("Error Describe DB backup policy: %#v", err)
+	}
+
+	d.Set("instance_id", d.Id())
+	d.Set("backup_time", resp.PreferredBackupTime)
+	d.Set("backup_period", strings.Split(resp.PreferredBackupPeriod, ","))
+	d.Set("retention_period", resp.BackupRetentionPeriod)
+	d.Set("log_backup", resp.BackupLog == "Enable")
+	d.Set("log_retention_period", resp.LogBackupRetentionPeriod)
+
+	return nil
+}
+
+func resourceAlicloudDBBackupPolicyUpdate(d *schema.ResourceData, meta interface{}) error {
+
+	d.Partial(true)
+
+	update := false
+	args := rds.ModifyBackupPolicyArgs{
+		DBInstanceId: d.Id(),
+	}
+	periodList := expandStringList(d.Get("backup_period").(*schema.Set).List())
+	args.PreferredBackupPeriod = fmt.Sprintf("%s", strings.Join(periodList[:], COMMA_SEPARATED))
+	args.PreferredBackupTime = d.Get("backup_time").(string)
+	args.BackupRetentionPeriod = d.Get("retention_period").(int)
+	args.BackupLog = "Enable"
+	args.LogBackupRetentionPeriod = strconv.Itoa(d.Get("log_retention_period").(int))
+
+	if d.HasChange("backup_period") {
+		update = true
+		d.SetPartial("backup_period")
+	}
+
+	if d.HasChange("backup_time") {
+		update = true
+		d.SetPartial("backup_time")
+	}
+
+	if d.HasChange("retention_period") {
+		update = true
+		d.SetPartial("retention_period")
+	}
+
+	if d.HasChange("log_backup") {
+		if !d.Get("log_backup").(bool) {
+			args.BackupLog = "Disabled"
+		}
+		update = true
+		d.SetPartial("retention_period")
+	}
+
+	if d.HasChange("log_retention_period") {
+		if d.Get("log_retention_period").(int) > args.BackupRetentionPeriod {
+			args.LogBackupRetentionPeriod = strconv.Itoa(args.BackupRetentionPeriod)
+		}
+		update = true
+		d.SetPartial("log_retention_period")
+	}
+
+	if update {
+		err := resource.Retry(3*time.Minute, func() *resource.RetryError {
+			ag := args
+			if _, err := meta.(*AliyunClient).rdsconn.ModifyBackupPolicy(&ag); err != nil {
+				if IsExceptedError(err, OperationDeniedDBInstanceStatus) {
+					return resource.RetryableError(fmt.Errorf("ModifyBackupPolicy got an error: %#v.", err))
+				}
+				return resource.NonRetryableError(fmt.Errorf("ModifyBackupPolicy got an error: %#v.", err))
+			}
+
+			return nil
+		})
+
+		if err != nil {
+			return err
+		}
+	}
+
+	d.Partial(false)
+	return resourceAlicloudDBBackupPolicyRead(d, meta)
+}
+
+func resourceAlicloudDBBackupPolicyDelete(d *schema.ResourceData, meta interface{}) error {
+
+	args := &rds.ModifyBackupPolicyArgs{
+		DBInstanceId: d.Id(),
+	}
+	args.PreferredBackupTime = "02:00Z-03:00Z"
+	args.PreferredBackupPeriod = "Tuesday,Thursday,Saturday"
+	args.BackupRetentionPeriod = 7
+	args.BackupLog = "Enable"
+	args.LogBackupRetentionPeriod = "7"
+
+	return resource.Retry(5*time.Minute, func() *resource.RetryError {
+		if _, err := meta.(*AliyunClient).rdsconn.ModifyBackupPolicy(args); err != nil {
+			return resource.RetryableError(fmt.Errorf("ModifyBackupPolicy got an error: %#v", err))
+		}
+
+		return nil
+	})
+}
diff --git a/alicloud/resource_alicloud_db_backup_policy_test.go b/alicloud/resource_alicloud_db_backup_policy_test.go
@@ -0,0 +1,119 @@
+package alicloud
+
+import (
+	"fmt"
+	"github.com/denverdino/aliyungo/rds"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+	"testing"
+)
+
+func TestAccAlicloudDBBackupPolicy_basic(t *testing.T) {
+	var policy rds.DescribeBackupPolicyResponse
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+
+		// module name
+		IDRefreshName: "alicloud_db_backup_policy.policy",
+
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckDBBackupPolicyDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccDBBackupPolicy_basic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckDBBackupPolicyExists(
+						"alicloud_db_backup_policy.policy", &policy),
+					resource.TestCheckResourceAttr("alicloud_db_backup_policy.policy", "backup_time", "10:00Z-11:00Z"),
+				),
+			},
+		},
+	})
+
+}
+
+func testAccCheckDBBackupPolicyExists(n string, d *rds.DescribeBackupPolicyResponse) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("Not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No DB account ID is set")
+		}
+
+		client := testAccProvider.Meta().(*AliyunClient)
+
+		resp, err := client.rdsconn.DescribeBackupPolicy(&rds.DescribeBackupPolicyArgs{
+			DBInstanceId: rs.Primary.ID,
+		})
+		if err != nil {
+
+			return fmt.Errorf("Error Describe DB backup policy: %#v", err)
+		}
+
+		if resp == nil {
+			return fmt.Errorf("Backup policy is not found in the instance %s.", rs.Primary.ID)
+		}
+
+		*d = *resp
+		return nil
+	}
+}
+
+func testAccCheckDBBackupPolicyDestroy(s *terraform.State) error {
+	client := testAccProvider.Meta().(*AliyunClient)
+
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "alicloud_db_account" {
+			continue
+		}
+
+		_, err := client.rdsconn.DescribeBackupPolicy(&rds.DescribeBackupPolicyArgs{
+			DBInstanceId: rs.Primary.ID,
+		})
+		if err != nil {
+			if NotFoundError(err) || IsExceptedError(err, InvalidDBInstanceNameNotFound) {
+				continue
+			}
+			return fmt.Errorf("Error Describe DB backup policy: %#v", err)
+		}
+	}
+
+	return nil
+}
+
+const testAccDBBackupPolicy_basic = `
+data "alicloud_zones" "default" {
+	"available_resource_creation"= "VSwitch"
+}
+
+resource "alicloud_vpc" "foo" {
+	name = "tf_test_foo"
+	cidr_block = "172.16.0.0/12"
+}
+
+resource "alicloud_vswitch" "foo" {
+ 	vpc_id = "${alicloud_vpc.foo.id}"
+ 	cidr_block = "172.16.0.0/21"
+ 	availability_zone = "${data.alicloud_zones.default.zones.0.id}"
+}
+
+resource "alicloud_db_instance" "instance" {
+	engine = "MySQL"
+	engine_version = "5.6"
+	instance_type = "rds.mysql.t1.small"
+	instance_storage = "10"
+  	vswitch_id = "${alicloud_vswitch.foo.id}"
+}
+
+resource "alicloud_db_backup_policy" "policy" {
+  	instance_id = "${alicloud_db_instance.instance.id}"
+  	backup_period = ["Tuesday", "Wednesday"]
+  	backup_time = "10:00Z-11:00Z"
+}
+`