in alicloud/resource_alicloud_cs_kubernetes_node_pool.go [2029:2857]
func resourceAliCloudAckNodepoolUpdate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*connectivity.AliyunClient)
var request map[string]interface{}
var response map[string]interface{}
var query map[string]*string
var body map[string]interface{}
update := false
d.Partial(true)
var err error
parts := strings.Split(d.Id(), ":")
ClusterId := parts[0]
NodepoolId := parts[1]
action := fmt.Sprintf("/clusters/%s/nodepools/%s", ClusterId, NodepoolId)
request = make(map[string]interface{})
query = make(map[string]*string)
body = make(map[string]interface{})
objectDataLocalMap := make(map[string]interface{})
if d.HasChange("resource_group_id") {
update = true
objectDataLocalMap["resource_group_id"] = d.Get("resource_group_id")
}
if d.HasChange("name") {
update = true
objectDataLocalMap["name"] = d.Get("name")
}
if d.HasChange("node_pool_name") {
update = true
objectDataLocalMap["name"] = d.Get("node_pool_name")
}
request["nodepool_info"] = objectDataLocalMap
objectDataLocalMap1 := make(map[string]interface{})
if d.HasChange("period") {
update = true
objectDataLocalMap1["period"] = d.Get("period")
}
if d.HasChange("platform") {
update = true
objectDataLocalMap1["platform"] = d.Get("platform")
}
if d.HasChange("data_disks") {
update = true
if v := d.Get("data_disks"); v != nil {
if v, ok := d.GetOk("data_disks"); ok {
localData, err := jsonpath.Get("$", v)
if err != nil {
localData = make([]interface{}, 0)
}
localMaps := make([]interface{}, 0)
for _, dataLoop := range localData.([]interface{}) {
dataLoopTmp := make(map[string]interface{})
if dataLoop != nil {
dataLoopTmp = dataLoop.(map[string]interface{})
}
dataLoopMap := make(map[string]interface{})
dataLoopMap["category"] = dataLoopTmp["category"]
if dataLoopMap["category"] == "cloud_auto" {
dataLoopMap["bursting_enabled"] = dataLoopTmp["bursting_enabled"]
}
dataLoopMap["performance_level"] = dataLoopTmp["performance_level"]
dataLoopMap["auto_snapshot_policy_id"] = dataLoopTmp["auto_snapshot_policy_id"]
if dataLoopTmp["provisioned_iops"].(int) > 0 {
dataLoopMap["provisioned_iops"] = dataLoopTmp["provisioned_iops"]
}
dataLoopMap["encrypted"] = dataLoopTmp["encrypted"]
if dataLoopTmp["size"].(int) > 0 {
dataLoopMap["size"] = dataLoopTmp["size"]
}
dataLoopMap["kms_key_id"] = dataLoopTmp["kms_key_id"]
dataLoopMap["device"] = dataLoopTmp["device"]
dataLoopMap["snapshot_id"] = dataLoopTmp["snapshot_id"]
dataLoopMap["disk_name"] = dataLoopTmp["name"]
if autoFormatRaw, ok := dataLoopTmp["auto_format"]; ok && autoFormatRaw != "" {
autoFormat, _ := strconv.ParseBool(autoFormatRaw.(string))
dataLoopMap["auto_format"] = autoFormat
}
dataLoopMap["file_system"] = dataLoopTmp["file_system"]
dataLoopMap["mount_target"] = dataLoopTmp["mount_target"]
localMaps = append(localMaps, dataLoopMap)
}
objectDataLocalMap1["data_disks"] = localMaps
}
}
}
if d.HasChange("compensate_with_on_demand") {
update = true
objectDataLocalMap1["compensate_with_on_demand"] = d.Get("compensate_with_on_demand")
}
if d.HasChange("auto_renew") {
update = true
objectDataLocalMap1["auto_renew"] = d.Get("auto_renew")
}
if d.HasChange("auto_renew_period") {
update = true
objectDataLocalMap1["auto_renew_period"] = d.Get("auto_renew_period")
}
if d.HasChange("desired_size") {
if d.Get("desired_size") != nil && d.Get("desired_size") != "" {
update = true
desiredSize, _ := strconv.ParseInt(d.Get("desired_size").(string), 10, 64)
objectDataLocalMap1["desired_size"] = desiredSize
}
}
if d.HasChange("image_id") {
update = true
objectDataLocalMap1["image_id"] = d.Get("image_id")
}
if d.HasChange("instance_charge_type") {
update = true
objectDataLocalMap1["instance_charge_type"] = d.Get("instance_charge_type")
}
if d.HasChange("internet_charge_type") {
update = true
objectDataLocalMap1["internet_charge_type"] = d.Get("internet_charge_type")
}
if d.HasChange("internet_max_bandwidth_out") {
update = true
objectDataLocalMap1["internet_max_bandwidth_out"] = d.Get("internet_max_bandwidth_out")
}
if d.HasChange("key_name") {
update = true
objectDataLocalMap1["key_pair"] = d.Get("key_name")
}
if d.HasChange("multi_az_policy") {
update = true
objectDataLocalMap1["multi_az_policy"] = d.Get("multi_az_policy")
}
if d.HasChange("on_demand_base_capacity") {
if d.Get("on_demand_base_capacity") != nil && d.Get("on_demand_base_capacity") != "" {
update = true
onDemandBaseCapacity, _ := strconv.ParseInt(d.Get("on_demand_base_capacity").(string), 10, 64)
objectDataLocalMap1["on_demand_base_capacity"] = onDemandBaseCapacity
}
}
if d.HasChange("on_demand_percentage_above_base_capacity") {
if d.Get("on_demand_percentage_above_base_capacity") != nil && d.Get("on_demand_percentage_above_base_capacity") != "" {
update = true
onDemandPercentageAboveBaseCapacity, _ := strconv.ParseInt(d.Get("on_demand_percentage_above_base_capacity").(string), 10, 64)
objectDataLocalMap1["on_demand_percentage_above_base_capacity"] = onDemandPercentageAboveBaseCapacity
}
}
if d.HasChange("period_unit") {
update = true
objectDataLocalMap1["period_unit"] = d.Get("period_unit")
}
if d.HasChange("scaling_policy") {
update = true
objectDataLocalMap1["scaling_policy"] = d.Get("scaling_policy")
}
if d.HasChange("spot_instance_pools") {
update = true
objectDataLocalMap1["spot_instance_pools"] = d.Get("spot_instance_pools")
}
if d.HasChange("spot_instance_remedy") {
update = true
objectDataLocalMap1["spot_instance_remedy"] = d.Get("spot_instance_remedy")
}
if d.HasChange("spot_price_limit") {
update = true
if v := d.Get("spot_price_limit"); v != nil {
if v, ok := d.GetOk("spot_price_limit"); ok {
localData1, err := jsonpath.Get("$", v)
if err != nil {
localData1 = make([]interface{}, 0)
}
localMaps1 := make([]interface{}, 0)
for _, dataLoop1 := range localData1.([]interface{}) {
dataLoop1Tmp := make(map[string]interface{})
if dataLoop1 != nil {
dataLoop1Tmp = dataLoop1.(map[string]interface{})
}
dataLoop1Map := make(map[string]interface{})
dataLoop1Map["instance_type"] = dataLoop1Tmp["instance_type"]
dataLoop1Map["price_limit"] = dataLoop1Tmp["price_limit"]
localMaps1 = append(localMaps1, dataLoop1Map)
}
objectDataLocalMap1["spot_price_limit"] = localMaps1
}
}
}
if d.HasChange("spot_strategy") {
update = true
objectDataLocalMap1["spot_strategy"] = d.Get("spot_strategy")
}
if d.HasChange("system_disk_category") {
update = true
objectDataLocalMap1["system_disk_category"] = d.Get("system_disk_category")
}
if d.HasChange("system_disk_performance_level") {
update = true
objectDataLocalMap1["system_disk_performance_level"] = d.Get("system_disk_performance_level")
}
if d.HasChange("vswitch_ids") {
update = true
vswitchIds, _ := jsonpath.Get("$", d.Get("vswitch_ids"))
if vswitchIds != nil && vswitchIds != "" {
objectDataLocalMap1["vswitch_ids"] = vswitchIds
}
}
if d.HasChange("tags") {
update = true
if v := d.Get("tags"); v != nil {
tagsMap := ConvertTags(v.(map[string]interface{}))
objectDataLocalMap1["tags"] = tagsMap
}
}
if d.HasChange("system_disk_size") {
update = true
objectDataLocalMap1["system_disk_size"] = d.Get("system_disk_size")
}
if d.HasChange("password") {
update = true
objectDataLocalMap1["login_password"] = d.Get("password")
}
password := d.Get("password").(string)
if password == "" {
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 WrapError(err)
}
objectDataLocalMap1["login_password"] = decryptResp
}
}
if d.HasChange("private_pool_options") {
update = true
if v := d.Get("private_pool_options"); v != nil {
private_pool_options := make(map[string]interface{})
privatePoolOptionsMatchCriteria, _ := jsonpath.Get("$[0].private_pool_options_match_criteria", v)
if privatePoolOptionsMatchCriteria != nil && privatePoolOptionsMatchCriteria != "" {
private_pool_options["match_criteria"] = privatePoolOptionsMatchCriteria
}
privatePoolOptionsId, _ := jsonpath.Get("$[0].private_pool_options_id", v)
if privatePoolOptionsId != nil && privatePoolOptionsId != "" {
private_pool_options["id"] = privatePoolOptionsId
}
objectDataLocalMap1["private_pool_options"] = private_pool_options
}
}
if d.HasChange("system_disk_provisioned_iops") {
update = true
objectDataLocalMap1["system_disk_provisioned_iops"] = d.Get("system_disk_provisioned_iops")
}
if d.HasChange("system_disk_bursting_enabled") {
update = true
objectDataLocalMap1["system_disk_bursting_enabled"] = d.Get("system_disk_bursting_enabled")
}
if d.HasChange("system_disk_encrypted") {
update = true
objectDataLocalMap1["system_disk_encrypted"] = d.Get("system_disk_encrypted")
}
if d.HasChange("system_disk_categories") {
update = true
systemDiskCategories, _ := jsonpath.Get("$", d.Get("system_disk_categories"))
if systemDiskCategories != nil && systemDiskCategories != "" {
objectDataLocalMap1["system_disk_categories"] = systemDiskCategories
}
}
if d.HasChange("system_disk_encrypt_algorithm") {
update = true
objectDataLocalMap1["system_disk_encrypt_algorithm"] = d.Get("system_disk_encrypt_algorithm")
}
if d.HasChange("image_type") {
update = true
objectDataLocalMap1["image_type"] = d.Get("image_type")
}
if d.HasChange("instance_types") {
update = true
instanceTypes, _ := jsonpath.Get("$", d.Get("instance_types"))
if instanceTypes != nil && instanceTypes != "" {
objectDataLocalMap1["instance_types"] = instanceTypes
}
}
if d.HasChange("rds_instances") {
update = true
rdsInstances, _ := jsonpath.Get("$", d.Get("rds_instances"))
if rdsInstances != nil && rdsInstances != "" {
objectDataLocalMap1["rds_instances"] = rdsInstances
}
}
if d.HasChange("system_disk_kms_key") {
update = true
objectDataLocalMap1["system_disk_kms_key_id"] = d.Get("system_disk_kms_key")
}
if d.HasChange("system_disk_snapshot_policy_id") {
update = true
objectDataLocalMap1["worker_system_disk_snapshot_policy_id"] = d.Get("system_disk_snapshot_policy_id")
}
request["scaling_group"] = objectDataLocalMap1
objectDataLocalMap2 := make(map[string]interface{})
if d.HasChange("cpu_policy") {
update = true
objectDataLocalMap2["cpu_policy"] = d.Get("cpu_policy")
}
if d.HasChange("install_cloud_monitor") {
update = true
objectDataLocalMap2["cms_enabled"] = d.Get("install_cloud_monitor")
}
if d.HasChange("runtime_version") {
update = true
objectDataLocalMap2["runtime_version"] = d.Get("runtime_version")
}
if d.HasChange("user_data") {
update = true
objectDataLocalMap2["user_data"] = d.Get("user_data")
if v := d.Get("user_data").(string); v != "" {
_, base64DecodeError := base64.StdEncoding.DecodeString(v)
if base64DecodeError == nil {
objectDataLocalMap2["user_data"] = tea.String(v)
} else {
objectDataLocalMap2["user_data"] = tea.String(base64.StdEncoding.EncodeToString([]byte(v)))
}
}
}
if d.HasChange("taints") {
update = true
if v := d.Get("taints"); v != nil {
localData3, err := jsonpath.Get("$", v)
if err != nil {
localData3 = make([]interface{}, 0)
}
localMaps3 := make([]interface{}, 0)
for _, dataLoop3 := range localData3.([]interface{}) {
dataLoop3Tmp := make(map[string]interface{})
if dataLoop3 != nil {
dataLoop3Tmp = dataLoop3.(map[string]interface{})
}
dataLoop3Map := make(map[string]interface{})
dataLoop3Map["key"] = dataLoop3Tmp["key"]
dataLoop3Map["effect"] = dataLoop3Tmp["effect"]
dataLoop3Map["value"] = dataLoop3Tmp["value"]
localMaps3 = append(localMaps3, dataLoop3Map)
}
objectDataLocalMap2["taints"] = localMaps3
}
}
if d.HasChange("runtime_name") {
update = true
objectDataLocalMap2["runtime"] = d.Get("runtime_name")
}
if d.HasChange("labels") {
update = true
if v := d.Get("labels"); v != nil {
localData4, err := jsonpath.Get("$", v)
if err != nil {
localData4 = make([]interface{}, 0)
}
localMaps4 := make([]interface{}, 0)
for _, dataLoop4 := range localData4.([]interface{}) {
dataLoop4Tmp := make(map[string]interface{})
if dataLoop4 != nil {
dataLoop4Tmp = dataLoop4.(map[string]interface{})
}
dataLoop4Map := make(map[string]interface{})
dataLoop4Map["key"] = dataLoop4Tmp["key"]
dataLoop4Map["value"] = dataLoop4Tmp["value"]
localMaps4 = append(localMaps4, dataLoop4Map)
}
objectDataLocalMap2["labels"] = localMaps4
}
}
if d.HasChange("unschedulable") {
update = true
objectDataLocalMap2["unschedulable"] = d.Get("unschedulable")
}
if d.HasChange("pre_user_data") {
update = true
objectDataLocalMap2["pre_user_data"] = d.Get("pre_user_data")
}
request["kubernetes_config"] = objectDataLocalMap2
if d.HasChange("scaling_config") {
update = true
objectDataLocalMap3 := make(map[string]interface{})
if v := d.Get("scaling_config"); v != nil {
type1, _ := jsonpath.Get("$[0].type", v)
if type1 != nil && type1 != "" {
objectDataLocalMap3["type"] = type1
}
enable1, _ := jsonpath.Get("$[0].enable", v)
if enable1 != nil && enable1 != "" {
objectDataLocalMap3["enable"] = enable1
}
maxSize, _ := jsonpath.Get("$[0].max_size", v)
if maxSize != nil && maxSize != "" {
objectDataLocalMap3["max_instances"] = maxSize
}
minSize, _ := jsonpath.Get("$[0].min_size", v)
if minSize != nil && minSize != "" {
objectDataLocalMap3["min_instances"] = minSize
}
eipBandwidth, _ := jsonpath.Get("$[0].eip_bandwidth", v)
if eipBandwidth != nil && eipBandwidth != "" && eipBandwidth.(int) > 0 {
objectDataLocalMap3["eip_bandwidth"] = eipBandwidth
}
eipInternetChargeType, _ := jsonpath.Get("$[0].eip_internet_charge_type", v)
if eipInternetChargeType != nil && eipInternetChargeType != "" {
objectDataLocalMap3["eip_internet_charge_type"] = eipInternetChargeType
}
isBondEip, _ := jsonpath.Get("$[0].is_bond_eip", v)
if isBondEip != nil && isBondEip != "" {
objectDataLocalMap3["is_bond_eip"] = isBondEip
}
request["auto_scaling"] = objectDataLocalMap3
}
}
if d.HasChange("management") {
update = true
objectDataLocalMap4 := make(map[string]interface{})
if v := d.Get("management"); v != nil {
enable3, _ := jsonpath.Get("$[0].enable", v)
if enable3 != nil && enable3 != "" {
objectDataLocalMap4["enable"] = enable3
}
autoRepair, _ := jsonpath.Get("$[0].auto_repair", v)
if autoRepair != nil && autoRepair != "" {
objectDataLocalMap4["auto_repair"] = autoRepair
}
auto_repair_policy := make(map[string]interface{})
restartNode, _ := jsonpath.Get("$[0].auto_repair_policy[0].restart_node", v)
if restartNode != nil && restartNode != "" {
auto_repair_policy["restart_node"] = restartNode
}
objectDataLocalMap4["auto_repair_policy"] = auto_repair_policy
autoVulFix, _ := jsonpath.Get("$[0].auto_vul_fix", v)
if autoVulFix != nil && autoVulFix != "" {
objectDataLocalMap4["auto_vul_fix"] = autoVulFix
}
auto_vul_fix_policy := make(map[string]interface{})
restartNode1, _ := jsonpath.Get("$[0].auto_vul_fix_policy[0].restart_node", v)
if restartNode1 != nil && restartNode1 != "" {
auto_vul_fix_policy["restart_node"] = restartNode1
}
vulLevel, _ := jsonpath.Get("$[0].auto_vul_fix_policy[0].vul_level", v)
if vulLevel != nil && vulLevel != "" {
auto_vul_fix_policy["vul_level"] = vulLevel
}
objectDataLocalMap4["auto_vul_fix_policy"] = auto_vul_fix_policy
autoUpgrade, _ := jsonpath.Get("$[0].auto_upgrade", v)
if autoUpgrade != nil && autoUpgrade != "" {
objectDataLocalMap4["auto_upgrade"] = autoUpgrade
}
auto_upgrade_policy := make(map[string]interface{})
autoUpgradeKubelet, _ := jsonpath.Get("$[0].auto_upgrade_policy[0].auto_upgrade_kubelet", v)
if autoUpgradeKubelet != nil && autoUpgradeKubelet != "" {
auto_upgrade_policy["auto_upgrade_kubelet"] = autoUpgradeKubelet
}
objectDataLocalMap4["auto_upgrade_policy"] = auto_upgrade_policy
upgrade_config := make(map[string]interface{})
surge1, _ := jsonpath.Get("$[0].surge", v)
if surge1 != nil && surge1 != "" {
upgrade_config["surge"] = surge1
}
surgePercentage, _ := jsonpath.Get("$[0].surge_percentage", v)
if surgePercentage != nil && surgePercentage != "" {
upgrade_config["surge_percentage"] = surgePercentage
}
maxUnavailable, _ := jsonpath.Get("$[0].max_unavailable", v)
if maxUnavailable != nil && maxUnavailable != "" && maxUnavailable.(int) > 0 {
upgrade_config["max_unavailable"] = maxUnavailable
}
objectDataLocalMap4["upgrade_config"] = upgrade_config
request["management"] = objectDataLocalMap4
}
}
if v, ok := d.GetOk("update_nodes"); ok {
request["update_nodes"] = v
}
if _, exist := d.GetOk("desired_size"); !exist && d.HasChange("node_count") {
oldV, newV := d.GetChange("node_count")
oldValue, ok := oldV.(int)
if ok != true {
return WrapErrorf(fmt.Errorf("node_count old value can not be parsed"), "parseError %d", oldValue)
}
newValue, ok := newV.(int)
if ok != true {
return WrapErrorf(fmt.Errorf("node_count new value can not be parsed"), "parseError %d", newValue)
}
if newValue < oldValue {
if err = removeNodePoolNodes(d, meta, parts, nil, nil); err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), "RemoveNodePoolNodes", AlibabaCloudSdkGoERROR)
}
// The removal of a node is logically independent.
// The removal of a node should not involve parameter changes.
return resourceAliCloudAckNodepoolRead(d, meta)
}
update = true
request["count"] = int64(newValue) - int64(oldValue)
}
body = request
if update {
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RoaPut("CS", "2015-12-15", action, query, nil, body, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
ackServiceV2 := AckServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"success"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, ackServiceV2.DescribeAsyncAckNodepoolStateRefreshFunc(d, response, "$.state", []string{"fail", "failed"}))
if jobDetail, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id(), jobDetail)
}
}
update = false
parts = strings.Split(d.Id(), ":")
ClusterId = parts[0]
NodepoolId = parts[1]
action = fmt.Sprintf("/clusters/%s/nodepools/%s/node_config", ClusterId, NodepoolId)
request = make(map[string]interface{})
query = make(map[string]*string)
body = make(map[string]interface{})
if d.HasChange("kubelet_configuration") {
update = true
objectDataLocalMap := make(map[string]interface{})
if v := d.Get("kubelet_configuration"); v != nil {
registryBurst1Raw, _ := jsonpath.Get("$[0].registry_burst", v)
if registryBurst1Raw != nil && registryBurst1Raw != "" {
registryBurst1, _ := strconv.ParseInt(registryBurst1Raw.(string), 10, 64)
objectDataLocalMap["registryBurst"] = registryBurst1
}
registryPullQpsRaw, _ := jsonpath.Get("$[0].registry_pull_qps", v)
if registryPullQpsRaw != nil && registryPullQpsRaw != "" {
registryPullQps, _ := strconv.ParseInt(registryPullQpsRaw.(string), 10, 64)
objectDataLocalMap["registryPullQPS"] = registryPullQps
}
eventRecordQpsRaw, _ := jsonpath.Get("$[0].event_record_qps", v)
if eventRecordQpsRaw != nil && eventRecordQpsRaw != "" {
eventRecordQps, _ := strconv.ParseInt(eventRecordQpsRaw.(string), 10, 64)
objectDataLocalMap["eventRecordQPS"] = eventRecordQps
}
eventBurst1Raw, _ := jsonpath.Get("$[0].event_burst", v)
if eventBurst1Raw != nil && eventBurst1Raw != "" {
eventBurst1, _ := strconv.ParseInt(eventBurst1Raw.(string), 10, 64)
objectDataLocalMap["eventBurst"] = eventBurst1
}
kubeApiQpsRaw, _ := jsonpath.Get("$[0].kube_api_qps", v)
if kubeApiQpsRaw != nil && kubeApiQpsRaw != "" {
kubeApiQps, _ := strconv.ParseInt(kubeApiQpsRaw.(string), 10, 64)
objectDataLocalMap["kubeAPIQPS"] = kubeApiQps
}
serializeImagePulls1Raw, _ := jsonpath.Get("$[0].serialize_image_pulls", v)
if serializeImagePulls1Raw != nil && serializeImagePulls1Raw != "" {
serializeImagePulls1, _ := strconv.ParseBool(serializeImagePulls1Raw.(string))
objectDataLocalMap["serializeImagePulls"] = serializeImagePulls1
}
cpuManagerPolicy1, _ := jsonpath.Get("$[0].cpu_manager_policy", v)
if cpuManagerPolicy1 != nil && cpuManagerPolicy1 != "" {
objectDataLocalMap["cpuManagerPolicy"] = cpuManagerPolicy1
}
evictionHard1, _ := jsonpath.Get("$[0].eviction_hard", v)
if evictionHard1 != nil && evictionHard1 != "" {
objectDataLocalMap["evictionHard"] = evictionHard1
}
evictionSoft1, _ := jsonpath.Get("$[0].eviction_soft", v)
if evictionSoft1 != nil && evictionSoft1 != "" {
objectDataLocalMap["evictionSoft"] = evictionSoft1
}
evictionSoftGracePeriod1, _ := jsonpath.Get("$[0].eviction_soft_grace_period", v)
if evictionSoftGracePeriod1 != nil && evictionSoftGracePeriod1 != "" {
objectDataLocalMap["evictionSoftGracePeriod"] = evictionSoftGracePeriod1
}
systemReserved1, _ := jsonpath.Get("$[0].system_reserved", v)
if systemReserved1 != nil && systemReserved1 != "" {
objectDataLocalMap["systemReserved"] = systemReserved1
}
kubeReserved1, _ := jsonpath.Get("$[0].kube_reserved", v)
if kubeReserved1 != nil && kubeReserved1 != "" {
objectDataLocalMap["kubeReserved"] = kubeReserved1
}
readOnlyPort1Raw, _ := jsonpath.Get("$[0].read_only_port", v)
if readOnlyPort1Raw != nil && readOnlyPort1Raw != "" {
readOnlyPort1, _ := strconv.ParseInt(readOnlyPort1Raw.(string), 10, 64)
objectDataLocalMap["readOnlyPort"] = readOnlyPort1
}
maxPods1Raw, _ := jsonpath.Get("$[0].max_pods", v)
if maxPods1Raw != nil && maxPods1Raw != "" {
maxPods1, _ := strconv.ParseInt(maxPods1Raw.(string), 10, 64)
objectDataLocalMap["maxPods"] = maxPods1
}
containerLogMaxSize1, _ := jsonpath.Get("$[0].container_log_max_size", v)
if containerLogMaxSize1 != nil && containerLogMaxSize1 != "" {
objectDataLocalMap["containerLogMaxSize"] = containerLogMaxSize1
}
containerLogMaxFiles1Raw, _ := jsonpath.Get("$[0].container_log_max_files", v)
if containerLogMaxFiles1Raw != nil && containerLogMaxFiles1Raw != "" {
containerLogMaxFiles1, _ := strconv.ParseInt(containerLogMaxFiles1Raw.(string), 10, 64)
objectDataLocalMap["containerLogMaxFiles"] = containerLogMaxFiles1
}
featureGates1, _ := jsonpath.Get("$[0].feature_gates", v)
if featureGates1 != nil && featureGates1 != "" {
objectDataLocalMap["featureGates"] = featureGates1
}
allowedUnsafeSysctls1, _ := jsonpath.Get("$[0].allowed_unsafe_sysctls", d.Get("kubelet_configuration"))
if allowedUnsafeSysctls1 != nil && allowedUnsafeSysctls1 != "" {
objectDataLocalMap["allowedUnsafeSysctls"] = allowedUnsafeSysctls1
}
kubeApiBurstRaw, _ := jsonpath.Get("$[0].kube_api_burst", v)
if kubeApiBurstRaw != nil && kubeApiBurstRaw != "" {
kubeApiBurst, _ := strconv.ParseInt(kubeApiBurstRaw.(string), 10, 64)
objectDataLocalMap["kubeAPIBurst"] = kubeApiBurst
}
cpuCfsQuotaRaw, _ := jsonpath.Get("$[0].cpu_cfs_quota", v)
if cpuCfsQuotaRaw != nil && cpuCfsQuotaRaw != "" {
cpuCfsQuota, _ := strconv.ParseBool(cpuCfsQuotaRaw.(string))
objectDataLocalMap["cpuCFSQuota"] = cpuCfsQuota
}
if v, ok := d.GetOk("kubelet_configuration"); ok {
localData, err := jsonpath.Get("$[0].reserved_memory", v)
if err != nil {
localData = make([]interface{}, 0)
}
localMaps := make([]interface{}, 0)
for _, dataLoop := range localData.([]interface{}) {
dataLoopTmp := make(map[string]interface{})
if dataLoop != nil {
dataLoopTmp = dataLoop.(map[string]interface{})
}
dataLoopMap := make(map[string]interface{})
dataLoopMap["numaNode"] = dataLoopTmp["numa_node"]
dataLoopMap["limits"] = dataLoopTmp["limits"]
localMaps = append(localMaps, dataLoopMap)
}
objectDataLocalMap["reservedMemory"] = localMaps
}
cpuCfsQuotaPeriod, _ := jsonpath.Get("$[0].cpu_cfs_quota_period", v)
if cpuCfsQuotaPeriod != nil && cpuCfsQuotaPeriod != "" {
objectDataLocalMap["cpuCFSQuotaPeriod"] = cpuCfsQuotaPeriod
}
imageGcHighThresholdPercentRaw, _ := jsonpath.Get("$[0].image_gc_high_threshold_percent", v)
if imageGcHighThresholdPercentRaw != nil && imageGcHighThresholdPercentRaw != "" {
imageGcHighThresholdPercent, _ := strconv.ParseInt(imageGcHighThresholdPercentRaw.(string), 10, 64)
objectDataLocalMap["imageGCHighThresholdPercent"] = imageGcHighThresholdPercent
}
imageGcLowThresholdPercentRaw, _ := jsonpath.Get("$[0].image_gc_low_threshold_percent", v)
if imageGcLowThresholdPercentRaw != nil && imageGcLowThresholdPercentRaw != "" {
imageGcLowThresholdPercent, _ := strconv.ParseInt(imageGcLowThresholdPercentRaw.(string), 10, 64)
objectDataLocalMap["imageGCLowThresholdPercent"] = imageGcLowThresholdPercent
}
clusterDns, _ := jsonpath.Get("$[0].cluster_dns", d.Get("kubelet_configuration"))
if clusterDns != nil && clusterDns != "" {
objectDataLocalMap["clusterDNS"] = clusterDns
}
memoryManagerPolicy1, _ := jsonpath.Get("$[0].memory_manager_policy", v)
if memoryManagerPolicy1 != nil && memoryManagerPolicy1 != "" {
objectDataLocalMap["memoryManagerPolicy"] = memoryManagerPolicy1
}
tracing := make(map[string]interface{})
endpoint1, _ := jsonpath.Get("$[0].tracing[0].endpoint", v)
if endpoint1 != nil && endpoint1 != "" {
tracing["endpoint"] = endpoint1
}
samplingRatePerMillion1Raw, _ := jsonpath.Get("$[0].tracing[0].sampling_rate_per_million", v)
if samplingRatePerMillion1Raw != nil && samplingRatePerMillion1Raw != "" {
samplingRatePerMillion1, _ := strconv.ParseInt(samplingRatePerMillion1Raw.(string), 10, 64)
tracing["samplingRatePerMillion"] = samplingRatePerMillion1
}
objectDataLocalMap["tracing"] = tracing
containerLogMaxWorkers1Raw, _ := jsonpath.Get("$[0].container_log_max_workers", v)
if containerLogMaxWorkers1Raw != nil && containerLogMaxWorkers1Raw != "" {
containerLogMaxWorkers1, _ := strconv.ParseInt(containerLogMaxWorkers1Raw.(string), 10, 64)
objectDataLocalMap["containerLogMaxWorkers"] = containerLogMaxWorkers1
}
containerLogMonitorInterval1, _ := jsonpath.Get("$[0].container_log_monitor_interval", v)
if containerLogMonitorInterval1 != nil && containerLogMonitorInterval1 != "" {
objectDataLocalMap["containerLogMonitorInterval"] = containerLogMonitorInterval1
}
topologyManagerPolicy1, _ := jsonpath.Get("$[0].topology_manager_policy", v)
if topologyManagerPolicy1 != nil && topologyManagerPolicy1 != "" {
objectDataLocalMap["topologyManagerPolicy"] = topologyManagerPolicy1
}
podPidsLimit1Raw, _ := jsonpath.Get("$[0].pod_pids_limit", v)
if podPidsLimit1Raw != nil && podPidsLimit1Raw != "" {
podPidsLimit1, _ := strconv.ParseInt(podPidsLimit1Raw.(string), 10, 64)
objectDataLocalMap["podPidsLimit"] = podPidsLimit1
}
request["kubelet_config"] = objectDataLocalMap
}
}
objectDataLocalMap1 = make(map[string]interface{})
if v := d.Get("rolling_policy"); v != nil {
maxParallelism, _ := jsonpath.Get("$[0].max_parallelism", v)
if maxParallelism != nil && maxParallelism != "" {
objectDataLocalMap1["max_parallelism"] = maxParallelism
}
request["rolling_policy"] = objectDataLocalMap1
}
body = request
if update {
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RoaPut("CS", "2015-12-15", action, query, nil, body, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
ackServiceV2 := AckServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"success"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, ackServiceV2.DescribeAsyncAckNodepoolStateRefreshFunc(d, response, "$.state", []string{"fail", "failed"}))
if jobDetail, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id(), jobDetail)
}
}
// attach or remove existing node
if d.HasChange("instances") {
rawOldValue, rawNewValue := d.GetChange("instances")
oldValue, ok := rawOldValue.([]interface{})
if ok != true {
return WrapErrorf(fmt.Errorf("instances old value can not be parsed"), "parseError %d", oldValue)
}
newValue, ok := rawNewValue.([]interface{})
if ok != true {
return WrapErrorf(fmt.Errorf("instances new value can not be parsed"), "parseError %d", oldValue)
}
attach, remove := diffInstances(expandStringList(oldValue), expandStringList(newValue))
if len(attach) > 0 {
if err = attachExistingInstance(d, meta, attach); err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), "AttachInstances", AlibabaCloudSdkGoERROR)
}
}
if len(remove) > 0 {
if err = removeNodePoolNodes(d, meta, parts, oldValue, newValue); err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), "RemoveNodePoolNodes", AlibabaCloudSdkGoERROR)
}
}
}
d.Partial(false)
return resourceAliCloudAckNodepoolRead(d, meta)
}