| // Copyright (c) HashiCorp, Inc. |
| // SPDX-License-Identifier: MPL-2.0 |
| |
| // ---------------------------------------------------------------------------- |
| // |
| // *** AUTO GENERATED CODE *** Type: MMv1 *** |
| // |
| // ---------------------------------------------------------------------------- |
| // |
| // This file is automatically generated by Magic Modules and manual |
| // changes will be clobbered when the file is regenerated. |
| // |
| // Please read more about how to change this file in |
| // .github/CONTRIBUTING.md. |
| // |
| // ---------------------------------------------------------------------------- |
| |
| package edgecontainer |
| |
| import ( |
| "fmt" |
| "log" |
| "net/http" |
| "reflect" |
| "strings" |
| "time" |
| |
| "github.com/hashicorp/terraform-plugin-sdk/v2/helper/customdiff" |
| "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" |
| |
| "github.com/hashicorp/terraform-provider-google-beta/google-beta/tpgresource" |
| transport_tpg "github.com/hashicorp/terraform-provider-google-beta/google-beta/transport" |
| "github.com/hashicorp/terraform-provider-google-beta/google-beta/verify" |
| ) |
| |
| func ResourceEdgecontainerCluster() *schema.Resource { |
| return &schema.Resource{ |
| Create: resourceEdgecontainerClusterCreate, |
| Read: resourceEdgecontainerClusterRead, |
| Update: resourceEdgecontainerClusterUpdate, |
| Delete: resourceEdgecontainerClusterDelete, |
| |
| Importer: &schema.ResourceImporter{ |
| State: resourceEdgecontainerClusterImport, |
| }, |
| |
| Timeouts: &schema.ResourceTimeout{ |
| Create: schema.DefaultTimeout(480 * time.Minute), |
| Update: schema.DefaultTimeout(480 * time.Minute), |
| Delete: schema.DefaultTimeout(480 * time.Minute), |
| }, |
| |
| CustomizeDiff: customdiff.All( |
| tpgresource.SetLabelsDiff, |
| tpgresource.DefaultProviderProject, |
| ), |
| |
| Schema: map[string]*schema.Schema{ |
| "authorization": { |
| Type: schema.TypeList, |
| Required: true, |
| ForceNew: true, |
| Description: `RBAC policy that will be applied and managed by GEC.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "admin_users": { |
| Type: schema.TypeList, |
| Required: true, |
| Description: `User that will be granted the cluster-admin role on the cluster, providing |
| full access to the cluster. Currently, this is a singular field, but will |
| be expanded to allow multiple admins in the future.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "username": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `An active Google username.`, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| "fleet": { |
| Type: schema.TypeList, |
| Required: true, |
| ForceNew: true, |
| Description: `Fleet related configuration. |
| Fleets are a Google Cloud concept for logically organizing clusters, |
| letting you use and manage multi-cluster capabilities and apply |
| consistent policies across your systems.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "project": { |
| Type: schema.TypeString, |
| Required: true, |
| ForceNew: true, |
| Description: `The name of the Fleet host project where this cluster will be registered. |
| Project names are formatted as |
| 'projects/<project-number>'.`, |
| }, |
| "membership": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The name of the managed Hub Membership resource associated to this cluster. |
| Membership names are formatted as |
| 'projects/<project-number>/locations/global/membership/<cluster-id>'.`, |
| }, |
| }, |
| }, |
| }, |
| "location": { |
| Type: schema.TypeString, |
| Required: true, |
| ForceNew: true, |
| Description: `The location of the resource.`, |
| }, |
| "name": { |
| Type: schema.TypeString, |
| Required: true, |
| ForceNew: true, |
| Description: `The GDCE cluster name.`, |
| }, |
| "networking": { |
| Type: schema.TypeList, |
| Required: true, |
| Description: `Fleet related configuration. |
| Fleets are a Google Cloud concept for logically organizing clusters, |
| letting you use and manage multi-cluster capabilities and apply |
| consistent policies across your systems.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "cluster_ipv4_cidr_blocks": { |
| Type: schema.TypeList, |
| Required: true, |
| ForceNew: true, |
| Description: `All pods in the cluster are assigned an RFC1918 IPv4 address from these |
| blocks. Only a single block is supported. This field cannot be changed |
| after creation.`, |
| Elem: &schema.Schema{ |
| Type: schema.TypeString, |
| }, |
| }, |
| "services_ipv4_cidr_blocks": { |
| Type: schema.TypeList, |
| Required: true, |
| ForceNew: true, |
| Description: `All services in the cluster are assigned an RFC1918 IPv4 address from these |
| blocks. Only a single block is supported. This field cannot be changed |
| after creation.`, |
| Elem: &schema.Schema{ |
| Type: schema.TypeString, |
| }, |
| }, |
| "cluster_ipv6_cidr_blocks": { |
| Type: schema.TypeList, |
| Optional: true, |
| ForceNew: true, |
| Description: `If specified, dual stack mode is enabled and all pods in the cluster are |
| assigned an IPv6 address from these blocks alongside from an IPv4 |
| address. Only a single block is supported. This field cannot be changed |
| after creation.`, |
| Elem: &schema.Schema{ |
| Type: schema.TypeString, |
| }, |
| }, |
| "services_ipv6_cidr_blocks": { |
| Type: schema.TypeList, |
| Optional: true, |
| ForceNew: true, |
| Description: `If specified, dual stack mode is enabled and all services in the cluster are |
| assigned an IPv6 address from these blocks alongside from an IPv4 |
| address. Only a single block is supported. This field cannot be changed |
| after creation.`, |
| Elem: &schema.Schema{ |
| Type: schema.TypeString, |
| }, |
| }, |
| "network_type": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `IP addressing type of this cluster i.e. SINGLESTACK_V4 vs DUALSTACK_V4_V6.`, |
| }, |
| }, |
| }, |
| }, |
| "control_plane": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `The configuration of the cluster control plane.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "local": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| ForceNew: true, |
| Description: `Local control plane configuration.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "machine_filter": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `Only machines matching this filter will be allowed to host control |
| plane nodes. The filtering language accepts strings like "name=<name>", |
| and is documented here: [AIP-160](https://google.aip.dev/160).`, |
| }, |
| "node_count": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Optional: true, |
| Description: `The number of nodes to serve as replicas of the Control Plane. |
| Only 1 and 3 are supported.`, |
| }, |
| "node_location": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| ForceNew: true, |
| Description: `Name of the Google Distributed Cloud Edge zones where this node pool |
| will be created. For example: 'us-central1-edge-customer-a'.`, |
| }, |
| "shared_deployment_policy": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| ValidateFunc: verify.ValidateEnum([]string{"SHARED_DEPLOYMENT_POLICY_UNSPECIFIED", "ALLOWED", "DISALLOWED", ""}), |
| Description: `Policy configuration about how user applications are deployed. Possible values: ["SHARED_DEPLOYMENT_POLICY_UNSPECIFIED", "ALLOWED", "DISALLOWED"]`, |
| }, |
| }, |
| }, |
| ExactlyOneOf: []string{"control_plane.0.remote", "control_plane.0.local"}, |
| }, |
| "remote": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| ForceNew: true, |
| Description: `Remote control plane configuration.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "node_location": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| ForceNew: true, |
| Description: `Name of the Google Distributed Cloud Edge zones where this node pool |
| will be created. For example: 'us-central1-edge-customer-a'.`, |
| }, |
| }, |
| }, |
| ExactlyOneOf: []string{"control_plane.0.remote", "control_plane.0.local"}, |
| }, |
| }, |
| }, |
| }, |
| "control_plane_encryption": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| Description: `Remote control plane disk encryption options. This field is only used when |
| enabling CMEK support.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "kms_key": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| ForceNew: true, |
| Description: `The Cloud KMS CryptoKey e.g. |
| projects/{project}/locations/{location}/keyRings/{keyRing}/cryptoKeys/{cryptoKey} |
| to use for protecting control plane disks. If not specified, a |
| Google-managed key will be used instead.`, |
| }, |
| "kms_key_active_version": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The Cloud KMS CryptoKeyVersion currently in use for protecting control |
| plane disks. Only applicable if kms_key is set.`, |
| }, |
| "kms_key_state": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `Availability of the Cloud KMS CryptoKey. If not 'KEY_AVAILABLE', then |
| nodes may go offline as they cannot access their local data. This can be |
| caused by a lack of permissions to use the key, or if the key is disabled |
| or deleted.`, |
| }, |
| "kms_status": { |
| Type: schema.TypeList, |
| Computed: true, |
| Description: `Error status returned by Cloud KMS when using this key. This field may be |
| populated only if 'kms_key_state' is not 'KMS_KEY_STATE_KEY_AVAILABLE'. |
| If populated, this field contains the error status reported by Cloud KMS.`, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "code": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Description: `The status code, which should be an enum value of google.rpc.Code.`, |
| }, |
| "message": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.`, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| "default_max_pods_per_node": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Optional: true, |
| Description: `The default maximum number of pods per node used if a maximum value is not |
| specified explicitly for a node pool in this cluster. If unspecified, the |
| Kubernetes default value will be used.`, |
| }, |
| "external_load_balancer_ipv4_address_pools": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| Description: `Address pools for cluster data plane external load balancing.`, |
| Elem: &schema.Schema{ |
| Type: schema.TypeString, |
| }, |
| }, |
| "labels": { |
| Type: schema.TypeMap, |
| Optional: true, |
| Description: `User-defined labels for the edgecloud cluster. |
| |
| **Note**: This field is non-authoritative, and will only manage the labels present in your configuration. |
| Please refer to the field 'effective_labels' for all of the labels present on the resource.`, |
| Elem: &schema.Schema{Type: schema.TypeString}, |
| }, |
| "maintenance_policy": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| Description: `Cluster-wide maintenance policy configuration.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "window": { |
| Type: schema.TypeList, |
| Required: true, |
| Description: `Specifies the maintenance window in which maintenance may be performed.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "recurring_window": { |
| Type: schema.TypeList, |
| Required: true, |
| Description: `Represents an arbitrary window of time that recurs.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "recurrence": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| Description: `An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how |
| this window recurs. They go on for the span of time between the start and |
| end time.`, |
| }, |
| "window": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| Description: `Represents an arbitrary window of time.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "end_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| Description: `The time that the window ends. The end time must take place after the |
| start time.`, |
| }, |
| "start_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| Description: `The time that the window first starts.`, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| "maintenance_exclusions": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Exclusions to automatic maintenance. Non-emergency maintenance should not occur |
| in these windows. Each exclusion has a unique name and may be active or expired. |
| The max number of maintenance exclusions allowed at a given time is 3.`, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "id": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| Description: `A unique (per cluster) id for the window.`, |
| }, |
| "window": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| Description: `Represents an arbitrary window of time.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "end_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| Description: `The time that the window ends. The end time must take place after the |
| start time.`, |
| }, |
| "start_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| Description: `The time that the window first starts.`, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| "release_channel": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| ValidateFunc: verify.ValidateEnum([]string{"RELEASE_CHANNEL_UNSPECIFIED", "NONE", "REGULAR", ""}), |
| Description: `The release channel a cluster is subscribed to. Possible values: ["RELEASE_CHANNEL_UNSPECIFIED", "NONE", "REGULAR"]`, |
| }, |
| "system_addons_config": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| Description: `Config that customers are allowed to define for GDCE system add-ons.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "ingress": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| Description: `Config for the Ingress add-on which allows customers to create an Ingress |
| object to manage external access to the servers in a cluster. The add-on |
| consists of istiod and istio-ingress.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "disabled": { |
| Type: schema.TypeBool, |
| Computed: true, |
| Optional: true, |
| Description: `Whether Ingress is disabled.`, |
| }, |
| "ipv4_vip": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| Description: `Ingress VIP.`, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| "target_version": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| Description: `The target cluster version. For example: "1.5.0".`, |
| }, |
| "cluster_ca_certificate": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The PEM-encoded public certificate of the cluster's CA.`, |
| Sensitive: true, |
| }, |
| "control_plane_version": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The control plane release version.`, |
| }, |
| "create_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The time the cluster was created, in RFC3339 text format.`, |
| }, |
| "effective_labels": { |
| Type: schema.TypeMap, |
| Computed: true, |
| Description: `All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Terraform, other clients and services.`, |
| Elem: &schema.Schema{Type: schema.TypeString}, |
| }, |
| "endpoint": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The IP address of the Kubernetes API server.`, |
| }, |
| "maintenance_events": { |
| Type: schema.TypeList, |
| Computed: true, |
| Description: `All the maintenance events scheduled for the cluster, including the ones |
| ongoing, planned for the future and done in the past (up to 90 days).`, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "create_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The time when the maintenance event request was created.`, |
| }, |
| "end_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The time when the maintenance event ended, either successfully or not. If |
| the maintenance event is split into multiple maintenance windows, |
| end_time is only updated when the whole flow ends.`, |
| }, |
| "operation": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The operation for running the maintenance event. Specified in the format |
| projects/*/locations/*/operations/*. If the maintenance event is split |
| into multiple operations (e.g. due to maintenance windows), the latest |
| one is recorded.`, |
| }, |
| "schedule": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The schedule of the maintenance event.`, |
| }, |
| "start_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The time when the maintenance event started.`, |
| }, |
| "state": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `Indicates the maintenance event state.`, |
| }, |
| "target_version": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The target version of the cluster.`, |
| }, |
| "type": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `Indicates the maintenance event type.`, |
| }, |
| "update_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The time when the maintenance event message was updated.`, |
| }, |
| "uuid": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `UUID of the maintenance event.`, |
| }, |
| }, |
| }, |
| }, |
| "node_version": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The lowest release version among all worker nodes. This field can be empty |
| if the cluster does not have any worker nodes.`, |
| }, |
| "port": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Description: `The port number of the Kubernetes API server.`, |
| }, |
| "status": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `Indicates the status of the cluster.`, |
| }, |
| "terraform_labels": { |
| Type: schema.TypeMap, |
| Computed: true, |
| Description: `The combination of labels configured directly on the resource |
| and default labels configured on the provider.`, |
| Elem: &schema.Schema{Type: schema.TypeString}, |
| }, |
| "update_time": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The time the cluster was last updated, in RFC3339 text format.`, |
| }, |
| "project": { |
| Type: schema.TypeString, |
| Optional: true, |
| Computed: true, |
| ForceNew: true, |
| }, |
| }, |
| UseJSONNumber: true, |
| } |
| } |
| |
| func resourceEdgecontainerClusterCreate(d *schema.ResourceData, meta interface{}) error { |
| config := meta.(*transport_tpg.Config) |
| userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) |
| if err != nil { |
| return err |
| } |
| |
| obj := make(map[string]interface{}) |
| fleetProp, err := expandEdgecontainerClusterFleet(d.Get("fleet"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("fleet"); !tpgresource.IsEmptyValue(reflect.ValueOf(fleetProp)) && (ok || !reflect.DeepEqual(v, fleetProp)) { |
| obj["fleet"] = fleetProp |
| } |
| networkingProp, err := expandEdgecontainerClusterNetworking(d.Get("networking"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("networking"); !tpgresource.IsEmptyValue(reflect.ValueOf(networkingProp)) && (ok || !reflect.DeepEqual(v, networkingProp)) { |
| obj["networking"] = networkingProp |
| } |
| authorizationProp, err := expandEdgecontainerClusterAuthorization(d.Get("authorization"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("authorization"); !tpgresource.IsEmptyValue(reflect.ValueOf(authorizationProp)) && (ok || !reflect.DeepEqual(v, authorizationProp)) { |
| obj["authorization"] = authorizationProp |
| } |
| defaultMaxPodsPerNodeProp, err := expandEdgecontainerClusterDefaultMaxPodsPerNode(d.Get("default_max_pods_per_node"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("default_max_pods_per_node"); !tpgresource.IsEmptyValue(reflect.ValueOf(defaultMaxPodsPerNodeProp)) && (ok || !reflect.DeepEqual(v, defaultMaxPodsPerNodeProp)) { |
| obj["defaultMaxPodsPerNode"] = defaultMaxPodsPerNodeProp |
| } |
| maintenancePolicyProp, err := expandEdgecontainerClusterMaintenancePolicy(d.Get("maintenance_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("maintenance_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(maintenancePolicyProp)) && (ok || !reflect.DeepEqual(v, maintenancePolicyProp)) { |
| obj["maintenancePolicy"] = maintenancePolicyProp |
| } |
| controlPlaneProp, err := expandEdgecontainerClusterControlPlane(d.Get("control_plane"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("control_plane"); !tpgresource.IsEmptyValue(reflect.ValueOf(controlPlaneProp)) && (ok || !reflect.DeepEqual(v, controlPlaneProp)) { |
| obj["controlPlane"] = controlPlaneProp |
| } |
| systemAddonsConfigProp, err := expandEdgecontainerClusterSystemAddonsConfig(d.Get("system_addons_config"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("system_addons_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(systemAddonsConfigProp)) && (ok || !reflect.DeepEqual(v, systemAddonsConfigProp)) { |
| obj["systemAddonsConfig"] = systemAddonsConfigProp |
| } |
| externalLoadBalancerIpv4AddressPoolsProp, err := expandEdgecontainerClusterExternalLoadBalancerIpv4AddressPools(d.Get("external_load_balancer_ipv4_address_pools"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("external_load_balancer_ipv4_address_pools"); !tpgresource.IsEmptyValue(reflect.ValueOf(externalLoadBalancerIpv4AddressPoolsProp)) && (ok || !reflect.DeepEqual(v, externalLoadBalancerIpv4AddressPoolsProp)) { |
| obj["externalLoadBalancerIpv4AddressPools"] = externalLoadBalancerIpv4AddressPoolsProp |
| } |
| controlPlaneEncryptionProp, err := expandEdgecontainerClusterControlPlaneEncryption(d.Get("control_plane_encryption"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("control_plane_encryption"); !tpgresource.IsEmptyValue(reflect.ValueOf(controlPlaneEncryptionProp)) && (ok || !reflect.DeepEqual(v, controlPlaneEncryptionProp)) { |
| obj["controlPlaneEncryption"] = controlPlaneEncryptionProp |
| } |
| targetVersionProp, err := expandEdgecontainerClusterTargetVersion(d.Get("target_version"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("target_version"); !tpgresource.IsEmptyValue(reflect.ValueOf(targetVersionProp)) && (ok || !reflect.DeepEqual(v, targetVersionProp)) { |
| obj["targetVersion"] = targetVersionProp |
| } |
| releaseChannelProp, err := expandEdgecontainerClusterReleaseChannel(d.Get("release_channel"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("release_channel"); !tpgresource.IsEmptyValue(reflect.ValueOf(releaseChannelProp)) && (ok || !reflect.DeepEqual(v, releaseChannelProp)) { |
| obj["releaseChannel"] = releaseChannelProp |
| } |
| labelsProp, err := expandEdgecontainerClusterEffectiveLabels(d.Get("effective_labels"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("effective_labels"); !tpgresource.IsEmptyValue(reflect.ValueOf(labelsProp)) && (ok || !reflect.DeepEqual(v, labelsProp)) { |
| obj["labels"] = labelsProp |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{EdgecontainerBasePath}}projects/{{project}}/locations/{{location}}/clusters?cluster_id={{name}}") |
| if err != nil { |
| return err |
| } |
| |
| log.Printf("[DEBUG] Creating new Cluster: %#v", obj) |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for Cluster: %s", err) |
| } |
| billingProject = project |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| headers := make(http.Header) |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "POST", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| Body: obj, |
| Timeout: d.Timeout(schema.TimeoutCreate), |
| Headers: headers, |
| }) |
| if err != nil { |
| return fmt.Errorf("Error creating Cluster: %s", err) |
| } |
| |
| // Store the ID now |
| id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{location}}/clusters/{{name}}") |
| if err != nil { |
| return fmt.Errorf("Error constructing id: %s", err) |
| } |
| d.SetId(id) |
| |
| err = EdgecontainerOperationWaitTime( |
| config, res, project, "Creating Cluster", userAgent, |
| d.Timeout(schema.TimeoutCreate)) |
| |
| if err != nil { |
| // The resource didn't actually create |
| d.SetId("") |
| return fmt.Errorf("Error waiting to create Cluster: %s", err) |
| } |
| |
| log.Printf("[DEBUG] Finished creating Cluster %q: %#v", d.Id(), res) |
| |
| return resourceEdgecontainerClusterRead(d, meta) |
| } |
| |
| func resourceEdgecontainerClusterRead(d *schema.ResourceData, meta interface{}) error { |
| config := meta.(*transport_tpg.Config) |
| userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) |
| if err != nil { |
| return err |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{EdgecontainerBasePath}}projects/{{project}}/locations/{{location}}/clusters/{{name}}") |
| if err != nil { |
| return err |
| } |
| |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for Cluster: %s", err) |
| } |
| billingProject = project |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| headers := make(http.Header) |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "GET", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| Headers: headers, |
| }) |
| if err != nil { |
| return transport_tpg.HandleNotFoundError(err, d, fmt.Sprintf("EdgecontainerCluster %q", d.Id())) |
| } |
| |
| if err := d.Set("project", project); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| |
| if err := d.Set("create_time", flattenEdgecontainerClusterCreateTime(res["createTime"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("update_time", flattenEdgecontainerClusterUpdateTime(res["updateTime"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("labels", flattenEdgecontainerClusterLabels(res["labels"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("fleet", flattenEdgecontainerClusterFleet(res["fleet"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("networking", flattenEdgecontainerClusterNetworking(res["networking"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("authorization", flattenEdgecontainerClusterAuthorization(res["authorization"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("default_max_pods_per_node", flattenEdgecontainerClusterDefaultMaxPodsPerNode(res["defaultMaxPodsPerNode"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("endpoint", flattenEdgecontainerClusterEndpoint(res["endpoint"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("port", flattenEdgecontainerClusterPort(res["port"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("cluster_ca_certificate", flattenEdgecontainerClusterClusterCaCertificate(res["clusterCaCertificate"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("maintenance_policy", flattenEdgecontainerClusterMaintenancePolicy(res["maintenancePolicy"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("control_plane_version", flattenEdgecontainerClusterControlPlaneVersion(res["controlPlaneVersion"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("node_version", flattenEdgecontainerClusterNodeVersion(res["nodeVersion"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("control_plane", flattenEdgecontainerClusterControlPlane(res["controlPlane"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("system_addons_config", flattenEdgecontainerClusterSystemAddonsConfig(res["systemAddonsConfig"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("external_load_balancer_ipv4_address_pools", flattenEdgecontainerClusterExternalLoadBalancerIpv4AddressPools(res["externalLoadBalancerIpv4AddressPools"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("control_plane_encryption", flattenEdgecontainerClusterControlPlaneEncryption(res["controlPlaneEncryption"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("status", flattenEdgecontainerClusterStatus(res["status"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("maintenance_events", flattenEdgecontainerClusterMaintenanceEvents(res["maintenanceEvents"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("target_version", flattenEdgecontainerClusterTargetVersion(res["targetVersion"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("release_channel", flattenEdgecontainerClusterReleaseChannel(res["releaseChannel"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("terraform_labels", flattenEdgecontainerClusterTerraformLabels(res["labels"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| if err := d.Set("effective_labels", flattenEdgecontainerClusterEffectiveLabels(res["labels"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Cluster: %s", err) |
| } |
| |
| return nil |
| } |
| |
| func resourceEdgecontainerClusterUpdate(d *schema.ResourceData, meta interface{}) error { |
| config := meta.(*transport_tpg.Config) |
| userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) |
| if err != nil { |
| return err |
| } |
| |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for Cluster: %s", err) |
| } |
| billingProject = project |
| |
| obj := make(map[string]interface{}) |
| networkingProp, err := expandEdgecontainerClusterNetworking(d.Get("networking"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("networking"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, networkingProp)) { |
| obj["networking"] = networkingProp |
| } |
| defaultMaxPodsPerNodeProp, err := expandEdgecontainerClusterDefaultMaxPodsPerNode(d.Get("default_max_pods_per_node"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("default_max_pods_per_node"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, defaultMaxPodsPerNodeProp)) { |
| obj["defaultMaxPodsPerNode"] = defaultMaxPodsPerNodeProp |
| } |
| maintenancePolicyProp, err := expandEdgecontainerClusterMaintenancePolicy(d.Get("maintenance_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("maintenance_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, maintenancePolicyProp)) { |
| obj["maintenancePolicy"] = maintenancePolicyProp |
| } |
| controlPlaneProp, err := expandEdgecontainerClusterControlPlane(d.Get("control_plane"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("control_plane"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, controlPlaneProp)) { |
| obj["controlPlane"] = controlPlaneProp |
| } |
| systemAddonsConfigProp, err := expandEdgecontainerClusterSystemAddonsConfig(d.Get("system_addons_config"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("system_addons_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, systemAddonsConfigProp)) { |
| obj["systemAddonsConfig"] = systemAddonsConfigProp |
| } |
| externalLoadBalancerIpv4AddressPoolsProp, err := expandEdgecontainerClusterExternalLoadBalancerIpv4AddressPools(d.Get("external_load_balancer_ipv4_address_pools"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("external_load_balancer_ipv4_address_pools"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, externalLoadBalancerIpv4AddressPoolsProp)) { |
| obj["externalLoadBalancerIpv4AddressPools"] = externalLoadBalancerIpv4AddressPoolsProp |
| } |
| controlPlaneEncryptionProp, err := expandEdgecontainerClusterControlPlaneEncryption(d.Get("control_plane_encryption"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("control_plane_encryption"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, controlPlaneEncryptionProp)) { |
| obj["controlPlaneEncryption"] = controlPlaneEncryptionProp |
| } |
| releaseChannelProp, err := expandEdgecontainerClusterReleaseChannel(d.Get("release_channel"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("release_channel"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, releaseChannelProp)) { |
| obj["releaseChannel"] = releaseChannelProp |
| } |
| labelsProp, err := expandEdgecontainerClusterEffectiveLabels(d.Get("effective_labels"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("effective_labels"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, labelsProp)) { |
| obj["labels"] = labelsProp |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{EdgecontainerBasePath}}projects/{{project}}/locations/{{location}}/clusters/{{name}}") |
| if err != nil { |
| return err |
| } |
| |
| log.Printf("[DEBUG] Updating Cluster %q: %#v", d.Id(), obj) |
| headers := make(http.Header) |
| updateMask := []string{} |
| |
| if d.HasChange("networking") { |
| updateMask = append(updateMask, "networking") |
| } |
| |
| if d.HasChange("default_max_pods_per_node") { |
| updateMask = append(updateMask, "defaultMaxPodsPerNode") |
| } |
| |
| if d.HasChange("maintenance_policy") { |
| updateMask = append(updateMask, "maintenancePolicy") |
| } |
| |
| if d.HasChange("control_plane") { |
| updateMask = append(updateMask, "controlPlane") |
| } |
| |
| if d.HasChange("system_addons_config") { |
| updateMask = append(updateMask, "systemAddonsConfig") |
| } |
| |
| if d.HasChange("external_load_balancer_ipv4_address_pools") { |
| updateMask = append(updateMask, "externalLoadBalancerIpv4AddressPools") |
| } |
| |
| if d.HasChange("control_plane_encryption") { |
| updateMask = append(updateMask, "controlPlaneEncryption") |
| } |
| |
| if d.HasChange("release_channel") { |
| updateMask = append(updateMask, "releaseChannel") |
| } |
| |
| if d.HasChange("effective_labels") { |
| updateMask = append(updateMask, "labels") |
| } |
| // updateMask is a URL parameter but not present in the schema, so ReplaceVars |
| // won't set it |
| url, err = transport_tpg.AddQueryParams(url, map[string]string{"updateMask": strings.Join(updateMask, ",")}) |
| if err != nil { |
| return err |
| } |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| // if updateMask is empty we are not updating anything so skip the post |
| if len(updateMask) > 0 { |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "PATCH", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| Body: obj, |
| Timeout: d.Timeout(schema.TimeoutUpdate), |
| Headers: headers, |
| }) |
| |
| if err != nil { |
| return fmt.Errorf("Error updating Cluster %q: %s", d.Id(), err) |
| } else { |
| log.Printf("[DEBUG] Finished updating Cluster %q: %#v", d.Id(), res) |
| } |
| |
| err = EdgecontainerOperationWaitTime( |
| config, res, project, "Updating Cluster", userAgent, |
| d.Timeout(schema.TimeoutUpdate)) |
| |
| if err != nil { |
| return err |
| } |
| } |
| d.Partial(true) |
| |
| if d.HasChange("target_version") { |
| obj := make(map[string]interface{}) |
| |
| targetVersionProp, err := expandEdgecontainerClusterTargetVersion(d.Get("target_version"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("target_version"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, targetVersionProp)) { |
| obj["targetVersion"] = targetVersionProp |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{EdgecontainerBasePath}}projects/{{project}}/locations/{{location}}/clusters/{{name}}:upgrade") |
| if err != nil { |
| return err |
| } |
| |
| headers := make(http.Header) |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "POST", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| Body: obj, |
| Timeout: d.Timeout(schema.TimeoutUpdate), |
| Headers: headers, |
| }) |
| if err != nil { |
| return fmt.Errorf("Error updating Cluster %q: %s", d.Id(), err) |
| } else { |
| log.Printf("[DEBUG] Finished updating Cluster %q: %#v", d.Id(), res) |
| } |
| |
| err = EdgecontainerOperationWaitTime( |
| config, res, project, "Updating Cluster", userAgent, |
| d.Timeout(schema.TimeoutUpdate)) |
| if err != nil { |
| return err |
| } |
| } |
| |
| d.Partial(false) |
| |
| return resourceEdgecontainerClusterRead(d, meta) |
| } |
| |
| func resourceEdgecontainerClusterDelete(d *schema.ResourceData, meta interface{}) error { |
| config := meta.(*transport_tpg.Config) |
| userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) |
| if err != nil { |
| return err |
| } |
| |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for Cluster: %s", err) |
| } |
| billingProject = project |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{EdgecontainerBasePath}}projects/{{project}}/locations/{{location}}/clusters/{{name}}") |
| if err != nil { |
| return err |
| } |
| |
| var obj map[string]interface{} |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| headers := make(http.Header) |
| |
| log.Printf("[DEBUG] Deleting Cluster %q", d.Id()) |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "DELETE", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| Body: obj, |
| Timeout: d.Timeout(schema.TimeoutDelete), |
| Headers: headers, |
| }) |
| if err != nil { |
| return transport_tpg.HandleNotFoundError(err, d, "Cluster") |
| } |
| |
| err = EdgecontainerOperationWaitTime( |
| config, res, project, "Deleting Cluster", userAgent, |
| d.Timeout(schema.TimeoutDelete)) |
| |
| if err != nil { |
| return err |
| } |
| |
| log.Printf("[DEBUG] Finished deleting Cluster %q: %#v", d.Id(), res) |
| return nil |
| } |
| |
| func resourceEdgecontainerClusterImport(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { |
| config := meta.(*transport_tpg.Config) |
| if err := tpgresource.ParseImportId([]string{ |
| "^projects/(?P<project>[^/]+)/locations/(?P<location>[^/]+)/clusters/(?P<name>[^/]+)$", |
| "^(?P<project>[^/]+)/(?P<location>[^/]+)/(?P<name>[^/]+)$", |
| "^(?P<location>[^/]+)/(?P<name>[^/]+)$", |
| }, d, config); err != nil { |
| return nil, err |
| } |
| |
| // Replace import id for the resource id |
| id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{location}}/clusters/{{name}}") |
| if err != nil { |
| return nil, fmt.Errorf("Error constructing id: %s", err) |
| } |
| d.SetId(id) |
| |
| return []*schema.ResourceData{d}, nil |
| } |
| |
| func flattenEdgecontainerClusterCreateTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterUpdateTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterLabels(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| |
| transformed := make(map[string]interface{}) |
| if l, ok := d.GetOkExists("labels"); ok { |
| for k := range l.(map[string]interface{}) { |
| transformed[k] = v.(map[string]interface{})[k] |
| } |
| } |
| |
| return transformed |
| } |
| |
| func flattenEdgecontainerClusterFleet(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["project"] = |
| flattenEdgecontainerClusterFleetProject(original["project"], d, config) |
| transformed["membership"] = |
| flattenEdgecontainerClusterFleetMembership(original["membership"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterFleetProject(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterFleetMembership(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterNetworking(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["cluster_ipv4_cidr_blocks"] = |
| flattenEdgecontainerClusterNetworkingClusterIpv4CidrBlocks(original["clusterIpv4CidrBlocks"], d, config) |
| transformed["services_ipv4_cidr_blocks"] = |
| flattenEdgecontainerClusterNetworkingServicesIpv4CidrBlocks(original["servicesIpv4CidrBlocks"], d, config) |
| transformed["cluster_ipv6_cidr_blocks"] = |
| flattenEdgecontainerClusterNetworkingClusterIpv6CidrBlocks(original["clusterIpv6CidrBlocks"], d, config) |
| transformed["services_ipv6_cidr_blocks"] = |
| flattenEdgecontainerClusterNetworkingServicesIpv6CidrBlocks(original["servicesIpv6CidrBlocks"], d, config) |
| transformed["network_type"] = |
| flattenEdgecontainerClusterNetworkingNetworkType(original["networkType"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterNetworkingClusterIpv4CidrBlocks(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterNetworkingServicesIpv4CidrBlocks(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterNetworkingClusterIpv6CidrBlocks(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterNetworkingServicesIpv6CidrBlocks(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterNetworkingNetworkType(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterAuthorization(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["admin_users"] = |
| flattenEdgecontainerClusterAuthorizationAdminUsers(original["adminUsers"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterAuthorizationAdminUsers(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["username"] = |
| flattenEdgecontainerClusterAuthorizationAdminUsersUsername(original["username"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterAuthorizationAdminUsersUsername(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterDefaultMaxPodsPerNode(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| // Handles the string fixed64 format |
| if strVal, ok := v.(string); ok { |
| if intVal, err := tpgresource.StringToFixed64(strVal); err == nil { |
| return intVal |
| } |
| } |
| |
| // number values are represented as float64 |
| if floatVal, ok := v.(float64); ok { |
| intVal := int(floatVal) |
| return intVal |
| } |
| |
| return v // let terraform core handle it otherwise |
| } |
| |
| func flattenEdgecontainerClusterEndpoint(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterPort(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| // Handles the string fixed64 format |
| if strVal, ok := v.(string); ok { |
| if intVal, err := tpgresource.StringToFixed64(strVal); err == nil { |
| return intVal |
| } |
| } |
| |
| // number values are represented as float64 |
| if floatVal, ok := v.(float64); ok { |
| intVal := int(floatVal) |
| return intVal |
| } |
| |
| return v // let terraform core handle it otherwise |
| } |
| |
| func flattenEdgecontainerClusterClusterCaCertificate(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenancePolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["window"] = |
| flattenEdgecontainerClusterMaintenancePolicyWindow(original["window"], d, config) |
| transformed["maintenance_exclusions"] = |
| flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusions(original["maintenanceExclusions"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterMaintenancePolicyWindow(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["recurring_window"] = |
| flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindow(original["recurringWindow"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindow(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["window"] = |
| flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindow(original["window"], d, config) |
| transformed["recurrence"] = |
| flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindowRecurrence(original["recurrence"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindow(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["start_time"] = |
| flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindowStartTime(original["startTime"], d, config) |
| transformed["end_time"] = |
| flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindowEndTime(original["endTime"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindowStartTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindowEndTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenancePolicyWindowRecurringWindowRecurrence(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusions(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| l := v.([]interface{}) |
| transformed := make([]interface{}, 0, len(l)) |
| for _, raw := range l { |
| original := raw.(map[string]interface{}) |
| if len(original) < 1 { |
| // Do not include empty json objects coming back from the api |
| continue |
| } |
| transformed = append(transformed, map[string]interface{}{ |
| "window": flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindow(original["window"], d, config), |
| "id": flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsId(original["id"], d, config), |
| }) |
| } |
| return transformed |
| } |
| func flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindow(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["start_time"] = |
| flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindowStartTime(original["startTime"], d, config) |
| transformed["end_time"] = |
| flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindowEndTime(original["endTime"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindowStartTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindowEndTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneVersion(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterNodeVersion(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterControlPlane(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["remote"] = |
| flattenEdgecontainerClusterControlPlaneRemote(original["remote"], d, config) |
| transformed["local"] = |
| flattenEdgecontainerClusterControlPlaneLocal(original["local"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterControlPlaneRemote(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["node_location"] = |
| flattenEdgecontainerClusterControlPlaneRemoteNodeLocation(original["nodeLocation"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterControlPlaneRemoteNodeLocation(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneLocal(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["node_location"] = |
| flattenEdgecontainerClusterControlPlaneLocalNodeLocation(original["nodeLocation"], d, config) |
| transformed["node_count"] = |
| flattenEdgecontainerClusterControlPlaneLocalNodeCount(original["nodeCount"], d, config) |
| transformed["machine_filter"] = |
| flattenEdgecontainerClusterControlPlaneLocalMachineFilter(original["machineFilter"], d, config) |
| transformed["shared_deployment_policy"] = |
| flattenEdgecontainerClusterControlPlaneLocalSharedDeploymentPolicy(original["sharedDeploymentPolicy"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterControlPlaneLocalNodeLocation(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneLocalNodeCount(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| // Handles the string fixed64 format |
| if strVal, ok := v.(string); ok { |
| if intVal, err := tpgresource.StringToFixed64(strVal); err == nil { |
| return intVal |
| } |
| } |
| |
| // number values are represented as float64 |
| if floatVal, ok := v.(float64); ok { |
| intVal := int(floatVal) |
| return intVal |
| } |
| |
| return v // let terraform core handle it otherwise |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneLocalMachineFilter(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneLocalSharedDeploymentPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterSystemAddonsConfig(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["ingress"] = |
| flattenEdgecontainerClusterSystemAddonsConfigIngress(original["ingress"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterSystemAddonsConfigIngress(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["disabled"] = |
| flattenEdgecontainerClusterSystemAddonsConfigIngressDisabled(original["disabled"], d, config) |
| transformed["ipv4_vip"] = |
| flattenEdgecontainerClusterSystemAddonsConfigIngressIpv4Vip(original["ipv4Vip"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterSystemAddonsConfigIngressDisabled(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterSystemAddonsConfigIngressIpv4Vip(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterExternalLoadBalancerIpv4AddressPools(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneEncryption(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["kms_key"] = |
| flattenEdgecontainerClusterControlPlaneEncryptionKmsKey(original["kmsKey"], d, config) |
| transformed["kms_key_active_version"] = |
| flattenEdgecontainerClusterControlPlaneEncryptionKmsKeyActiveVersion(original["kmsKeyActiveVersion"], d, config) |
| transformed["kms_key_state"] = |
| flattenEdgecontainerClusterControlPlaneEncryptionKmsKeyState(original["kmsKeyState"], d, config) |
| transformed["kms_status"] = |
| flattenEdgecontainerClusterControlPlaneEncryptionKmsStatus(original["kmsStatus"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterControlPlaneEncryptionKmsKey(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneEncryptionKmsKeyActiveVersion(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneEncryptionKmsKeyState(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneEncryptionKmsStatus(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return nil |
| } |
| original := v.(map[string]interface{}) |
| if len(original) == 0 { |
| return nil |
| } |
| transformed := make(map[string]interface{}) |
| transformed["code"] = |
| flattenEdgecontainerClusterControlPlaneEncryptionKmsStatusCode(original["code"], d, config) |
| transformed["message"] = |
| flattenEdgecontainerClusterControlPlaneEncryptionKmsStatusMessage(original["message"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenEdgecontainerClusterControlPlaneEncryptionKmsStatusCode(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| // Handles the string fixed64 format |
| if strVal, ok := v.(string); ok { |
| if intVal, err := tpgresource.StringToFixed64(strVal); err == nil { |
| return intVal |
| } |
| } |
| |
| // number values are represented as float64 |
| if floatVal, ok := v.(float64); ok { |
| intVal := int(floatVal) |
| return intVal |
| } |
| |
| return v // let terraform core handle it otherwise |
| } |
| |
| func flattenEdgecontainerClusterControlPlaneEncryptionKmsStatusMessage(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterStatus(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEvents(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| l := v.([]interface{}) |
| transformed := make([]interface{}, 0, len(l)) |
| for _, raw := range l { |
| original := raw.(map[string]interface{}) |
| if len(original) < 1 { |
| // Do not include empty json objects coming back from the api |
| continue |
| } |
| transformed = append(transformed, map[string]interface{}{ |
| "uuid": flattenEdgecontainerClusterMaintenanceEventsUuid(original["uuid"], d, config), |
| "target_version": flattenEdgecontainerClusterMaintenanceEventsTargetVersion(original["targetVersion"], d, config), |
| "operation": flattenEdgecontainerClusterMaintenanceEventsOperation(original["operation"], d, config), |
| "type": flattenEdgecontainerClusterMaintenanceEventsType(original["type"], d, config), |
| "schedule": flattenEdgecontainerClusterMaintenanceEventsSchedule(original["schedule"], d, config), |
| "state": flattenEdgecontainerClusterMaintenanceEventsState(original["state"], d, config), |
| "create_time": flattenEdgecontainerClusterMaintenanceEventsCreateTime(original["createTime"], d, config), |
| "start_time": flattenEdgecontainerClusterMaintenanceEventsStartTime(original["startTime"], d, config), |
| "end_time": flattenEdgecontainerClusterMaintenanceEventsEndTime(original["endTime"], d, config), |
| "update_time": flattenEdgecontainerClusterMaintenanceEventsUpdateTime(original["updateTime"], d, config), |
| }) |
| } |
| return transformed |
| } |
| func flattenEdgecontainerClusterMaintenanceEventsUuid(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEventsTargetVersion(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEventsOperation(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEventsType(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEventsSchedule(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEventsState(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEventsCreateTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEventsStartTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEventsEndTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterMaintenanceEventsUpdateTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterTargetVersion(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterReleaseChannel(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenEdgecontainerClusterTerraformLabels(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| |
| transformed := make(map[string]interface{}) |
| if l, ok := d.GetOkExists("terraform_labels"); ok { |
| for k := range l.(map[string]interface{}) { |
| transformed[k] = v.(map[string]interface{})[k] |
| } |
| } |
| |
| return transformed |
| } |
| |
| func flattenEdgecontainerClusterEffectiveLabels(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func expandEdgecontainerClusterFleet(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedProject, err := expandEdgecontainerClusterFleetProject(original["project"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedProject); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["project"] = transformedProject |
| } |
| |
| transformedMembership, err := expandEdgecontainerClusterFleetMembership(original["membership"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMembership); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["membership"] = transformedMembership |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterFleetProject(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterFleetMembership(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterNetworking(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedClusterIpv4CidrBlocks, err := expandEdgecontainerClusterNetworkingClusterIpv4CidrBlocks(original["cluster_ipv4_cidr_blocks"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedClusterIpv4CidrBlocks); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["clusterIpv4CidrBlocks"] = transformedClusterIpv4CidrBlocks |
| } |
| |
| transformedServicesIpv4CidrBlocks, err := expandEdgecontainerClusterNetworkingServicesIpv4CidrBlocks(original["services_ipv4_cidr_blocks"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedServicesIpv4CidrBlocks); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["servicesIpv4CidrBlocks"] = transformedServicesIpv4CidrBlocks |
| } |
| |
| transformedClusterIpv6CidrBlocks, err := expandEdgecontainerClusterNetworkingClusterIpv6CidrBlocks(original["cluster_ipv6_cidr_blocks"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedClusterIpv6CidrBlocks); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["clusterIpv6CidrBlocks"] = transformedClusterIpv6CidrBlocks |
| } |
| |
| transformedServicesIpv6CidrBlocks, err := expandEdgecontainerClusterNetworkingServicesIpv6CidrBlocks(original["services_ipv6_cidr_blocks"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedServicesIpv6CidrBlocks); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["servicesIpv6CidrBlocks"] = transformedServicesIpv6CidrBlocks |
| } |
| |
| transformedNetworkType, err := expandEdgecontainerClusterNetworkingNetworkType(original["network_type"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedNetworkType); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["networkType"] = transformedNetworkType |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterNetworkingClusterIpv4CidrBlocks(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterNetworkingServicesIpv4CidrBlocks(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterNetworkingClusterIpv6CidrBlocks(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterNetworkingServicesIpv6CidrBlocks(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterNetworkingNetworkType(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterAuthorization(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedAdminUsers, err := expandEdgecontainerClusterAuthorizationAdminUsers(original["admin_users"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedAdminUsers); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["adminUsers"] = transformedAdminUsers |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterAuthorizationAdminUsers(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedUsername, err := expandEdgecontainerClusterAuthorizationAdminUsersUsername(original["username"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedUsername); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["username"] = transformedUsername |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterAuthorizationAdminUsersUsername(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterDefaultMaxPodsPerNode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedWindow, err := expandEdgecontainerClusterMaintenancePolicyWindow(original["window"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedWindow); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["window"] = transformedWindow |
| } |
| |
| transformedMaintenanceExclusions, err := expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusions(original["maintenance_exclusions"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaintenanceExclusions); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maintenanceExclusions"] = transformedMaintenanceExclusions |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyWindow(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedRecurringWindow, err := expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindow(original["recurring_window"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedRecurringWindow); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["recurringWindow"] = transformedRecurringWindow |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindow(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedWindow, err := expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindow(original["window"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedWindow); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["window"] = transformedWindow |
| } |
| |
| transformedRecurrence, err := expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindowRecurrence(original["recurrence"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedRecurrence); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["recurrence"] = transformedRecurrence |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindow(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedStartTime, err := expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindowStartTime(original["start_time"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedStartTime); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["startTime"] = transformedStartTime |
| } |
| |
| transformedEndTime, err := expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindowEndTime(original["end_time"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedEndTime); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["endTime"] = transformedEndTime |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindowStartTime(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindowWindowEndTime(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyWindowRecurringWindowRecurrence(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusions(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| req := make([]interface{}, 0, len(l)) |
| for _, raw := range l { |
| if raw == nil { |
| continue |
| } |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedWindow, err := expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindow(original["window"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedWindow); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["window"] = transformedWindow |
| } |
| |
| transformedId, err := expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsId(original["id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["id"] = transformedId |
| } |
| |
| req = append(req, transformed) |
| } |
| return req, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindow(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedStartTime, err := expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindowStartTime(original["start_time"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedStartTime); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["startTime"] = transformedStartTime |
| } |
| |
| transformedEndTime, err := expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindowEndTime(original["end_time"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedEndTime); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["endTime"] = transformedEndTime |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindowStartTime(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsWindowEndTime(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterMaintenancePolicyMaintenanceExclusionsId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlane(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedRemote, err := expandEdgecontainerClusterControlPlaneRemote(original["remote"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedRemote); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["remote"] = transformedRemote |
| } |
| |
| transformedLocal, err := expandEdgecontainerClusterControlPlaneLocal(original["local"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedLocal); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["local"] = transformedLocal |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneRemote(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedNodeLocation, err := expandEdgecontainerClusterControlPlaneRemoteNodeLocation(original["node_location"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedNodeLocation); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["nodeLocation"] = transformedNodeLocation |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneRemoteNodeLocation(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneLocal(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedNodeLocation, err := expandEdgecontainerClusterControlPlaneLocalNodeLocation(original["node_location"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedNodeLocation); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["nodeLocation"] = transformedNodeLocation |
| } |
| |
| transformedNodeCount, err := expandEdgecontainerClusterControlPlaneLocalNodeCount(original["node_count"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedNodeCount); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["nodeCount"] = transformedNodeCount |
| } |
| |
| transformedMachineFilter, err := expandEdgecontainerClusterControlPlaneLocalMachineFilter(original["machine_filter"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMachineFilter); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["machineFilter"] = transformedMachineFilter |
| } |
| |
| transformedSharedDeploymentPolicy, err := expandEdgecontainerClusterControlPlaneLocalSharedDeploymentPolicy(original["shared_deployment_policy"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedSharedDeploymentPolicy); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["sharedDeploymentPolicy"] = transformedSharedDeploymentPolicy |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneLocalNodeLocation(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneLocalNodeCount(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneLocalMachineFilter(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneLocalSharedDeploymentPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterSystemAddonsConfig(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedIngress, err := expandEdgecontainerClusterSystemAddonsConfigIngress(original["ingress"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedIngress); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["ingress"] = transformedIngress |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterSystemAddonsConfigIngress(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedDisabled, err := expandEdgecontainerClusterSystemAddonsConfigIngressDisabled(original["disabled"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedDisabled); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["disabled"] = transformedDisabled |
| } |
| |
| transformedIpv4Vip, err := expandEdgecontainerClusterSystemAddonsConfigIngressIpv4Vip(original["ipv4_vip"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedIpv4Vip); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["ipv4Vip"] = transformedIpv4Vip |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterSystemAddonsConfigIngressDisabled(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterSystemAddonsConfigIngressIpv4Vip(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterExternalLoadBalancerIpv4AddressPools(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneEncryption(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedKmsKey, err := expandEdgecontainerClusterControlPlaneEncryptionKmsKey(original["kms_key"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedKmsKey); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["kmsKey"] = transformedKmsKey |
| } |
| |
| transformedKmsKeyActiveVersion, err := expandEdgecontainerClusterControlPlaneEncryptionKmsKeyActiveVersion(original["kms_key_active_version"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedKmsKeyActiveVersion); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["kmsKeyActiveVersion"] = transformedKmsKeyActiveVersion |
| } |
| |
| transformedKmsKeyState, err := expandEdgecontainerClusterControlPlaneEncryptionKmsKeyState(original["kms_key_state"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedKmsKeyState); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["kmsKeyState"] = transformedKmsKeyState |
| } |
| |
| transformedKmsStatus, err := expandEdgecontainerClusterControlPlaneEncryptionKmsStatus(original["kms_status"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedKmsStatus); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["kmsStatus"] = transformedKmsStatus |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneEncryptionKmsKey(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneEncryptionKmsKeyActiveVersion(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneEncryptionKmsKeyState(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneEncryptionKmsStatus(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| if len(l) == 0 || l[0] == nil { |
| return nil, nil |
| } |
| raw := l[0] |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedCode, err := expandEdgecontainerClusterControlPlaneEncryptionKmsStatusCode(original["code"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedCode); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["code"] = transformedCode |
| } |
| |
| transformedMessage, err := expandEdgecontainerClusterControlPlaneEncryptionKmsStatusMessage(original["message"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMessage); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["message"] = transformedMessage |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneEncryptionKmsStatusCode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterControlPlaneEncryptionKmsStatusMessage(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterTargetVersion(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterReleaseChannel(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandEdgecontainerClusterEffectiveLabels(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (map[string]string, error) { |
| if v == nil { |
| return map[string]string{}, nil |
| } |
| m := make(map[string]string) |
| for k, val := range v.(map[string]interface{}) { |
| m[k] = val.(string) |
| } |
| return m, nil |
| } |
