func resourceAliCloudDcdnErUpdate()

in alicloud/resource_alicloud_dcdn_er.go [2838:3745]


func resourceAliCloudDcdnErUpdate(d *schema.ResourceData, meta interface{}) error {
	client := meta.(*connectivity.AliyunClient)
	var response map[string]interface{}
	var err error
	update := false

	request := map[string]interface{}{
		"Name": d.Id(),
	}

	if d.HasChange("description") {
		update = true
	}
	if v, ok := d.GetOk("description"); ok {
		request["Description"] = v
	}

	if d.HasChange("env_conf") {
		update = true
	}
	if v, ok := d.GetOk("env_conf"); ok {
		envConfMap := map[string]interface{}{}
		for _, envConfList := range v.([]interface{}) {
			envConfArg := envConfList.(map[string]interface{})

			if staging, ok := envConfArg["staging"]; ok {
				stagingMap := map[string]interface{}{}
				for _, stagingList := range staging.([]interface{}) {
					stagingArg := stagingList.(map[string]interface{})

					if specName, ok := stagingArg["spec_name"]; ok {
						stagingMap["SpecName"] = specName
					}

					if codeRev, ok := stagingArg["code_rev"]; ok {
						stagingMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := stagingArg["allowed_hosts"]; ok {
						stagingMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(stagingMap) > 0 {
					envConfMap["staging"] = stagingMap
				}
			}

			if production, ok := envConfArg["production"]; ok {
				productionMap := map[string]interface{}{}
				for _, productionList := range production.([]interface{}) {
					productionArg := productionList.(map[string]interface{})

					if specName, ok := productionArg["spec_name"]; ok {
						productionMap["SpecName"] = specName
					}

					if codeRev, ok := productionArg["code_rev"]; ok {
						productionMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := productionArg["allowed_hosts"]; ok {
						productionMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(productionMap) > 0 {
					envConfMap["production"] = productionMap
				}
			}

			if presetCanaryAnhui, ok := envConfArg["preset_canary_anhui"]; ok {
				presetCanaryAnhuiMap := map[string]interface{}{}
				for _, presetCanaryAnhuiList := range presetCanaryAnhui.([]interface{}) {
					presetCanaryAnhuiArg := presetCanaryAnhuiList.(map[string]interface{})

					if specName, ok := presetCanaryAnhuiArg["spec_name"]; ok {
						presetCanaryAnhuiMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryAnhuiArg["code_rev"]; ok {
						presetCanaryAnhuiMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryAnhuiArg["allowed_hosts"]; ok {
						presetCanaryAnhuiMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryAnhuiMap) > 0 {
					envConfMap["presetCanaryAnhui"] = presetCanaryAnhuiMap
				}
			}

			if presetCanaryBeijing, ok := envConfArg["preset_canary_beijing"]; ok {
				presetCanaryBeijingMap := map[string]interface{}{}
				for _, presetCanaryBeijingList := range presetCanaryBeijing.([]interface{}) {
					presetCanaryBeijingArg := presetCanaryBeijingList.(map[string]interface{})

					if specName, ok := presetCanaryBeijingArg["spec_name"]; ok {
						presetCanaryBeijingMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryBeijingArg["code_rev"]; ok {
						presetCanaryBeijingMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryBeijingArg["allowed_hosts"]; ok {
						presetCanaryBeijingMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryBeijingMap) > 0 {
					envConfMap["presetCanaryBeijing"] = presetCanaryBeijingMap
				}
			}

			if presetCanaryChongqing, ok := envConfArg["preset_canary_chongqing"]; ok {
				presetCanaryChongqingMap := map[string]interface{}{}
				for _, presetCanaryChongqingList := range presetCanaryChongqing.([]interface{}) {
					presetCanaryChongqingArg := presetCanaryChongqingList.(map[string]interface{})

					if specName, ok := presetCanaryChongqingArg["spec_name"]; ok {
						presetCanaryChongqingMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryChongqingArg["code_rev"]; ok {
						presetCanaryChongqingMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryChongqingArg["allowed_hosts"]; ok {
						presetCanaryChongqingMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryChongqingMap) > 0 {
					envConfMap["presetCanaryChongqing"] = presetCanaryChongqingMap
				}
			}

			if presetCanaryFujian, ok := envConfArg["preset_canary_fujian"]; ok {
				presetCanaryFujianMap := map[string]interface{}{}
				for _, presetCanaryFujianList := range presetCanaryFujian.([]interface{}) {
					presetCanaryFujianArg := presetCanaryFujianList.(map[string]interface{})

					if specName, ok := presetCanaryFujianArg["spec_name"]; ok {
						presetCanaryFujianMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryFujianArg["code_rev"]; ok {
						presetCanaryFujianMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryFujianArg["allowed_hosts"]; ok {
						presetCanaryFujianMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryFujianMap) > 0 {
					envConfMap["presetCanaryFujian"] = presetCanaryFujianMap
				}
			}

			if presetCanaryGansu, ok := envConfArg["preset_canary_gansu"]; ok {
				presetCanaryGansuMap := map[string]interface{}{}
				for _, presetCanaryGansuList := range presetCanaryGansu.([]interface{}) {
					presetCanaryGansuArg := presetCanaryGansuList.(map[string]interface{})

					if specName, ok := presetCanaryGansuArg["spec_name"]; ok {
						presetCanaryGansuMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryGansuArg["code_rev"]; ok {
						presetCanaryGansuMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryGansuArg["allowed_hosts"]; ok {
						presetCanaryGansuMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryGansuMap) > 0 {
					envConfMap["presetCanaryGansu"] = presetCanaryGansuMap
				}
			}

			if presetCanaryGuangdong, ok := envConfArg["preset_canary_guangdong"]; ok {
				presetCanaryGuangdongMap := map[string]interface{}{}
				for _, presetCanaryGuangdongList := range presetCanaryGuangdong.([]interface{}) {
					presetCanaryGuangdongArg := presetCanaryGuangdongList.(map[string]interface{})

					if specName, ok := presetCanaryGuangdongArg["spec_name"]; ok {
						presetCanaryGuangdongMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryGuangdongArg["code_rev"]; ok {
						presetCanaryGuangdongMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryGuangdongArg["allowed_hosts"]; ok {
						presetCanaryGuangdongMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryGuangdongMap) > 0 {
					envConfMap["presetCanaryGuangdong"] = presetCanaryGuangdongMap
				}
			}

			if presetCanaryGuangxi, ok := envConfArg["preset_canary_guangxi"]; ok {
				presetCanaryGuangxiMap := map[string]interface{}{}
				for _, presetCanaryGuangxiList := range presetCanaryGuangxi.([]interface{}) {
					presetCanaryGuangxiArg := presetCanaryGuangxiList.(map[string]interface{})

					if specName, ok := presetCanaryGuangxiArg["spec_name"]; ok {
						presetCanaryGuangxiMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryGuangxiArg["code_rev"]; ok {
						presetCanaryGuangxiMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryGuangxiArg["allowed_hosts"]; ok {
						presetCanaryGuangxiMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryGuangxiMap) > 0 {
					envConfMap["presetCanaryGuangxi"] = presetCanaryGuangxiMap
				}
			}

			if presetCanaryGuizhou, ok := envConfArg["preset_canary_guizhou"]; ok {
				presetCanaryGuizhouMap := map[string]interface{}{}
				for _, presetCanaryGuizhouList := range presetCanaryGuizhou.([]interface{}) {
					presetCanaryGuizhouArg := presetCanaryGuizhouList.(map[string]interface{})

					if specName, ok := presetCanaryGuizhouArg["spec_name"]; ok {
						presetCanaryGuizhouMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryGuizhouArg["code_rev"]; ok {
						presetCanaryGuizhouMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryGuizhouArg["allowed_hosts"]; ok {
						presetCanaryGuizhouMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryGuizhouMap) > 0 {
					envConfMap["presetCanaryGuizhou"] = presetCanaryGuizhouMap
				}
			}

			if presetCanaryHainan, ok := envConfArg["preset_canary_hainan"]; ok {
				presetCanaryHainanMap := map[string]interface{}{}
				for _, presetCanaryHainanList := range presetCanaryHainan.([]interface{}) {
					presetCanaryHainanArg := presetCanaryHainanList.(map[string]interface{})

					if specName, ok := presetCanaryHainanArg["spec_name"]; ok {
						presetCanaryHainanMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryHainanArg["code_rev"]; ok {
						presetCanaryHainanMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryHainanArg["allowed_hosts"]; ok {
						presetCanaryHainanMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryHainanMap) > 0 {
					envConfMap["presetCanaryHainan"] = presetCanaryHainanMap
				}
			}

			if presetCanaryHebei, ok := envConfArg["preset_canary_hebei"]; ok {
				presetCanaryHebeiMap := map[string]interface{}{}
				for _, presetCanaryHebeiList := range presetCanaryHebei.([]interface{}) {
					presetCanaryHebeiArg := presetCanaryHebeiList.(map[string]interface{})

					if specName, ok := presetCanaryHebeiArg["spec_name"]; ok {
						presetCanaryHebeiMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryHebeiArg["code_rev"]; ok {
						presetCanaryHebeiMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryHebeiArg["allowed_hosts"]; ok {
						presetCanaryHebeiMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryHebeiMap) > 0 {
					envConfMap["presetCanaryHebei"] = presetCanaryHebeiMap
				}
			}

			if presetCanaryHeilongjiang, ok := envConfArg["preset_canary_heilongjiang"]; ok {
				presetCanaryHeilongjiangMap := map[string]interface{}{}
				for _, presetCanaryHeilongjiangList := range presetCanaryHeilongjiang.([]interface{}) {
					presetCanaryHeilongjiangArg := presetCanaryHeilongjiangList.(map[string]interface{})

					if specName, ok := presetCanaryHeilongjiangArg["spec_name"]; ok {
						presetCanaryHeilongjiangMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryHeilongjiangArg["code_rev"]; ok {
						presetCanaryHeilongjiangMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryHeilongjiangArg["allowed_hosts"]; ok {
						presetCanaryHeilongjiangMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryHeilongjiangMap) > 0 {
					envConfMap["presetCanaryHeilongjiang"] = presetCanaryHeilongjiangMap
				}
			}

			if presetCanaryHenan, ok := envConfArg["preset_canary_henan"]; ok {
				presetCanaryHenanMap := map[string]interface{}{}
				for _, presetCanaryHenanList := range presetCanaryHenan.([]interface{}) {
					presetCanaryHenanArg := presetCanaryHenanList.(map[string]interface{})

					if specName, ok := presetCanaryHenanArg["spec_name"]; ok {
						presetCanaryHenanMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryHenanArg["code_rev"]; ok {
						presetCanaryHenanMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryHenanArg["allowed_hosts"]; ok {
						presetCanaryHenanMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryHenanMap) > 0 {
					envConfMap["presetCanaryHenan"] = presetCanaryHenanMap
				}
			}

			if presetCanaryHongKong, ok := envConfArg["preset_canary_hong_kong"]; ok {
				presetCanaryHongKongMap := map[string]interface{}{}
				for _, presetCanaryHongKongList := range presetCanaryHongKong.([]interface{}) {
					presetCanaryHongKongArg := presetCanaryHongKongList.(map[string]interface{})

					if specName, ok := presetCanaryHongKongArg["spec_name"]; ok {
						presetCanaryHongKongMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryHongKongArg["code_rev"]; ok {
						presetCanaryHongKongMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryHongKongArg["allowed_hosts"]; ok {
						presetCanaryHongKongMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryHongKongMap) > 0 {
					envConfMap["presetCanaryHongKong"] = presetCanaryHongKongMap
				}
			}

			if presetCanaryHubei, ok := envConfArg["preset_canary_hubei"]; ok {
				presetCanaryHubeiMap := map[string]interface{}{}
				for _, presetCanaryHubeiList := range presetCanaryHubei.([]interface{}) {
					presetCanaryHubeiArg := presetCanaryHubeiList.(map[string]interface{})

					if specName, ok := presetCanaryHubeiArg["spec_name"]; ok {
						presetCanaryHubeiMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryHubeiArg["code_rev"]; ok {
						presetCanaryHubeiMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryHubeiArg["allowed_hosts"]; ok {
						presetCanaryHubeiMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryHubeiMap) > 0 {
					envConfMap["presetCanaryHubei"] = presetCanaryHubeiMap
				}
			}

			if presetCanaryHunan, ok := envConfArg["preset_canary_hunan"]; ok {
				presetCanaryHunanMap := map[string]interface{}{}
				for _, presetCanaryHunanList := range presetCanaryHunan.([]interface{}) {
					presetCanaryHunanArg := presetCanaryHunanList.(map[string]interface{})

					if specName, ok := presetCanaryHunanArg["spec_name"]; ok {
						presetCanaryHunanMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryHunanArg["code_rev"]; ok {
						presetCanaryHunanMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryHunanArg["allowed_hosts"]; ok {
						presetCanaryHunanMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryHunanMap) > 0 {
					envConfMap["presetCanaryHunan"] = presetCanaryHunanMap
				}
			}

			if presetCanaryJiangsu, ok := envConfArg["preset_canary_jiangsu"]; ok {
				presetCanaryJiangsuMap := map[string]interface{}{}
				for _, presetCanaryJiangsuList := range presetCanaryJiangsu.([]interface{}) {
					presetCanaryJiangsuArg := presetCanaryJiangsuList.(map[string]interface{})

					if specName, ok := presetCanaryJiangsuArg["spec_name"]; ok {
						presetCanaryJiangsuMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryJiangsuArg["code_rev"]; ok {
						presetCanaryJiangsuMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryJiangsuArg["allowed_hosts"]; ok {
						presetCanaryJiangsuMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryJiangsuMap) > 0 {
					envConfMap["presetCanaryJiangsu"] = presetCanaryJiangsuMap
				}
			}

			if presetCanaryJiangxi, ok := envConfArg["preset_canary_jiangxi"]; ok {
				presetCanaryJiangxiMap := map[string]interface{}{}
				for _, presetCanaryJiangxiList := range presetCanaryJiangxi.([]interface{}) {
					presetCanaryJiangxiArg := presetCanaryJiangxiList.(map[string]interface{})

					if specName, ok := presetCanaryJiangxiArg["spec_name"]; ok {
						presetCanaryJiangxiMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryJiangxiArg["code_rev"]; ok {
						presetCanaryJiangxiMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryJiangxiArg["allowed_hosts"]; ok {
						presetCanaryJiangxiMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryJiangxiMap) > 0 {
					envConfMap["presetCanaryJiangxi"] = presetCanaryJiangxiMap
				}
			}

			if presetCanaryJilin, ok := envConfArg["preset_canary_jilin"]; ok {
				presetCanaryJilinMap := map[string]interface{}{}
				for _, presetCanaryJilinList := range presetCanaryJilin.([]interface{}) {
					presetCanaryJilinArg := presetCanaryJilinList.(map[string]interface{})

					if specName, ok := presetCanaryJilinArg["spec_name"]; ok {
						presetCanaryJilinMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryJilinArg["code_rev"]; ok {
						presetCanaryJilinMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryJilinArg["allowed_hosts"]; ok {
						presetCanaryJilinMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryJilinMap) > 0 {
					envConfMap["presetCanaryJilin"] = presetCanaryJilinMap
				}
			}

			if presetCanaryLiaoning, ok := envConfArg["preset_canary_liaoning"]; ok {
				presetCanaryLiaoningMap := map[string]interface{}{}
				for _, presetCanaryLiaoningList := range presetCanaryLiaoning.([]interface{}) {
					presetCanaryLiaoningArg := presetCanaryLiaoningList.(map[string]interface{})

					if specName, ok := presetCanaryLiaoningArg["spec_name"]; ok {
						presetCanaryLiaoningMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryLiaoningArg["code_rev"]; ok {
						presetCanaryLiaoningMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryLiaoningArg["allowed_hosts"]; ok {
						presetCanaryLiaoningMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryLiaoningMap) > 0 {
					envConfMap["presetCanaryLiaoning"] = presetCanaryLiaoningMap
				}
			}

			if presetCanaryMacau, ok := envConfArg["preset_canary_macau"]; ok {
				presetCanaryMacauMap := map[string]interface{}{}
				for _, presetCanaryMacauList := range presetCanaryMacau.([]interface{}) {
					presetCanaryMacauArg := presetCanaryMacauList.(map[string]interface{})

					if specName, ok := presetCanaryMacauArg["spec_name"]; ok {
						presetCanaryMacauMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryMacauArg["code_rev"]; ok {
						presetCanaryMacauMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryMacauArg["allowed_hosts"]; ok {
						presetCanaryMacauMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryMacauMap) > 0 {
					envConfMap["presetCanaryMacau"] = presetCanaryMacauMap
				}
			}

			if presetCanaryNeimenggu, ok := envConfArg["preset_canary_neimenggu"]; ok {
				presetCanaryNeimengguMap := map[string]interface{}{}
				for _, presetCanaryNeimengguList := range presetCanaryNeimenggu.([]interface{}) {
					presetCanaryNeimengguArg := presetCanaryNeimengguList.(map[string]interface{})

					if specName, ok := presetCanaryNeimengguArg["spec_name"]; ok {
						presetCanaryNeimengguMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryNeimengguArg["code_rev"]; ok {
						presetCanaryNeimengguMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryNeimengguArg["allowed_hosts"]; ok {
						presetCanaryNeimengguMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryNeimengguMap) > 0 {
					envConfMap["presetCanaryNeimenggu"] = presetCanaryNeimengguMap
				}
			}

			if presetCanaryNingxia, ok := envConfArg["preset_canary_ningxia"]; ok {
				presetCanaryNingxiaMap := map[string]interface{}{}
				for _, presetCanaryNingxiaList := range presetCanaryNingxia.([]interface{}) {
					presetCanaryNingxiaArg := presetCanaryNingxiaList.(map[string]interface{})

					if specName, ok := presetCanaryNingxiaArg["spec_name"]; ok {
						presetCanaryNingxiaMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryNingxiaArg["code_rev"]; ok {
						presetCanaryNingxiaMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryNingxiaArg["allowed_hosts"]; ok {
						presetCanaryNingxiaMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryNingxiaMap) > 0 {
					envConfMap["presetCanaryNingxia"] = presetCanaryNingxiaMap
				}
			}

			if presetCanaryQinghai, ok := envConfArg["preset_canary_qinghai"]; ok {
				presetCanaryQinghaiMap := map[string]interface{}{}
				for _, presetCanaryQinghaiList := range presetCanaryQinghai.([]interface{}) {
					presetCanaryQinghaiArg := presetCanaryQinghaiList.(map[string]interface{})

					if specName, ok := presetCanaryQinghaiArg["spec_name"]; ok {
						presetCanaryQinghaiMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryQinghaiArg["code_rev"]; ok {
						presetCanaryQinghaiMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryQinghaiArg["allowed_hosts"]; ok {
						presetCanaryQinghaiMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryQinghaiMap) > 0 {
					envConfMap["presetCanaryQinghai"] = presetCanaryQinghaiMap
				}
			}

			if presetCanaryShaanxi, ok := envConfArg["preset_canary_shaanxi"]; ok {
				presetCanaryShaanxiMap := map[string]interface{}{}
				for _, presetCanaryShaanxiList := range presetCanaryShaanxi.([]interface{}) {
					presetCanaryShaanxiArg := presetCanaryShaanxiList.(map[string]interface{})

					if specName, ok := presetCanaryShaanxiArg["spec_name"]; ok {
						presetCanaryShaanxiMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryShaanxiArg["code_rev"]; ok {
						presetCanaryShaanxiMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryShaanxiArg["allowed_hosts"]; ok {
						presetCanaryShaanxiMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryShaanxiMap) > 0 {
					envConfMap["presetCanaryShaanxi"] = presetCanaryShaanxiMap
				}
			}

			if presetCanaryShandong, ok := envConfArg["preset_canary_shandong"]; ok {
				presetCanaryShandongMap := map[string]interface{}{}
				for _, presetCanaryShandongList := range presetCanaryShandong.([]interface{}) {
					presetCanaryShandongArg := presetCanaryShandongList.(map[string]interface{})

					if specName, ok := presetCanaryShandongArg["spec_name"]; ok {
						presetCanaryShandongMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryShandongArg["code_rev"]; ok {
						presetCanaryShandongMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryShandongArg["allowed_hosts"]; ok {
						presetCanaryShandongMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryShandongMap) > 0 {
					envConfMap["presetCanaryShandong"] = presetCanaryShandongMap
				}
			}

			if presetCanaryShanghai, ok := envConfArg["preset_canary_shanghai"]; ok {
				presetCanaryShanghaiMap := map[string]interface{}{}
				for _, presetCanaryShanghaiList := range presetCanaryShanghai.([]interface{}) {
					presetCanaryShanghaiArg := presetCanaryShanghaiList.(map[string]interface{})

					if specName, ok := presetCanaryShanghaiArg["spec_name"]; ok {
						presetCanaryShanghaiMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryShanghaiArg["code_rev"]; ok {
						presetCanaryShanghaiMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryShanghaiArg["allowed_hosts"]; ok {
						presetCanaryShanghaiMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryShanghaiMap) > 0 {
					envConfMap["presetCanaryShanghai"] = presetCanaryShanghaiMap
				}
			}

			if presetCanaryShanxi, ok := envConfArg["preset_canary_shanxi"]; ok {
				presetCanaryShanxiMap := map[string]interface{}{}
				for _, presetCanaryShanxiList := range presetCanaryShanxi.([]interface{}) {
					presetCanaryShanxiArg := presetCanaryShanxiList.(map[string]interface{})

					if specName, ok := presetCanaryShanxiArg["spec_name"]; ok {
						presetCanaryShanxiMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryShanxiArg["code_rev"]; ok {
						presetCanaryShanxiMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryShanxiArg["allowed_hosts"]; ok {
						presetCanaryShanxiMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryShanxiMap) > 0 {
					envConfMap["presetCanaryShanxi"] = presetCanaryShanxiMap
				}
			}

			if presetCanarySichuan, ok := envConfArg["preset_canary_sichuan"]; ok {
				presetCanarySichuanMap := map[string]interface{}{}
				for _, presetCanarySichuanList := range presetCanarySichuan.([]interface{}) {
					presetCanarySichuanArg := presetCanarySichuanList.(map[string]interface{})

					if specName, ok := presetCanarySichuanArg["spec_name"]; ok {
						presetCanarySichuanMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanarySichuanArg["code_rev"]; ok {
						presetCanarySichuanMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanarySichuanArg["allowed_hosts"]; ok {
						presetCanarySichuanMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanarySichuanMap) > 0 {
					envConfMap["presetCanarySichuan"] = presetCanarySichuanMap
				}
			}

			if presetCanaryTaiwan, ok := envConfArg["preset_canary_taiwan"]; ok {
				presetCanaryTaiwanMap := map[string]interface{}{}
				for _, presetCanaryTaiwanList := range presetCanaryTaiwan.([]interface{}) {
					presetCanaryTaiwanArg := presetCanaryTaiwanList.(map[string]interface{})

					if specName, ok := presetCanaryTaiwanArg["spec_name"]; ok {
						presetCanaryTaiwanMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryTaiwanArg["code_rev"]; ok {
						presetCanaryTaiwanMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryTaiwanArg["allowed_hosts"]; ok {
						presetCanaryTaiwanMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryTaiwanMap) > 0 {
					envConfMap["presetCanaryTaiwan"] = presetCanaryTaiwanMap
				}
			}

			if presetCanaryTianjin, ok := envConfArg["preset_canary_tianjin"]; ok {
				presetCanaryTianjinMap := map[string]interface{}{}
				for _, presetCanaryTianjinList := range presetCanaryTianjin.([]interface{}) {
					presetCanaryTianjinArg := presetCanaryTianjinList.(map[string]interface{})

					if specName, ok := presetCanaryTianjinArg["spec_name"]; ok {
						presetCanaryTianjinMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryTianjinArg["code_rev"]; ok {
						presetCanaryTianjinMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryTianjinArg["allowed_hosts"]; ok {
						presetCanaryTianjinMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryTianjinMap) > 0 {
					envConfMap["presetCanaryTianjin"] = presetCanaryTianjinMap
				}
			}

			if presetCanaryXinjiang, ok := envConfArg["preset_canary_xinjiang"]; ok {
				presetCanaryXinjiangMap := map[string]interface{}{}
				for _, presetCanaryXinjiangList := range presetCanaryXinjiang.([]interface{}) {
					presetCanaryXinjiangArg := presetCanaryXinjiangList.(map[string]interface{})

					if specName, ok := presetCanaryXinjiangArg["spec_name"]; ok {
						presetCanaryXinjiangMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryXinjiangArg["code_rev"]; ok {
						presetCanaryXinjiangMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryXinjiangArg["allowed_hosts"]; ok {
						presetCanaryXinjiangMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryXinjiangMap) > 0 {
					envConfMap["presetCanaryXinjiang"] = presetCanaryXinjiangMap
				}
			}

			if presetCanaryXizang, ok := envConfArg["preset_canary_xizang"]; ok {
				presetCanaryXizangMap := map[string]interface{}{}
				for _, presetCanaryXizangList := range presetCanaryXizang.([]interface{}) {
					presetCanaryXizangArg := presetCanaryXizangList.(map[string]interface{})

					if specName, ok := presetCanaryXizangArg["spec_name"]; ok {
						presetCanaryXizangMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryXizangArg["code_rev"]; ok {
						presetCanaryXizangMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryXizangArg["allowed_hosts"]; ok {
						presetCanaryXizangMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryXizangMap) > 0 {
					envConfMap["presetCanaryXizang"] = presetCanaryXizangMap
				}
			}

			if presetCanaryYunnan, ok := envConfArg["preset_canary_yunnan"]; ok {
				presetCanaryYunnanMap := map[string]interface{}{}
				for _, presetCanaryYunnanList := range presetCanaryYunnan.([]interface{}) {
					presetCanaryYunnanArg := presetCanaryYunnanList.(map[string]interface{})

					if specName, ok := presetCanaryYunnanArg["spec_name"]; ok {
						presetCanaryYunnanMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryYunnanArg["code_rev"]; ok {
						presetCanaryYunnanMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryYunnanArg["allowed_hosts"]; ok {
						presetCanaryYunnanMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryYunnanMap) > 0 {
					envConfMap["presetCanaryYunnan"] = presetCanaryYunnanMap
				}
			}

			if presetCanaryZhejiang, ok := envConfArg["preset_canary_zhejiang"]; ok {
				presetCanaryZhejiangMap := map[string]interface{}{}
				for _, presetCanaryZhejiangList := range presetCanaryZhejiang.([]interface{}) {
					presetCanaryZhejiangArg := presetCanaryZhejiangList.(map[string]interface{})

					if specName, ok := presetCanaryZhejiangArg["spec_name"]; ok {
						presetCanaryZhejiangMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryZhejiangArg["code_rev"]; ok {
						presetCanaryZhejiangMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryZhejiangArg["allowed_hosts"]; ok {
						presetCanaryZhejiangMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryZhejiangMap) > 0 {
					envConfMap["presetCanaryZhejiang"] = presetCanaryZhejiangMap
				}
			}

			if presetCanaryOverseas, ok := envConfArg["preset_canary_overseas"]; ok {
				presetCanaryOverseasMap := map[string]interface{}{}
				for _, presetCanaryOverseasList := range presetCanaryOverseas.([]interface{}) {
					presetCanaryOverseasArg := presetCanaryOverseasList.(map[string]interface{})

					if specName, ok := presetCanaryOverseasArg["spec_name"]; ok {
						presetCanaryOverseasMap["SpecName"] = specName
					}

					if codeRev, ok := presetCanaryOverseasArg["code_rev"]; ok {
						presetCanaryOverseasMap["CodeRev"] = codeRev
					}

					if allowedHosts, ok := presetCanaryOverseasArg["allowed_hosts"]; ok {
						presetCanaryOverseasMap["AllowedHosts"] = allowedHosts
					}
				}

				if len(presetCanaryOverseasMap) > 0 {
					envConfMap["presetCanaryOverseas"] = presetCanaryOverseasMap
				}
			}
		}

		envConfJson, err := convertMaptoJsonString(envConfMap)
		if err != nil {
			return WrapError(err)
		}

		request["EnvConf"] = envConfJson
	}

	if update {
		action := "EditRoutineConf"
		wait := incrementalWait(3*time.Second, 3*time.Second)
		err = resource.Retry(client.GetRetryTimeout(d.Timeout(schema.TimeoutUpdate)), func() *resource.RetryError {
			response, err = client.RpcPost("dcdn", "2018-01-15", action, nil, request, false)
			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)
		}
	}

	return resourceAliCloudDcdnErRead(d, meta)
}