new data source db_instances

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 IMPROVEMENTS:
 
+- *New Data Source*: _alicloud_db_instances_ ([#450](https://github.com/alibaba/terraform-provider/pull/450)))
 - Improve alicloud.tf ([#449](https://github.com/alibaba/terraform-provider/pull/449)))
 - Support to set auto renew for ECS instance ([#448](https://github.com/alibaba/terraform-provider/pull/448)))
 - Add missing code for describing RDS zones ([#447](https://github.com/alibaba/terraform-provider/pull/447)))

alicloud/data_source_alicloud_db_instances.go

@@ -0,0 +1,262 @@
+package alicloud
+
+import (
+	"regexp"
+
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/services/rds"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func dataSourceAlicloudDBInstances() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceAlicloudDBInstancesRead,
+
+		Schema: map[string]*schema.Schema{
+			"name_regex": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ValidateFunc: validateNameRegex,
+			},
+			"engine": {
+				Type:     schema.TypeString,
+				Optional: true,
+				ValidateFunc: validateAllowedStringValue([]string{
+					string(MySQL),
+					string(SQLServer),
+					string(PPAS),
+					string(PostgreSQL),
+				}),
+			},
+			"status": {
+				Type:     schema.TypeString,
+				Optional: true,
+				// please follow the link below to see more details on available statusesplease follow the link below to see more details on available statuses
+				// https://help.aliyun.com/document_detail/26315.html
+			},
+			"db_type": {
+				Type:     schema.TypeString,
+				Optional: true,
+				ValidateFunc: validateAllowedStringValue([]string{
+					"Primary",
+					"Readonly",
+					"Guard",
+					"Temp",
+				}),
+			},
+			"vpc_id": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"vswitch_id": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"connection_mode": {
+				Type:     schema.TypeString,
+				Optional: true,
+				ValidateFunc: validateAllowedStringValue([]string{
+					"Standard",
+					"Safe",
+				}),
+			},
+			"tags": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ValidateFunc: validateJsonString,
+			},
+			"output_file": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+
+			// Computed values
+			"instances": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"charge_type": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"db_type": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"region_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"create_time": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"expire_time": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"status": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"engine": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"engine_version": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"net_type": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"connection_mode": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"instance_type": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"availability_zone": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"master_instance_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"guard_instance_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"temp_instance_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"readonly_instance_ids": {
+							Type:     schema.TypeList,
+							Elem:     &schema.Schema{Type: schema.TypeString},
+							Computed: true,
+						},
+						"vpc_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"vswitch_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func dataSourceAlicloudDBInstancesRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AliyunClient).rdsconn
+
+	args := rds.CreateDescribeDBInstancesRequest()
+
+	args.RegionId = getRegionId(d, meta)
+	args.Engine = d.Get("engine").(string)
+	args.DBInstanceStatus = d.Get("status").(string)
+	args.DBInstanceType = d.Get("db_type").(string)
+	args.VpcId = d.Get("vpc_id").(string)
+	args.VSwitchId = d.Get("vswitch_id").(string)
+	args.ConnectionMode = d.Get("connection_mode").(string)
+	args.Tags = d.Get("tags").(string)
+	args.PageSize = requests.NewInteger(PageSizeLarge)
+
+	var dbi []rds.DBInstance
+
+	var nameRegex *regexp.Regexp
+	if v, ok := d.GetOk("name_regex"); ok {
+		if r, err := regexp.Compile(v.(string)); err == nil {
+			nameRegex = r
+		}
+	}
+
+	for {
+		resp, err := conn.DescribeDBInstances(args)
+		if err != nil {
+			return err
+		}
+
+		if resp == nil || len(resp.Items.DBInstance) < 1 {
+			break
+		}
+
+		for _, item := range resp.Items.DBInstance {
+			if nameRegex != nil {
+				if !nameRegex.MatchString(item.DBInstanceDescription) {
+					continue
+				}
+			}
+			dbi = append(dbi, item)
+		}
+
+		if len(resp.Items.DBInstance) < PageSizeLarge {
+			break
+		}
+
+		args.PageNumber = args.PageNumber + requests.NewInteger(1)
+	}
+
+	return rdsInstancesDescription(d, dbi)
+}
+
+func rdsInstancesDescription(d *schema.ResourceData, dbi []rds.DBInstance) error {
+	var ids []string
+	var s []map[string]interface{}
+
+	for _, item := range dbi {
+		mapping := map[string]interface{}{
+			"id":                    item.DBInstanceId,
+			"name":                  item.DBInstanceDescription,
+			"charge_type":           item.PayType,
+			"db_type":               item.DBInstanceType,
+			"region_id":             item.RegionId,
+			"create_time":           item.CreateTime,
+			"expire_time":           item.ExpireTime,
+			"status":                item.DBInstanceStatus,
+			"engine":                item.Engine,
+			"engine_version":        item.EngineVersion,
+			"net_type":              item.DBInstanceNetType,
+			"connection_mode":       item.ConnectionMode,
+			"instance_type":         item.DBInstanceClass,
+			"availability_zone":     item.ZoneId,
+			"master_instance_id":    item.MasterInstanceId,
+			"guard_instance_id":     item.GuardDBInstanceId,
+			"temp_instance_id":      item.TempDBInstanceId,
+			"readonly_instance_ids": item.ReadOnlyDBInstanceIds.ReadOnlyDBInstanceId,
+			"vpc_id":                item.VpcId,
+			"vswitch_id":            item.VSwitchId,
+		}
+
+		ids = append(ids, item.DBInstanceId)
+		s = append(s, mapping)
+	}
+
+	d.SetId(dataResourceIdHash(ids))
+	if err := d.Set("instances", s); err != nil {
+		return err
+	}
+
+	// create a json file in current directory and write data source to it
+	if output, ok := d.GetOk("output_file"); ok && output.(string) != "" {
+		writeToFile(output.(string), s)
+	}
+	return nil
+}

alicloud/data_source_alicloud_db_instances_test.go

@@ -0,0 +1,45 @@
+package alicloud
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccAlicloudDBInstancesDataSource(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckAlicloudDBInstancesDataSourceConfig,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAlicloudDataSourceID("data.alicloud_db_instances.dbs"),
+					resource.TestCheckResourceAttr("data.alicloud_db_instances.dbs", "instances.#", "1"),
+					resource.TestCheckResourceAttr("data.alicloud_db_instances.dbs", "instances.0.instance_type", "rds.mysql.t1.small"),
+					resource.TestCheckResourceAttr("data.alicloud_db_instances.dbs", "instances.0.engine", string(MySQL)),
+					resource.TestCheckResourceAttr("data.alicloud_db_instances.dbs", "instances.0.engine_version", "5.6"),
+					resource.TestCheckResourceAttr("data.alicloud_db_instances.dbs", "instances.0.name", "data-server"),
+					resource.TestCheckResourceAttr("data.alicloud_db_instances.dbs", "instances.0.charge_type", string(Postpaid)),
+				),
+			},
+		},
+	})
+}
+
+const testAccCheckAlicloudDBInstancesDataSourceConfig = `
+data "alicloud_db_instances" "dbs" {
+  name_regex = "${alicloud_db_instance.db.instance_name}"
+}
+
+resource "alicloud_db_instance" "db" {
+  engine               = "MySQL"
+  engine_version       = "5.6"
+  instance_type        = "rds.mysql.t1.small"
+  instance_storage     = "10"
+  instance_name        = "data-server"
+  instance_charge_type = "Postpaid"
+}
+`

alicloud/data_source_alicloud_dns_records.go

@@ -49,7 +49,7 @@ func dataSourceAlicloudDnsRecords() *schema.Resource {
 				ValidateFunc: func(v interface{}, k string) (ws []string, errors []error) {
 					value := v.(string)
 					if strings.ToLower(value) != "enable" && strings.ToLower(value) != "disable" {
-						errors = append(errors, fmt.Errorf("%q must be 'enable' or 'distable', regardless of uppercase and lowercase.", k))
+						errors = append(errors, fmt.Errorf("%q must be 'enable' or 'disable', regardless of uppercase and lowercase.", k))
 					}
 					return
 				},

alicloud/provider.go

@@ -71,6 +71,7 @@ func Provider() terraform.ResourceProvider {
 			"alicloud_ram_policies":         dataSourceAlicloudRamPolicies(),
 			"alicloud_security_groups":      dataSourceAlicloudSecurityGroups(),
 			"alicloud_security_group_rules": dataSourceAlicloudSecurityGroupRules(),
+			"alicloud_db_instances":         dataSourceAlicloudDBInstances(),
 		},
 		ResourcesMap: map[string]*schema.Resource{
 			"alicloud_instance":                  resourceAliyunInstance(),

alicloud/resource_alicloud_ram_alias.go

@@ -0,0 +1,61 @@
+package alicloud
+
+import (
+	"fmt"
+
+	"github.com/denverdino/aliyungo/ram"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func resourceAlicloudRamAlias() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAlicloudRamAliasCreate,
+		Read:   resourceAlicloudRamAliasRead,
+		Delete: resourceAlicloudRamAliasDelete,
+
+		Schema: map[string]*schema.Schema{
+			"account_alias": &schema.Schema{
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validateRamAlias,
+			},
+		},
+	}
+}
+
+func resourceAlicloudRamAliasCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AliyunClient).ramconn
+
+	args := ram.AccountAliasRequest{
+		AccountAlias: d.Get("account_alias").(string),
+	}
+
+	if _, err := conn.SetAccountAlias(args); err != nil {
+		return fmt.Errorf("SetAccountAlias got an error: %#v", err)
+	}
+
+	d.SetId(args.AccountAlias)
+	return resourceAlicloudRamAliasRead(d, meta)
+}
+
+func resourceAlicloudRamAliasRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AliyunClient).ramconn
+
+	response, err := conn.GetAccountAlias()
+	if err != nil {
+		return fmt.Errorf("GetAccountAlias got an error: %#v", err)
+	}
+
+	d.Set("account_alias", response.AccountAlias)
+	return nil
+}
+
+func resourceAlicloudRamAliasDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AliyunClient).ramconn
+
+	if _, err := conn.ClearAccountAlias(); err != nil {
+		return fmt.Errorf("ClearAccountAlias got an error: %#v", err)
+	}
+	return nil
+}