in alicloud/resource_alicloud_sae_application.go [1494:2151]
func resourceAliCloudSaeApplicationRead(d *schema.ResourceData, meta interface{}) error {
client := meta.(*connectivity.AliyunClient)
saeService := SaeService{client}
object, err := saeService.DescribeSaeApplication(d.Id())
if err != nil {
if !d.IsNewResource() && NotFoundError(err) {
log.Printf("[DEBUG] Resource alicloud_sae_application saeService.DescribeSaeApplication Failed!!! %s", err)
d.SetId("")
return nil
}
return WrapError(err)
}
d.Set("app_name", object["AppName"])
d.Set("package_type", object["PackageType"])
d.Set("namespace_id", object["NamespaceId"])
d.Set("vpc_id", object["VpcId"])
d.Set("vswitch_id", object["VSwitchId"])
d.Set("package_version", object["PackageVersion"])
d.Set("package_url", object["PackageUrl"])
d.Set("image_url", object["ImageUrl"])
d.Set("command", object["Command"])
d.Set("web_container", object["WebContainer"])
d.Set("jdk", object["Jdk"])
d.Set("jar_start_options", object["JarStartOptions"])
d.Set("jar_start_args", object["JarStartArgs"])
d.Set("app_description", object["AppDescription"])
d.Set("batch_wait_time", object["BatchWaitTime"])
d.Set("edas_container_version", object["EdasContainerVersion"])
d.Set("enable_ahas", fmt.Sprint(object["EnableAhas"]))
d.Set("enable_grey_tag_route", object["EnableGreyTagRoute"])
d.Set("oss_ak_id", object["OssAkId"])
d.Set("oss_ak_secret", object["OssAkSecret"])
d.Set("php_arms_config_location", object["PhpArmsConfigLocation"])
d.Set("php_config", object["PhpConfig"])
d.Set("php_config_location", object["PhpConfigLocation"])
d.Set("security_group_id", object["SecurityGroupId"])
d.Set("timezone", object["Timezone"])
d.Set("war_start_options", object["WarStartOptions"])
d.Set("acr_instance_id", object["AcrInstanceId"])
d.Set("acr_assume_role_arn", object["AcrAssumeRoleArn"])
d.Set("micro_registration", object["MicroRegistration"])
d.Set("php", object["Php"])
d.Set("image_pull_secrets", object["ImagePullSecrets"])
d.Set("programming_language", object["ProgrammingLanguage"])
d.Set("command_args", object["CommandArgs"])
d.Set("envs", object["Envs"])
d.Set("custom_host_alias", object["CustomHostAlias"])
d.Set("liveness", object["Liveness"])
d.Set("readiness", object["Readiness"])
d.Set("post_start", object["PostStart"])
d.Set("pre_stop", object["PreStop"])
d.Set("sls_configs", object["SlsConfigs"])
d.Set("tomcat_config", object["TomcatConfig"])
d.Set("update_strategy", object["UpdateStrategy"])
if v, ok := object["Replicas"]; ok && fmt.Sprint(v) != "0" {
d.Set("replicas", formatInt(v))
}
if v, ok := object["Cpu"]; ok && fmt.Sprint(v) != "0" {
d.Set("cpu", formatInt(v))
}
if v, ok := object["Memory"]; ok && fmt.Sprint(v) != "0" {
d.Set("memory", formatInt(v))
}
if v, ok := object["MinReadyInstances"]; ok && fmt.Sprint(v) != "0" {
d.Set("min_ready_instances", formatInt(v))
}
if v, ok := object["MinReadyInstanceRatio"]; ok && fmt.Sprint(v) != "0" {
d.Set("min_ready_instance_ratio", formatInt(v))
}
if v, ok := object["TerminationGracePeriodSeconds"]; ok && fmt.Sprint(v) != "0" {
d.Set("termination_grace_period_seconds", formatInt(v))
}
if v, ok := object["OssMountDescs"].([]interface{}); ok {
ossMountDescs, err := convertListObjectToCommaSeparate(v)
if err != nil {
return WrapError(err)
}
d.Set("oss_mount_descs", ossMountDescs)
}
if configMapMountDescList, ok := object["ConfigMapMountDesc"]; ok {
configMapMountDescMaps := make([]map[string]interface{}, 0)
for _, configMapMountDesc := range configMapMountDescList.([]interface{}) {
configMapMountDescArg := configMapMountDesc.(map[string]interface{})
configMapMountDescMap := map[string]interface{}{}
if configMapId, ok := configMapMountDescArg["ConfigMapId"]; ok {
configMapMountDescMap["configMapId"] = configMapId
}
if key, ok := configMapMountDescArg["Key"]; ok {
configMapMountDescMap["key"] = key
}
if mountPath, ok := configMapMountDescArg["MountPath"]; ok {
configMapMountDescMap["mountPath"] = mountPath
}
configMapMountDescMaps = append(configMapMountDescMaps, configMapMountDescMap)
}
configMapMountDescJson, err := convertListMapToJsonString(configMapMountDescMaps)
if err != nil {
return WrapError(err)
}
d.Set("config_map_mount_desc", configMapMountDescJson)
}
if v, ok := object["CommandArgs"].(string); ok && v != "" {
commandArgsList, err := convertJsonStringToList(v)
if err != nil {
return WrapError(err)
}
d.Set("command_args_v2", commandArgsList)
} else {
d.Set("command_args_v2", nil)
}
if v, ok := object["CustomHostAlias"].(string); ok {
customHostAliasList, err := convertJsonStringToList(v)
if err != nil {
return WrapError(err)
}
customHostAliasMaps := make([]map[string]interface{}, 0)
for _, customHostAlias := range customHostAliasList {
customHostAliasArg := customHostAlias.(map[string]interface{})
customHostAliasMap := map[string]interface{}{}
if hostName, ok := customHostAliasArg["hostName"]; ok {
customHostAliasMap["host_name"] = hostName
}
if ip, ok := customHostAliasArg["ip"]; ok {
customHostAliasMap["ip"] = ip
}
customHostAliasMaps = append(customHostAliasMaps, customHostAliasMap)
}
d.Set("custom_host_alias_v2", customHostAliasMaps)
}
if ossMountDescsList, ok := object["OssMountDescs"]; ok {
ossMountDescsMaps := make([]map[string]interface{}, 0)
for _, ossMountDescs := range ossMountDescsList.([]interface{}) {
ossMountDescsArg := ossMountDescs.(map[string]interface{})
ossMountDescsMap := map[string]interface{}{}
if bucketName, ok := ossMountDescsArg["bucketName"]; ok {
ossMountDescsMap["bucket_name"] = bucketName
}
if bucketPath, ok := ossMountDescsArg["bucketPath"]; ok {
ossMountDescsMap["bucket_path"] = bucketPath
}
if mountPath, ok := ossMountDescsArg["mountPath"]; ok {
ossMountDescsMap["mount_path"] = mountPath
}
if readOnly, ok := ossMountDescsArg["readOnly"]; ok {
ossMountDescsMap["read_only"] = readOnly
}
ossMountDescsMaps = append(ossMountDescsMaps, ossMountDescsMap)
}
d.Set("oss_mount_descs_v2", ossMountDescsMaps)
}
if configMapMountDescList, ok := object["ConfigMapMountDesc"]; ok {
configMapMountDescMaps := make([]map[string]interface{}, 0)
for _, configMapMountDesc := range configMapMountDescList.([]interface{}) {
configMapMountDescArg := configMapMountDesc.(map[string]interface{})
configMapMountDescMap := map[string]interface{}{}
if configMapId, ok := configMapMountDescArg["ConfigMapId"]; ok {
configMapMountDescMap["config_map_id"] = configMapId
}
if mountPath, ok := configMapMountDescArg["MountPath"]; ok {
configMapMountDescMap["mount_path"] = mountPath
}
if key, ok := configMapMountDescArg["Key"]; ok {
configMapMountDescMap["key"] = key
}
configMapMountDescMaps = append(configMapMountDescMaps, configMapMountDescMap)
}
d.Set("config_map_mount_desc_v2", configMapMountDescMaps)
}
if v, ok := object["Liveness"].(string); ok && v != "" {
livenessArg, err := convertJsonStringToMap(v)
if err != nil {
return WrapError(err)
}
livenessMaps := make([]map[string]interface{}, 0)
livenessMap := map[string]interface{}{}
if initialDelaySeconds, ok := livenessArg["initialDelaySeconds"]; ok {
livenessMap["initial_delay_seconds"] = initialDelaySeconds
}
if periodSeconds, ok := livenessArg["periodSeconds"]; ok {
livenessMap["period_seconds"] = periodSeconds
}
if timeoutSeconds, ok := livenessArg["timeoutSeconds"]; ok {
livenessMap["timeout_seconds"] = timeoutSeconds
}
if exec, ok := livenessArg["exec"]; ok {
execMaps := make([]map[string]interface{}, 0)
execArg := exec.(map[string]interface{})
execMap := map[string]interface{}{}
if command, ok := execArg["command"]; ok {
execMap["command"] = command
}
execMaps = append(execMaps, execMap)
livenessMap["exec"] = execMaps
}
if tcpSocket, ok := livenessArg["tcpSocket"]; ok {
tcpSocketMaps := make([]map[string]interface{}, 0)
tcpSocketArg := tcpSocket.(map[string]interface{})
tcpSocketMap := map[string]interface{}{}
if port, ok := tcpSocketArg["port"]; ok {
tcpSocketMap["port"] = port
}
tcpSocketMaps = append(tcpSocketMaps, tcpSocketMap)
livenessMap["tcp_socket"] = tcpSocketMaps
}
if httpGet, ok := livenessArg["httpGet"]; ok {
httpGetMaps := make([]map[string]interface{}, 0)
httpGetArg := httpGet.(map[string]interface{})
httpGetMap := map[string]interface{}{}
if path, ok := httpGetArg["path"]; ok {
httpGetMap["path"] = path
}
if port, ok := httpGetArg["port"]; ok {
httpGetMap["port"] = port
}
if scheme, ok := httpGetArg["scheme"]; ok {
httpGetMap["scheme"] = scheme
}
if keyWord, ok := httpGetArg["keyWord"]; ok {
httpGetMap["key_word"] = keyWord
}
if isContainKeyWord, ok := httpGetArg["isContainKeyWord"]; ok {
httpGetMap["is_contain_key_word"] = isContainKeyWord
} else {
httpGetMap["is_contain_key_word"] = nil
}
httpGetMaps = append(httpGetMaps, httpGetMap)
livenessMap["http_get"] = httpGetMaps
}
livenessMaps = append(livenessMaps, livenessMap)
d.Set("liveness_v2", livenessMaps)
}
if v, ok := object["Readiness"].(string); ok && v != "" {
readinessArg, err := convertJsonStringToMap(v)
if err != nil {
return WrapError(err)
}
readinessMaps := make([]map[string]interface{}, 0)
readinessMap := map[string]interface{}{}
if initialDelaySeconds, ok := readinessArg["initialDelaySeconds"]; ok {
readinessMap["initial_delay_seconds"] = initialDelaySeconds
}
if periodSeconds, ok := readinessArg["periodSeconds"]; ok {
readinessMap["period_seconds"] = periodSeconds
}
if timeoutSeconds, ok := readinessArg["timeoutSeconds"]; ok {
readinessMap["timeout_seconds"] = timeoutSeconds
}
if exec, ok := readinessArg["exec"]; ok {
execMaps := make([]map[string]interface{}, 0)
execArg := exec.(map[string]interface{})
execMap := map[string]interface{}{}
if command, ok := execArg["command"]; ok {
execMap["command"] = command
}
execMaps = append(execMaps, execMap)
readinessMap["exec"] = execMaps
}
if tcpSocket, ok := readinessArg["tcpSocket"]; ok {
tcpSocketMaps := make([]map[string]interface{}, 0)
tcpSocketArg := tcpSocket.(map[string]interface{})
tcpSocketMap := map[string]interface{}{}
if port, ok := tcpSocketArg["port"]; ok {
tcpSocketMap["port"] = port
}
tcpSocketMaps = append(tcpSocketMaps, tcpSocketMap)
readinessMap["tcp_socket"] = tcpSocketMaps
}
if httpGet, ok := readinessArg["httpGet"]; ok {
httpGetMaps := make([]map[string]interface{}, 0)
httpGetArg := httpGet.(map[string]interface{})
httpGetMap := map[string]interface{}{}
if path, ok := httpGetArg["path"]; ok {
httpGetMap["path"] = path
}
if port, ok := httpGetArg["port"]; ok {
httpGetMap["port"] = port
}
if scheme, ok := httpGetArg["scheme"]; ok {
httpGetMap["scheme"] = scheme
}
if keyWord, ok := httpGetArg["keyWord"]; ok {
httpGetMap["key_word"] = keyWord
}
if isContainKeyWord, ok := httpGetArg["isContainKeyWord"]; ok {
httpGetMap["is_contain_key_word"] = isContainKeyWord
} else {
httpGetMap["is_contain_key_word"] = nil
}
httpGetMaps = append(httpGetMaps, httpGetMap)
readinessMap["http_get"] = httpGetMaps
}
readinessMaps = append(readinessMaps, readinessMap)
d.Set("readiness_v2", readinessMaps)
}
if v, ok := object["PostStart"].(string); ok && v != "" {
postStartArg, err := convertJsonStringToMap(v)
if err != nil {
return WrapError(err)
}
postStartMaps := make([]map[string]interface{}, 0)
postStartMap := map[string]interface{}{}
if exec, ok := postStartArg["exec"]; ok {
execMaps := make([]map[string]interface{}, 0)
execArg := exec.(map[string]interface{})
execMap := map[string]interface{}{}
if command, ok := execArg["command"]; ok {
execMap["command"] = command
}
execMaps = append(execMaps, execMap)
postStartMap["exec"] = execMaps
}
postStartMaps = append(postStartMaps, postStartMap)
d.Set("post_start_v2", postStartMaps)
}
if v, ok := object["PreStop"].(string); ok && v != "" {
preStopArg, err := convertJsonStringToMap(v)
if err != nil {
return WrapError(err)
}
preStopMaps := make([]map[string]interface{}, 0)
preStopMap := map[string]interface{}{}
if exec, ok := preStopArg["exec"]; ok {
execMaps := make([]map[string]interface{}, 0)
execArg := exec.(map[string]interface{})
execMap := map[string]interface{}{}
if command, ok := execArg["command"]; ok {
execMap["command"] = command
}
execMaps = append(execMaps, execMap)
preStopMap["exec"] = execMaps
}
preStopMaps = append(preStopMaps, preStopMap)
d.Set("pre_stop_v2", preStopMaps)
}
if v, ok := object["TomcatConfig"].(string); ok && v != "" {
tomcatConfigArg, err := convertJsonStringToMap(v)
if err != nil {
return WrapError(err)
}
tomcatConfigMaps := make([]map[string]interface{}, 0)
tomcatConfigMap := map[string]interface{}{}
if port, ok := tomcatConfigArg["port"]; ok {
tomcatConfigMap["port"] = port
}
if maxThreads, ok := tomcatConfigArg["maxThreads"]; ok {
tomcatConfigMap["max_threads"] = maxThreads
}
if contextPath, ok := tomcatConfigArg["contextPath"]; ok {
tomcatConfigMap["context_path"] = contextPath
}
if uriEncoding, ok := tomcatConfigArg["uriEncoding"]; ok {
tomcatConfigMap["uri_encoding"] = uriEncoding
}
if useBodyEncodingForUri, ok := tomcatConfigArg["useBodyEncodingForUri"]; ok {
tomcatConfigMap["use_body_encoding_for_uri"] = useBodyEncodingForUri
}
tomcatConfigMaps = append(tomcatConfigMaps, tomcatConfigMap)
d.Set("tomcat_config_v2", tomcatConfigMaps)
}
if v, ok := object["UpdateStrategy"].(string); ok && v != "" {
updateStrategyArg, err := convertJsonStringToMap(v)
if err != nil {
return WrapError(err)
}
updateStrategyMaps := make([]map[string]interface{}, 0)
updateStrategyMap := map[string]interface{}{}
if updateStrategyType, ok := updateStrategyArg["type"]; ok {
updateStrategyMap["type"] = updateStrategyType
}
if batchUpdate, ok := updateStrategyArg["batchUpdate"]; ok {
batchUpdateMaps := make([]map[string]interface{}, 0)
batchUpdateArg := batchUpdate.(map[string]interface{})
batchUpdateMap := map[string]interface{}{}
if releaseType, ok := batchUpdateArg["releaseType"]; ok {
batchUpdateMap["release_type"] = releaseType
}
if batch, ok := batchUpdateArg["batch"]; ok {
batchUpdateMap["batch"] = batch
}
if batchWaitTime, ok := batchUpdateArg["batchWaitTime"]; ok {
batchUpdateMap["batch_wait_time"] = batchWaitTime
}
batchUpdateMaps = append(batchUpdateMaps, batchUpdateMap)
updateStrategyMap["batch_update"] = batchUpdateMaps
}
updateStrategyMaps = append(updateStrategyMaps, updateStrategyMap)
d.Set("update_strategy_v2", updateStrategyMaps)
}
if v, ok := object["NasConfigs"].(string); ok {
nasConfigsList, err := convertJsonStringToList(v)
if err != nil {
return WrapError(err)
}
nasConfigsMaps := make([]map[string]interface{}, 0)
for _, nasConfigs := range nasConfigsList {
nasConfigsArg := nasConfigs.(map[string]interface{})
nasConfigsMap := map[string]interface{}{}
if nasId, ok := nasConfigsArg["nasId"]; ok {
nasConfigsMap["nas_id"] = nasId
}
if nasPath, ok := nasConfigsArg["nasPath"]; ok {
nasConfigsMap["nas_path"] = nasPath
}
if mountPath, ok := nasConfigsArg["mountPath"]; ok {
nasConfigsMap["mount_path"] = mountPath
}
if mountDomain, ok := nasConfigsArg["mountDomain"]; ok {
nasConfigsMap["mount_domain"] = mountDomain
}
if readOnly, ok := nasConfigsArg["readOnly"]; ok {
nasConfigsMap["read_only"] = readOnly
}
nasConfigsMaps = append(nasConfigsMaps, nasConfigsMap)
}
d.Set("nas_configs", nasConfigsMaps)
}
if v, ok := object["KafkaConfigs"].(string); ok && v != "" {
kafkaConfigsArg, err := convertJsonStringToMap(v)
if err != nil {
return WrapError(err)
}
kafkaConfigsMaps := make([]map[string]interface{}, 0)
kafkaConfigsMap := map[string]interface{}{}
if kafkaInstanceId, ok := kafkaConfigsArg["kafkaInstanceId"]; ok {
kafkaConfigsMap["kafka_instance_id"] = kafkaInstanceId
}
if kafkaEndpoint, ok := kafkaConfigsArg["kafkaEndpoint"]; ok {
kafkaConfigsMap["kafka_endpoint"] = kafkaEndpoint
}
if kafkaConfigsValue, ok := kafkaConfigsArg["kafkaConfigs"]; ok {
kafkaConfigsValueMaps := make([]map[string]interface{}, 0)
for _, kafkaConfigsValueList := range kafkaConfigsValue.([]interface{}) {
kafkaConfigsValueArg := kafkaConfigsValueList.(map[string]interface{})
kafkaConfigsValueMap := map[string]interface{}{}
if logType, ok := kafkaConfigsValueArg["logType"]; ok {
kafkaConfigsValueMap["log_type"] = logType
}
if logDir, ok := kafkaConfigsValueArg["logDir"]; ok {
kafkaConfigsValueMap["log_dir"] = logDir
}
if kafkaTopic, ok := kafkaConfigsValueArg["kafkaTopic"]; ok {
kafkaConfigsValueMap["kafka_topic"] = kafkaTopic
}
kafkaConfigsValueMaps = append(kafkaConfigsValueMaps, kafkaConfigsValueMap)
}
kafkaConfigsMap["kafka_configs"] = kafkaConfigsValueMaps
}
kafkaConfigsMaps = append(kafkaConfigsMaps, kafkaConfigsMap)
d.Set("kafka_configs", kafkaConfigsMaps)
}
if v, ok := object["PvtzDiscovery"].(string); ok && v != "" {
pvtzDiscoveryArg, err := convertJsonStringToMap(v)
if err != nil {
return WrapError(err)
}
pvtzDiscoveryMaps := make([]map[string]interface{}, 0)
pvtzDiscoveryMap := map[string]interface{}{}
if serviceName, ok := pvtzDiscoveryArg["serviceName"]; ok {
pvtzDiscoveryMap["service_name"] = serviceName
}
if namespaceId, ok := pvtzDiscoveryArg["namespaceId"]; ok {
pvtzDiscoveryMap["namespace_id"] = namespaceId
}
if enable, ok := pvtzDiscoveryArg["enable"]; ok {
enableBool, err := strconv.ParseBool(fmt.Sprint(enable))
if err != nil {
return WrapError(err)
}
pvtzDiscoveryMap["enable"] = enableBool
}
if portProtocols, ok := pvtzDiscoveryArg["portProtocols"]; ok {
portProtocolsMaps := make([]map[string]interface{}, 0)
for _, portProtocolsList := range portProtocols.([]interface{}) {
portProtocolsArg := portProtocolsList.(map[string]interface{})
portProtocolsMap := map[string]interface{}{}
if port, ok := portProtocolsArg["port"]; ok {
portProtocolsMap["port"] = port
}
if protocol, ok := portProtocolsArg["protocol"]; ok {
portProtocolsMap["protocol"] = protocol
}
portProtocolsMaps = append(portProtocolsMaps, portProtocolsMap)
}
pvtzDiscoveryMap["port_protocols"] = portProtocolsMaps
}
pvtzDiscoveryMaps = append(pvtzDiscoveryMaps, pvtzDiscoveryMap)
d.Set("pvtz_discovery_svc", pvtzDiscoveryMaps)
}
listTagResourcesObject, err := saeService.ListTagResources(d.Id(), "application")
if err != nil {
return WrapError(err)
}
d.Set("tags", tagsToMap(listTagResourcesObject))
describeApplicationStatusObject, err := saeService.DescribeApplicationStatus(d.Id())
if err != nil {
return WrapError(err)
}
d.Set("status", describeApplicationStatusObject["CurrentStatus"])
return nil
}