func buildAlibabacloudStackInstanceArgs()

in alibabacloudstack/resource_apsarastack_ecs_instance.go [745:909]
143 lines of code
39 McCabe index (conditional complexity)

func buildAlibabacloudStackInstanceArgs(d *schema.ResourceData, meta interface{}) (*ecs.RunInstancesRequest, error) {
	client := meta.(*connectivity.AlibabacloudStackClient)

	request := ecs.CreateRunInstancesRequest()
	client.InitRpcRequest(*request.RpcRequest)

	if v := d.Get("enable_ipv6").(bool); v {
		request.QueryParams["Ipv6CidrBlock"] = d.Get("ipv6_cidr_block").(string)
		if d.Get("ipv6_address_count").(int) <= 0 {
			return nil, errmsgs.WrapError(errmsgs.Error("if enable_ipv6 = true, ipv6_address_count must be greater than 0"))
		}
		request.QueryParams["Ipv6AddressCount"] = "0"
	}
	request.InstanceType = d.Get("instance_type").(string)
	request.SystemDiskDiskName = d.Get("system_disk_name").(string)
	imageID := d.Get("image_id").(string)

	request.ImageId = imageID
	if v := d.Get("system_disk_description").(string); v != "" {
		request.SystemDiskDescription = v
	}
	systemDiskCategory := DiskCategory(d.Get("system_disk_category").(string))

	if v, ok := connectivity.GetResourceDataOk(d, "zone_id", "availability_zone"); ok && v.(string) != "" {
		request.ZoneId = v.(string)
	}

	request.SystemDiskCategory = string(systemDiskCategory)
	request.SystemDiskSize = strconv.Itoa(d.Get("system_disk_size").(int))

	if v, ok := d.GetOk("security_groups"); ok {
		sgs := expandStringList(v.(*schema.Set).List())
		request.SecurityGroupId = sgs[0]
	}

	if v := d.Get("instance_name").(string); v != "" {
		request.InstanceName = v
	}

	if v := d.Get("description").(string); v != "" {
		request.Description = v
	}

	if v, ok := d.GetOk("internet_max_bandwidth_in"); ok {
		request.InternetMaxBandwidthIn = requests.NewInteger(v.(int))
	}

	if v := d.Get("host_name").(string); v != "" {
		request.HostName = v
	}

	if v := d.Get("password").(string); v != "" {
		request.Password = v
	}

	if v := d.Get("kms_encrypted_password").(string); v != "" {
		kmsService := KmsService{client}
		decryptResp, err := kmsService.Decrypt(v, d.Get("kms_encryption_context").(map[string]interface{}))
		if err != nil {
			return request, errmsgs.WrapError(err)
		}
		request.Password = decryptResp.Plaintext
	}

	vswitchValue := d.Get("subnet_id").(string)
	if vswitchValue == "" {
		vswitchValue = d.Get("vswitch_id").(string)
	}
	if vswitchValue != "" {
		request.VSwitchId = vswitchValue
		if v, ok := d.GetOk("private_ip"); ok && v.(string) != "" {
			request.PrivateIpAddress = v.(string)
		}
	}

	if v := d.Get("user_data").(string); v != "" {
		_, base64DecodeError := base64.StdEncoding.DecodeString(v)
		if base64DecodeError == nil {
			request.UserData = v
		} else {
			request.UserData = base64.StdEncoding.EncodeToString([]byte(v))
		}
	}

	if v := d.Get("role_name").(string); v != "" {
		request.RamRoleName = v
	}

	if v := d.Get("key_name").(string); v != "" {
		request.KeyPairName = v
	}
	request.InternetMaxBandwidthOut = requests.NewInteger(d.Get("internet_max_bandwidth_out").(int))
	i := d.Get("storage_set_partition_number").(int)
	if v := d.Get("storage_set_id").(string); v != "" {
		request.StorageSetId = v
		if i >= 1 {
			request.StorageSetPartitionNumber = requests.NewInteger(d.Get("storage_set_partition_number").(int))
		} else {
			return nil, fmt.Errorf("can't empty storage_set_partition_number when you set storage_set_id and >=2 ")
		}
	}

	if v, ok := d.GetOk("security_enhancement_strategy"); ok {
		request.SecurityEnhancementStrategy = v.(string)
	}

	v, ok := d.GetOk("tags")
	if ok && len(v.(map[string]interface{})) > 0 {
		tags := make([]ecs.RunInstancesTag, 0)
		for key, value := range v.(map[string]interface{}) {
			tags = append(tags, ecs.RunInstancesTag{
				Key:   key,
				Value: value.(string),
			})
		}
		request.Tag = &tags
	}
	request.ClientToken = buildClientToken(request.GetActionName())

	if v, ok := d.GetOk("data_disks"); ok {
		disks := v.([]interface{})
		var dataDiskRequests []ecs.RunInstancesDataDisk
		for i := range disks {
			disk := disks[i].(map[string]interface{})

			dataDiskRequest := ecs.RunInstancesDataDisk{
				Category:           disk["category"].(string),
				DeleteWithInstance: strconv.FormatBool(disk["delete_with_instance"].(bool)),
				Encrypted:          strconv.FormatBool(disk["encrypted"].(bool)),
			}
			if enc, ok := disk["encrypted"]; ok {
				if enc.(bool) {
					if j, ok := disk["kms_key_id"]; ok {
						dataDiskRequest.KMSKeyId = j.(string)
					}
					if dataDiskRequest.KMSKeyId == "" {
						return nil, errmsgs.WrapError(errors.New("KmsKeyId can not be empty if encrypted is set to \"true\""))
					}
				}
			}
			if kms, ok := disk["kms_key_id"]; ok {
				dataDiskRequest.KMSKeyId = kms.(string)
			}
			if name, ok := disk["name"]; ok {
				dataDiskRequest.DiskName = name.(string)
			}
			if snapshotId, ok := disk["snapshot_id"]; ok {
				dataDiskRequest.SnapshotId = snapshotId.(string)
			}
			if description, ok := disk["description"]; ok {
				dataDiskRequest.Description = description.(string)
			}

			dataDiskRequest.Size = fmt.Sprintf("%d", disk["size"].(int))
			dataDiskRequest.Category = disk["category"].(string)
			if dataDiskRequest.Category == string(DiskEphemeralSSD) {
				dataDiskRequest.DeleteWithInstance = ""
			}

			dataDiskRequests = append(dataDiskRequests, dataDiskRequest)
		}
		request.DataDisk = &dataDiskRequests
	}
	return request, nil
}