in alibabacloudstack/resource_apsarastack_db_instance.go [238:453]
func resourceAlibabacloudStackDBInstanceCreate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*connectivity.AlibabacloudStackClient)
rdsService := RdsService{client}
vpcService := VpcService{client}
var VSwitchId, InstanceNetworkType, ZoneIdSlave1, ZoneIdSlave2, ZoneId, VPCId, arnrole string
var encryption bool
EncryptionKey := d.Get("encryption_key").(string)
encryption = d.Get("encryption").(bool)
log.Print("Encryption key input")
if EncryptionKey != "" && encryption == true {
log.Print("Encryption key condition passed")
req := client.NewCommonRequest("POST", "Rds", "2014-08-15", "CheckCloudResourceAuthorized", "")
req.QueryParams["TargetRegionId"] = client.RegionId
ram, err := client.WithRdsClient(func(RdsClient *rds.Client) (interface{}, error) {
return RdsClient.ProcessCommonRequest(req)
})
resparn, ok := ram.(*responses.CommonResponse)
if err != nil {
errmsg := ""
if ok {
errmsg = errmsgs.GetBaseResponseErrorMessage(resparn.BaseResponse)
}
return errmsgs.WrapErrorf(err, errmsgs.RequestV1ErrorMsg, "alibabacloudstack_db_instance", req.GetActionName(), errmsgs.AlibabacloudStackSdkGoERROR, errmsg)
}
var arnresp RoleARN
addDebug(req.GetActionName(), ram, req)
log.Printf("raw response %v", resparn)
err = json.Unmarshal(resparn.GetHttpContentBytes(), &arnresp)
if err != nil {
return errmsgs.WrapErrorf(err, errmsgs.DefaultErrorMsg, "CheckCloudResourceAuthorized", req.GetActionName(), errmsgs.AlibabacloudStackSdkGoERROR)
}
arnrole = arnresp.RoleArn
d.Set("role_arn", arnrole)
log.Printf("check arnrole %v", arnrole)
} else if EncryptionKey == "" && encryption == true {
return errmsgs.WrapErrorf(nil, "Add EncryptionKey or Set encryption to false", "CheckCloudResourceAuthorized", errmsgs.AlibabacloudStackSdkGoERROR)
} else if EncryptionKey != "" && encryption == false {
return errmsgs.WrapErrorf(nil, "Set encryption to true", "CheckCloudResourceAuthorized", errmsgs.AlibabacloudStackSdkGoERROR)
} else {
log.Print("Encryption key condition failed")
}
d.Set("encryption", encryption)
log.Printf("encryptionbool %v", d.Get("encryption").(bool))
enginever := Trim(d.Get("engine_version").(string))
engine := Trim(d.Get("engine").(string))
DBInstanceStorage := connectivity.GetResourceData(d, "db_instance_storage", "instance_storage").(int)
if err := errmsgs.CheckEmpty(DBInstanceStorage, schema.TypeString, "db_instance_storage", "instance_storage"); err != nil {
return errmsgs.WrapError(err)
}
DBInstanceClass := Trim(connectivity.GetResourceData(d, "db_instance_class", "instance_type").(string))
if err := errmsgs.CheckEmpty(DBInstanceClass, schema.TypeString, "db_instance_class", "instance_type"); err != nil {
return errmsgs.WrapError(err)
}
DBInstanceNetType := string(Intranet)
DBInstanceDescription := connectivity.GetResourceData(d, "db_instance_description", "instance_name").(string)
if zone, ok := d.GetOk("zone_id"); ok && Trim(zone.(string)) != "" {
ZoneId = Trim(zone.(string))
}
vswitchId := Trim(d.Get("vswitch_id").(string))
InstanceNetworkType = string(Classic)
if vswitchId != "" {
VSwitchId = vswitchId
InstanceNetworkType = strings.ToUpper(string(Vpc))
// check vswitchId in zone
vsw, err := vpcService.DescribeVSwitch(vswitchId)
if err != nil {
return nil
}
if ZoneId == "" {
ZoneId = vsw.ZoneId
}
VPCId = vsw.VpcId
}
payType := string(Postpaid)
if v, ok := connectivity.GetResourceDataOk(d, "payment_type", "instance_charge_type"); ok && Trim(v.(string)) != "" {
payType = Trim(v.(string))
}
DBInstanceStorageType := connectivity.GetResourceData(d, "db_instance_storage_type", "storage_type").(string)
if err := errmsgs.CheckEmpty(DBInstanceStorageType, schema.TypeString, "db_instance_storage_type", "storage_type"); err != nil {
return errmsgs.WrapError(err)
}
ZoneIdSlave1 = d.Get("zone_id_slave1").(string)
ZoneIdSlave2 = d.Get("zone_id_slave2").(string)
SecurityIPList := LOCAL_HOST_IP
if len(d.Get("security_ips").(*schema.Set).List()) > 0 {
SecurityIPList = strings.Join(expandStringList(d.Get("security_ips").(*schema.Set).List())[:], COMMA_SEPARATED)
}
uuid, err := uuid.GenerateUUID()
if err != nil {
uuid = resource.UniqueId()
}
ClientToken := fmt.Sprintf("Terraform-AlibabacloudStack-%d-%s", time.Now().Unix(), uuid)
request := client.NewCommonRequest("POST", "Rds", "2014-08-15", "CreateDBInstance", "")
mergeMaps(request.QueryParams, map[string]string{
"EngineVersion": enginever,
"Engine": engine,
"Encryption": strconv.FormatBool(encryption),
"DBInstanceStorage": strconv.Itoa(DBInstanceStorage),
"DBInstanceClass": DBInstanceClass,
"DBInstanceNetType": DBInstanceNetType,
"DBInstanceDescription": DBInstanceDescription,
"InstanceNetworkType": InstanceNetworkType,
"VSwitchId": VSwitchId,
"PayType": payType,
"DBInstanceStorageType": DBInstanceStorageType,
"SecurityIPList": SecurityIPList,
"ClientToken": ClientToken,
"ZoneIdSlave1": ZoneIdSlave1,
"ZoneIdSlave2": ZoneIdSlave2,
"EncryptionKey": EncryptionKey,
"ZoneId": ZoneId,
"VPCId": VPCId,
"RoleARN": arnrole,
})
log.Printf("request245 %v", request.QueryParams)
raw, err := client.WithRdsClient(func(RdsClient *rds.Client) (interface{}, error) {
return RdsClient.ProcessCommonRequest(request)
})
response, ok := raw.(*responses.CommonResponse)
if err != nil {
errmsg := ""
if ok {
errmsg = errmsgs.GetBaseResponseErrorMessage(response.BaseResponse)
}
return errmsgs.WrapErrorf(err, errmsgs.RequestV1ErrorMsg, "alibabacloudstack_db_instance", request.GetActionName(), errmsgs.AlibabacloudStackSdkGoERROR, errmsg)
}
if arnrole != "" {
log.Print("arnrole has been added")
} else {
log.Print("arnrole has not been added")
}
var resp CreateDBInstanceResponse
addDebug(request.GetActionName(), raw, request)
err = json.Unmarshal(response.GetHttpContentBytes(), &resp)
if err != nil {
return errmsgs.WrapErrorf(err, errmsgs.DefaultErrorMsg, "alibabacloudstack_db_instance", request.GetActionName(), errmsgs.AlibabacloudStackSdkGoERROR)
}
log.Printf("response25 %v", response)
d.SetId(resp.DBInstanceId)
d.Set("connection_string", resp.ConnectionString)
// wait instance status change from Creating to running
stateConf := BuildStateConf([]string{"Creating"}, []string{"Running"}, d.Timeout(schema.TimeoutCreate), 2*time.Minute, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return errmsgs.WrapErrorf(err, errmsgs.IdMsg, d.Id())
}
if tde := d.Get("tde_status"); tde == true {
client := meta.(*connectivity.AlibabacloudStackClient)
rdsService = RdsService{client}
tde_req := rds.CreateModifyDBInstanceTDERequest()
client.InitRpcRequest(*tde_req.RpcRequest)
tde_req.QueryParams["RoleARN"] = arnrole
tde_req.DBInstanceId = d.Id()
if EncryptionKey != "" {
tde_req.EncryptionKey = EncryptionKey
}
tde_req.TDEStatus = "Enabled"
tderaw, err := client.WithRdsClient(func(client *rds.Client) (interface{}, error) {
return client.ModifyDBInstanceTDE(tde_req)
})
if err != nil {
errmsg := ""
if tderaw != nil {
response, ok := tderaw.(*rds.ModifyDBInstanceTDEResponse)
if ok {
errmsg = errmsgs.GetBaseResponseErrorMessage(response.BaseResponse)
}
}
return errmsgs.WrapErrorf(err, errmsgs.RequestV1ErrorMsg, d.Id(), request.GetActionName(), errmsgs.AlibabacloudStackSdkGoERROR, errmsg)
}
if err := rdsService.WaitForDBInstance(d.Id(), Running, DefaultTimeoutMedium); err != nil {
return errmsgs.WrapError(err)
}
log.Print("enabled TDE")
addDebug(request.GetActionName(), tderaw, request)
}
if ssl := d.Get("enable_ssl"); ssl == true {
ssl_req := rds.CreateModifyDBInstanceSSLRequest()
client.InitRpcRequest(*ssl_req.RpcRequest)
ssl_req.QueryParams["Forwardedregionid"] = client.RegionId
ssl_req.DBInstanceId = d.Id()
ssl_req.SSLEnabled = "1"
ssl_req.ConnectionString = d.Get("connection_string").(string)
sslraw, err := client.WithRdsClient(func(client *rds.Client) (interface{}, error) {
return client.ModifyDBInstanceSSL(ssl_req)
})
if err != nil {
errmsg := ""
if sslraw != nil {
response, ok := sslraw.(*rds.ModifyDBInstanceSSLResponse)
if ok {
errmsg = errmsgs.GetBaseResponseErrorMessage(response.BaseResponse)
}
}
return errmsgs.WrapErrorf(err, errmsgs.RequestV1ErrorMsg, d.Id(), request.GetActionName(), errmsgs.AlibabacloudStackSdkGoERROR, errmsg)
}
if err := rdsService.WaitForDBInstance(d.Id(), Running, DefaultTimeoutMedium); err != nil {
return errmsgs.WrapError(err)
}
log.Print("enabled SSL")
addDebug(ssl_req.GetActionName(), sslraw, ssl_req)
}
return nil
}