add argument to instance about eip (#85)

Author: shawnmssu

CHANGELOG.md

@@ -1,4 +1,9 @@
 ## 1.24.0 (Unreleased)
+
+ENHANCEMENTS:
+
+* resource/ucloud_instance:  add `network_interface` to the argument in order to create and associate `eip` with the instance.[GH-85]
+
 ## 1.23.0 (2020-09-07)
 
 ENHANCEMENTS:

go.mod

@@ -4,6 +4,6 @@ go 1.14
 
 require (
 	github.com/hashicorp/terraform-plugin-sdk v1.4.0
-	github.com/ucloud/ucloud-sdk-go v0.16.2
+	github.com/ucloud/ucloud-sdk-go v0.17.5
 	golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c // indirect
 )

go.sum

@@ -184,8 +184,8 @@ github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/ucloud/ucloud-sdk-go v0.16.2 h1:gNzMa1UYERoQe1FX4sdP7jgkqkouUaXuGTJZxzZVsjM=
-github.com/ucloud/ucloud-sdk-go v0.16.2/go.mod h1:dyLmFHmUfgb4RZKYQP9IArlvQ2pxzFthfhwxRzOEPIw=
+github.com/ucloud/ucloud-sdk-go v0.17.5 h1:8GOmDmg/FnWoZRBV2WNVwF/DyJO6l1dQGghLUZ4dnGQ=
+github.com/ucloud/ucloud-sdk-go v0.17.5/go.mod h1:dyLmFHmUfgb4RZKYQP9IArlvQ2pxzFthfhwxRzOEPIw=
 github.com/ulikunitz/xz v0.5.5 h1:pFrO0lVpTBXLpYw+pnLj6TbvHuyjXMfjGeCwSqCVwok=
 github.com/ulikunitz/xz v0.5.5/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
 github.com/vmihailenco/msgpack v3.3.3+incompatible h1:wapg9xDUZDzGCNFlwc5SqI1rvcciqcxEHac4CYj89xI=

ucloud/config.go

@@ -62,7 +62,7 @@ func (c *Config) Client() (*UCloudClient, error) {
 	// enable auto retry with http/connection error
 	cfg.MaxRetries = c.MaxRetries
 	cfg.LogLevel = log.PanicLevel
-	cfg.UserAgent = "Terraform-UCloud/1.23.0"
+	cfg.UserAgent = "Terraform-UCloud/1.24.0"
 	cfg.BaseUrl = c.BaseURL
 
 	cred := auth.NewCredential()

ucloud/data_source_ucloud_instances.go

@@ -287,13 +287,12 @@ func dataSourceUCloudInstancesSave(d *schema.ResourceData, instances []uhost.UHo
 		}
 		memory := instance.Memory
 		cpu := instance.CPU
-		data = append(data, map[string]interface{}{
+		dataMap := map[string]interface{}{
 			"availability_zone": instance.Zone,
 			"id":                instance.UHostId,
 			"name":              instance.Name,
 			"cpu":               cpu,
 			"memory":            memory / 1024,
-			"instance_type":     instanceTypeSetFunc(upperCvt.convert(instance.MachineType), cpu, memory/1024),
 			"create_time":       timestampToString(instance.CreateTime),
 			"expire_time":       timestampToString(instance.ExpireTime),
 			"auto_renew":        boolCamelCvt.unconvert(instance.AutoRenew),
@@ -306,7 +305,13 @@ func dataSourceUCloudInstancesSave(d *schema.ResourceData, instances []uhost.UHo
 			"private_ip":        privateIp,
 			"vpc_id":            vpcId,
 			"subnet_id":         subnetId,
-		})
+		}
+
+		if cpu != 0 {
+			dataMap["instance_type"] = instanceTypeSetFunc(upperCvt.convert(instance.MachineType), cpu, memory/1024)
+		}
+
+		data = append(data, dataMap)
 	}
 
 	d.SetId(hashStringArray(ids))

ucloud/resource_ucloud_instance.go

@@ -42,7 +42,9 @@ func resourceUCloudInstance() *schema.Resource {
 			diffValidateChargeTypeWithDuration,
 			diffValidateIsolationGroup,
 			diffValidateDataDisks,
+			diffValidateNetworkInterface,
 			diffValidateCPUPlatform,
+			diffValidateBootDiskTypeWithDataDisks,
 		),
 
 		Schema: map[string]*schema.Schema{
@@ -178,6 +180,49 @@ func resourceUCloudInstance() *schema.Resource {
 				},
 			},
 
+			"network_interface": {
+				Type:     schema.TypeList,
+				Optional: true,
+				MinItems: 1,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"eip_bandwidth": {
+							Type:         schema.TypeInt,
+							Required:     true,
+							ForceNew:     true,
+							ValidateFunc: validation.IntBetween(1, 800),
+						},
+
+						"eip_internet_type": {
+							Type:     schema.TypeString,
+							Required: true,
+							ForceNew: true,
+							ValidateFunc: validation.StringInSlice([]string{
+								"bgp",
+								"international",
+							}, false),
+						},
+
+						"eip_charge_mode": {
+							Type:     schema.TypeString,
+							Required: true,
+							ForceNew: true,
+							ValidateFunc: validation.StringInSlice([]string{
+								"traffic",
+								"bandwidth",
+							}, false),
+						},
+					},
+				},
+			},
+
+			"delete_eips_with_instance": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				ForceNew: true,
+			},
+
 			"delete_disks_with_instance": {
 				Type:     schema.TypeBool,
 				Optional: true,
@@ -439,15 +484,34 @@ func resourceUCloudInstanceCreate(d *schema.ResourceData, meta interface{}) erro
 
 	if v, ok := d.GetOk("data_disks"); ok {
 		for _, item := range v.([]interface{}) {
+			disk, ok := item.(map[string]interface{})
+			if !ok {
+				return fmt.Errorf("error on parse data_disks when creating instance")
+			}
 			dataDisk := uhost.UHostDisk{}
 			dataDisk.IsBoot = ucloud.String("false")
-			disk := item.(map[string]interface{})
 			dataDisk.Size = ucloud.Int(disk["size"].(int))
 			dataDisk.Type = ucloud.String(upperCvt.unconvert(disk["type"].(string)))
 			req.Disks = append(req.Disks, dataDisk)
 		}
 	}
 
+	if v, ok := d.GetOk("network_interface"); ok {
+		for _, item := range v.([]interface{}) {
+			netIp, ok := item.(map[string]interface{})
+			if !ok {
+				return fmt.Errorf("error on parse network_interface when creating instance")
+			}
+			eip := uhost.CreateUHostInstanceParamNetworkInterface{}
+			eip.EIP = &uhost.CreateUHostInstanceParamNetworkInterfaceEIP{
+				Bandwidth:    ucloud.Int(netIp["eip_bandwidth"].(int)),
+				OperatorName: ucloud.String(upperCamelCvt.unconvert(netIp["eip_internet_type"].(string))),
+				PayMode:      ucloud.String(upperCamelCvt.unconvert(netIp["eip_charge_mode"].(string))),
+			}
+			req.NetworkInterface = append(req.NetworkInterface, eip)
+		}
+	}
+
 	// if tag is empty string, use default tag
 	if v, ok := d.GetOk("tag"); ok {
 		req.Tag = ucloud.String(v.(string))
@@ -475,7 +539,7 @@ func resourceUCloudInstanceCreate(d *schema.ResourceData, meta interface{}) erro
 		if isStringIn("CloudInit", imageResp.Features) {
 			req.UserData = ucloud.String(base64.StdEncoding.EncodeToString([]byte(v.(string))))
 		} else {
-			return fmt.Errorf("error on creating instance, the image %s must have %q feature, got %#v", "CloudInit", imageId, imageResp.Features)
+			return fmt.Errorf("error on creating instance, the image %s must have %q feature, got %#v", imageId, "CloudInit", imageResp.Features)
 		}
 	}
 	req.MachineType = ucloud.String(strings.ToUpper(t.HostType))
@@ -864,6 +928,9 @@ func resourceUCloudInstanceRead(d *schema.ResourceData, meta interface{}) error
 	memory := instance.Memory
 	cpu := instance.CPU
 
+	if cpu != 0 {
+		d.Set("instance_type", instanceTypeSetFunc(upperCvt.convert(instance.MachineType), cpu, memory/1024))
+	}
 	d.Set("root_password", d.Get("root_password"))
 	d.Set("isolation_group", instance.IsolationGroup)
 	d.Set("name", instance.Name)
@@ -875,7 +942,6 @@ func resourceUCloudInstanceRead(d *schema.ResourceData, meta interface{}) error
 	d.Set("expire_time", timestampToString(instance.ExpireTime))
 	d.Set("auto_renew", boolCamelCvt.unconvert(instance.AutoRenew))
 	d.Set("remark", instance.Remark)
-	d.Set("instance_type", instanceTypeSetFunc(upperCvt.convert(instance.MachineType), cpu, memory/1024))
 	d.Set("cpu_platform", instance.CpuPlatform)
 
 	//in order to be compatible with returns null
@@ -958,6 +1024,9 @@ func resourceUCloudInstanceDelete(d *schema.ResourceData, meta interface{}) erro
 	if v, ok := d.GetOkExists("delete_disks_with_instance"); ok {
 		deleReq.ReleaseUDisk = ucloud.Bool(v.(bool))
 	}
+	if v, ok := d.GetOkExists("delete_eips_with_instance"); ok {
+		deleReq.ReleaseEIP = ucloud.Bool(v.(bool))
+	}
 
 	return resource.Retry(15*time.Minute, func() *resource.RetryError {
 		instance, err := client.describeInstanceById(d.Id())
@@ -1133,6 +1202,24 @@ func diffValidateBootDiskTypeWithDataDiskType(diff *schema.ResourceDiff, meta in
 	return nil
 }
 
+func diffValidateBootDiskTypeWithDataDisks(diff *schema.ResourceDiff, meta interface{}) error {
+	var bootDiskType string
+
+	if v, ok := diff.GetOk("boot_disk_type"); ok {
+		bootDiskType = v.(string)
+	} else {
+		bootDiskType = "local_normal"
+	}
+
+	if _, ok := diff.GetOk("data_disks"); ok {
+		if isStringIn(bootDiskType, []string{"local_normal", "local_ssd"}) {
+			return fmt.Errorf("the %q cannot be local data disk, when set %q, got %q", "boot_disk_type", "data_disks", bootDiskType)
+		}
+	}
+
+	return nil
+}
+
 func diffValidateChargeTypeWithDuration(diff *schema.ResourceDiff, meta interface{}) error {
 	if v, ok := diff.GetOkExists("duration"); ok && v.(int) == 0 {
 		chargeType := diff.Get("charge_type").(string)
@@ -1175,8 +1262,21 @@ func diffValidateDataDisks(diff *schema.ResourceDiff, meta interface{}) error {
 	return nil
 }
 
+func diffValidateNetworkInterface(diff *schema.ResourceDiff, meta interface{}) error {
+	if _, ok := diff.GetOk("network_interface"); ok {
+		if _, ok1 := diff.GetOkExists("delete_eips_with_instance"); !ok1 {
+			return fmt.Errorf("the argument %q is required when set %q", "delete_eips_with_instance", "network_interface")
+		}
+	}
+
+	return nil
+}
+
 func diffValidateCPUPlatform(diff *schema.ResourceDiff, meta interface{}) error {
-	t, _ := parseInstanceType(diff.Get("instance_type").(string))
+	t, err := parseInstanceType(diff.Get("instance_type").(string))
+	if err != nil {
+		return err
+	}
 	if v, ok := diff.GetOk("min_cpu_platform"); ok {
 		supportedCPUForOS := []string{"Intel/Auto", "Intel/CascadelakeR"}
 		if t.HostType == "os" && !isStringIn(v.(string), supportedCPUForOS) {

ucloud/resource_ucloud_instance_test.go

@@ -54,6 +54,32 @@ func TestAccUCloudInstance_basic(t *testing.T) {
 	})
 }
 
+func TestAccUCloudInstance_EIP(t *testing.T) {
+	var instance uhost.UHostInstanceSet
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+
+		IDRefreshName: "ucloud_instance.foo",
+		Providers:     testAccProviders,
+		CheckDestroy:  testAccCheckInstanceDestroy,
+
+		Steps: []resource.TestStep{
+			{
+				Config: testAccInstanceConfigEIP,
+
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckInstanceExists("ucloud_instance.foo", &instance),
+					resource.TestCheckResourceAttr("ucloud_instance.foo", "name", "tf-acc-instance-eip"),
+					resource.TestCheckResourceAttr("ucloud_instance.foo", "tag", "tf-acc"),
+				),
+			},
+		},
+	})
+}
+
 func TestAccUCloudInstance_outstanding(t *testing.T) {
 	var instance uhost.UHostInstanceSet
 
@@ -670,3 +696,34 @@ resource "ucloud_instance" "foo" {
   security_group = "${data.ucloud_security_groups.default.security_groups.0.id}"
 }
 `
+
+const testAccInstanceConfigEIP = `
+data "ucloud_zones" "default" {
+}
+
+data "ucloud_security_groups" "default" {
+  type = "recommend_web"
+}
+
+data "ucloud_images" "default" {
+  availability_zone = "${data.ucloud_zones.default.zones.0.id}"
+  name_regex        = "^CentOS 7.6 64"
+  image_type        = "base"
+}
+
+resource "ucloud_instance" "foo" {
+  name              = "tf-acc-instance-eip"
+  tag               = "tf-acc"
+  availability_zone = "${data.ucloud_zones.default.zones.0.id}"
+  image_id          = "${data.ucloud_images.default.images.0.id}"
+  instance_type     = "n-basic-1"
+  root_password     = "wA1234567"
+  security_group = "${data.ucloud_security_groups.default.security_groups.0.id}"
+  network_interface {
+	  eip_bandwidth     = 2
+	  eip_charge_mode   = "bandwidth"
+	  eip_internet_type = "bgp"
+  }
+  delete_eips_with_instance = true
+}
+`