| // 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 bigqueryconnection |
| |
| 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 ResourceBigqueryConnectionConnection() *schema.Resource { |
| return &schema.Resource{ |
| Create: resourceBigqueryConnectionConnectionCreate, |
| Read: resourceBigqueryConnectionConnectionRead, |
| Update: resourceBigqueryConnectionConnectionUpdate, |
| Delete: resourceBigqueryConnectionConnectionDelete, |
| |
| Importer: &schema.ResourceImporter{ |
| State: resourceBigqueryConnectionConnectionImport, |
| }, |
| |
| Timeouts: &schema.ResourceTimeout{ |
| Create: schema.DefaultTimeout(20 * time.Minute), |
| Update: schema.DefaultTimeout(20 * time.Minute), |
| Delete: schema.DefaultTimeout(20 * time.Minute), |
| }, |
| |
| CustomizeDiff: customdiff.All( |
| tpgresource.DefaultProviderProject, |
| ), |
| |
| Schema: map[string]*schema.Schema{ |
| "aws": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Connection properties specific to Amazon Web Services.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "access_role": { |
| Type: schema.TypeList, |
| Required: true, |
| Description: `Authentication using Google owned service account to assume into customer's AWS IAM Role.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "iam_role_id": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `The user’s AWS IAM Role that trusts the Google-owned AWS IAM user Connection.`, |
| }, |
| "identity": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `A unique Google-owned and Google-generated identity for the Connection. This identity will be used to access the user's AWS IAM Role.`, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| ExactlyOneOf: []string{"cloud_sql", "aws", "azure", "cloud_spanner", "cloud_resource", "spark"}, |
| }, |
| "azure": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Container for connection properties specific to Azure.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "customer_tenant_id": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `The id of customer's directory that host the data.`, |
| }, |
| "federated_application_client_id": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `The Azure Application (client) ID where the federated credentials will be hosted.`, |
| }, |
| "application": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The name of the Azure Active Directory Application.`, |
| }, |
| "client_id": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The client id of the Azure Active Directory Application.`, |
| }, |
| "identity": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `A unique Google-owned and Google-generated identity for the Connection. This identity will be used to access the user's Azure Active Directory Application.`, |
| }, |
| "object_id": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The object id of the Azure Active Directory Application.`, |
| }, |
| "redirect_uri": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The URL user will be redirected to after granting consent during connection setup.`, |
| }, |
| }, |
| }, |
| ExactlyOneOf: []string{"cloud_sql", "aws", "azure", "cloud_spanner", "cloud_resource", "spark"}, |
| }, |
| "cloud_resource": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Container for connection properties for delegation of access to GCP resources.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "service_account_id": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The account ID of the service created for the purpose of this connection.`, |
| }, |
| }, |
| }, |
| ExactlyOneOf: []string{"cloud_sql", "aws", "azure", "cloud_spanner", "cloud_resource", "spark"}, |
| }, |
| "cloud_spanner": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Connection properties specific to Cloud Spanner`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "database": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `Cloud Spanner database in the form 'project/instance/database'.`, |
| }, |
| "database_role": { |
| Type: schema.TypeString, |
| Optional: true, |
| ValidateFunc: verify.ValidateRegexp(`^[a-zA-Z][a-zA-Z0-9_]*$`), |
| Description: `Cloud Spanner database role for fine-grained access control. The Cloud Spanner admin should have provisioned the database role with appropriate permissions, such as 'SELECT' and 'INSERT'. Other users should only use roles provided by their Cloud Spanner admins. The database role name must start with a letter, and can only contain letters, numbers, and underscores. For more details, see https://cloud.google.com/spanner/docs/fgac-about.`, |
| }, |
| "max_parallelism": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `Allows setting max parallelism per query when executing on Spanner independent compute resources. If unspecified, default values of parallelism are chosen that are dependent on the Cloud Spanner instance configuration. 'useParallelism' and 'useDataBoost' must be set when setting max parallelism.`, |
| RequiredWith: []string{"cloud_spanner.0.use_data_boost", "cloud_spanner.0.use_parallelism"}, |
| }, |
| "use_data_boost": { |
| Type: schema.TypeBool, |
| Optional: true, |
| Description: `If set, the request will be executed via Spanner independent compute resources. 'use_parallelism' must be set when using data boost.`, |
| RequiredWith: []string{"cloud_spanner.0.use_parallelism"}, |
| }, |
| "use_parallelism": { |
| Type: schema.TypeBool, |
| Optional: true, |
| Description: `If parallelism should be used when reading from Cloud Spanner.`, |
| }, |
| "use_serverless_analytics": { |
| Type: schema.TypeBool, |
| Optional: true, |
| Deprecated: "`useServerlessAnalytics` is deprecated and will be removed in a future major release. Use `useDataBoost` instead.", |
| Description: `If the serverless analytics service should be used to read data from Cloud Spanner. 'useParallelism' must be set when using serverless analytics.`, |
| }, |
| }, |
| }, |
| ExactlyOneOf: []string{"cloud_sql", "aws", "azure", "cloud_spanner", "cloud_resource", "spark"}, |
| }, |
| "cloud_sql": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Connection properties specific to the Cloud SQL.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "credential": { |
| Type: schema.TypeList, |
| Required: true, |
| Description: `Cloud SQL properties.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "password": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `Password for database.`, |
| Sensitive: true, |
| }, |
| "username": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `Username for database.`, |
| }, |
| }, |
| }, |
| }, |
| "database": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `Database name.`, |
| }, |
| "instance_id": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `Cloud SQL instance ID in the form project:location:instance.`, |
| }, |
| "type": { |
| Type: schema.TypeString, |
| Required: true, |
| ValidateFunc: verify.ValidateEnum([]string{"DATABASE_TYPE_UNSPECIFIED", "POSTGRES", "MYSQL"}), |
| Description: `Type of the Cloud SQL database. Possible values: ["DATABASE_TYPE_UNSPECIFIED", "POSTGRES", "MYSQL"]`, |
| }, |
| "service_account_id": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `When the connection is used in the context of an operation in BigQuery, this service account will serve as the identity being used for connecting to the CloudSQL instance specified in this connection.`, |
| }, |
| }, |
| }, |
| ExactlyOneOf: []string{"cloud_sql", "aws", "azure", "cloud_spanner", "cloud_resource", "spark"}, |
| }, |
| "connection_id": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| ForceNew: true, |
| Description: `Optional connection id that should be assigned to the created connection.`, |
| }, |
| "description": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `A descriptive description for the connection`, |
| }, |
| "friendly_name": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `A descriptive name for the connection`, |
| }, |
| "kms_key_name": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `Optional. The Cloud KMS key that is used for encryption. |
| |
| Example: projects/[kms_project_id]/locations/[region]/keyRings/[key_region]/cryptoKeys/[key]`, |
| }, |
| "location": { |
| Type: schema.TypeString, |
| Optional: true, |
| ForceNew: true, |
| Description: `The geographic location where the connection should reside. |
| Cloud SQL instance must be in the same location as the connection |
| with following exceptions: Cloud SQL us-central1 maps to BigQuery US, Cloud SQL europe-west1 maps to BigQuery EU. |
| Examples: US, EU, asia-northeast1, us-central1, europe-west1. |
| Spanner Connections same as spanner region |
| AWS allowed regions are aws-us-east-1 |
| Azure allowed regions are azure-eastus2`, |
| }, |
| "spark": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Container for connection properties to execute stored procedures for Apache Spark. resources.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "metastore_service_config": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Dataproc Metastore Service configuration for the connection.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "metastore_service": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `Resource name of an existing Dataproc Metastore service in the form of projects/[projectId]/locations/[region]/services/[serviceId].`, |
| }, |
| }, |
| }, |
| }, |
| "spark_history_server_config": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Spark History Server configuration for the connection.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "dataproc_cluster": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `Resource name of an existing Dataproc Cluster to act as a Spark History Server for the connection if the form of projects/[projectId]/regions/[region]/clusters/[cluster_name].`, |
| }, |
| }, |
| }, |
| }, |
| "service_account_id": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The account ID of the service created for the purpose of this connection.`, |
| }, |
| }, |
| }, |
| ExactlyOneOf: []string{"cloud_sql", "aws", "azure", "cloud_spanner", "cloud_resource", "spark"}, |
| }, |
| "has_credential": { |
| Type: schema.TypeBool, |
| Computed: true, |
| Description: `True if the connection has credential assigned.`, |
| }, |
| "name": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `The resource name of the connection in the form of: |
| "projects/{project_id}/locations/{location_id}/connections/{connectionId}"`, |
| }, |
| "project": { |
| Type: schema.TypeString, |
| Optional: true, |
| Computed: true, |
| ForceNew: true, |
| }, |
| }, |
| UseJSONNumber: true, |
| } |
| } |
| |
| func resourceBigqueryConnectionConnectionCreate(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{}) |
| connection_idProp, err := expandBigqueryConnectionConnectionConnectionId(d.Get("connection_id"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("connection_id"); !tpgresource.IsEmptyValue(reflect.ValueOf(connection_idProp)) && (ok || !reflect.DeepEqual(v, connection_idProp)) { |
| obj["connection_id"] = connection_idProp |
| } |
| friendlyNameProp, err := expandBigqueryConnectionConnectionFriendlyName(d.Get("friendly_name"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("friendly_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(friendlyNameProp)) && (ok || !reflect.DeepEqual(v, friendlyNameProp)) { |
| obj["friendlyName"] = friendlyNameProp |
| } |
| descriptionProp, err := expandBigqueryConnectionConnectionDescription(d.Get("description"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("description"); !tpgresource.IsEmptyValue(reflect.ValueOf(descriptionProp)) && (ok || !reflect.DeepEqual(v, descriptionProp)) { |
| obj["description"] = descriptionProp |
| } |
| kmsKeyNameProp, err := expandBigqueryConnectionConnectionKmsKeyName(d.Get("kms_key_name"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("kms_key_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(kmsKeyNameProp)) && (ok || !reflect.DeepEqual(v, kmsKeyNameProp)) { |
| obj["kmsKeyName"] = kmsKeyNameProp |
| } |
| cloudSqlProp, err := expandBigqueryConnectionConnectionCloudSql(d.Get("cloud_sql"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("cloud_sql"); !tpgresource.IsEmptyValue(reflect.ValueOf(cloudSqlProp)) && (ok || !reflect.DeepEqual(v, cloudSqlProp)) { |
| obj["cloudSql"] = cloudSqlProp |
| } |
| awsProp, err := expandBigqueryConnectionConnectionAws(d.Get("aws"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("aws"); !tpgresource.IsEmptyValue(reflect.ValueOf(awsProp)) && (ok || !reflect.DeepEqual(v, awsProp)) { |
| obj["aws"] = awsProp |
| } |
| azureProp, err := expandBigqueryConnectionConnectionAzure(d.Get("azure"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("azure"); !tpgresource.IsEmptyValue(reflect.ValueOf(azureProp)) && (ok || !reflect.DeepEqual(v, azureProp)) { |
| obj["azure"] = azureProp |
| } |
| cloudSpannerProp, err := expandBigqueryConnectionConnectionCloudSpanner(d.Get("cloud_spanner"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("cloud_spanner"); !tpgresource.IsEmptyValue(reflect.ValueOf(cloudSpannerProp)) && (ok || !reflect.DeepEqual(v, cloudSpannerProp)) { |
| obj["cloudSpanner"] = cloudSpannerProp |
| } |
| cloudResourceProp, err := expandBigqueryConnectionConnectionCloudResource(d.Get("cloud_resource"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("cloud_resource"); ok || !reflect.DeepEqual(v, cloudResourceProp) { |
| obj["cloudResource"] = cloudResourceProp |
| } |
| sparkProp, err := expandBigqueryConnectionConnectionSpark(d.Get("spark"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("spark"); ok || !reflect.DeepEqual(v, sparkProp) { |
| obj["spark"] = sparkProp |
| } |
| |
| obj, err = resourceBigqueryConnectionConnectionEncoder(d, meta, obj) |
| if err != nil { |
| return err |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{BigqueryConnectionBasePath}}projects/{{project}}/locations/{{location}}/connections?connectionId={{connection_id}}") |
| if err != nil { |
| return err |
| } |
| |
| log.Printf("[DEBUG] Creating new Connection: %#v", obj) |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for Connection: %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 Connection: %s", err) |
| } |
| if err := d.Set("name", flattenBigqueryConnectionConnectionName(res["name"], d, config)); err != nil { |
| return fmt.Errorf(`Error setting computed identity field "name": %s`, err) |
| } |
| |
| // Store the ID now |
| id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{location}}/connections/{{connection_id}}") |
| if err != nil { |
| return fmt.Errorf("Error constructing id: %s", err) |
| } |
| d.SetId(id) |
| |
| if tpgresource.IsEmptyValue(reflect.ValueOf(d.Get("connection_id"))) { |
| // connection id is set by API when unset and required to GET the connection |
| // it is set by reading the "name" field rather than a field in the response |
| if err := d.Set("connection_id", flattenBigqueryConnectionConnectionConnectionId("", d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| } |
| |
| // Reset id to make sure connection_id is not empty |
| id2, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{location}}/connections/{{connection_id}}") |
| if err != nil { |
| return fmt.Errorf("Error constructing id: %s", err) |
| } |
| d.SetId(id2) |
| |
| log.Printf("[DEBUG] Finished creating Connection %q: %#v", d.Id(), res) |
| |
| return resourceBigqueryConnectionConnectionRead(d, meta) |
| } |
| |
| func resourceBigqueryConnectionConnectionRead(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, "{{BigqueryConnectionBasePath}}projects/{{project}}/locations/{{location}}/connections/{{connection_id}}") |
| if err != nil { |
| return err |
| } |
| |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for Connection: %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("BigqueryConnectionConnection %q", d.Id())) |
| } |
| |
| if err := d.Set("project", project); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| |
| if err := d.Set("name", flattenBigqueryConnectionConnectionName(res["name"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("connection_id", flattenBigqueryConnectionConnectionConnectionId(res["connection_id"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("friendly_name", flattenBigqueryConnectionConnectionFriendlyName(res["friendlyName"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("description", flattenBigqueryConnectionConnectionDescription(res["description"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("has_credential", flattenBigqueryConnectionConnectionHasCredential(res["hasCredential"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("kms_key_name", flattenBigqueryConnectionConnectionKmsKeyName(res["kmsKeyName"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("cloud_sql", flattenBigqueryConnectionConnectionCloudSql(res["cloudSql"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("aws", flattenBigqueryConnectionConnectionAws(res["aws"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("azure", flattenBigqueryConnectionConnectionAzure(res["azure"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("cloud_spanner", flattenBigqueryConnectionConnectionCloudSpanner(res["cloudSpanner"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("cloud_resource", flattenBigqueryConnectionConnectionCloudResource(res["cloudResource"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| if err := d.Set("spark", flattenBigqueryConnectionConnectionSpark(res["spark"], d, config)); err != nil { |
| return fmt.Errorf("Error reading Connection: %s", err) |
| } |
| |
| return nil |
| } |
| |
| func resourceBigqueryConnectionConnectionUpdate(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 Connection: %s", err) |
| } |
| billingProject = project |
| |
| obj := make(map[string]interface{}) |
| friendlyNameProp, err := expandBigqueryConnectionConnectionFriendlyName(d.Get("friendly_name"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("friendly_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, friendlyNameProp)) { |
| obj["friendlyName"] = friendlyNameProp |
| } |
| descriptionProp, err := expandBigqueryConnectionConnectionDescription(d.Get("description"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("description"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, descriptionProp)) { |
| obj["description"] = descriptionProp |
| } |
| kmsKeyNameProp, err := expandBigqueryConnectionConnectionKmsKeyName(d.Get("kms_key_name"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("kms_key_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, kmsKeyNameProp)) { |
| obj["kmsKeyName"] = kmsKeyNameProp |
| } |
| cloudSqlProp, err := expandBigqueryConnectionConnectionCloudSql(d.Get("cloud_sql"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("cloud_sql"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, cloudSqlProp)) { |
| obj["cloudSql"] = cloudSqlProp |
| } |
| awsProp, err := expandBigqueryConnectionConnectionAws(d.Get("aws"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("aws"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, awsProp)) { |
| obj["aws"] = awsProp |
| } |
| azureProp, err := expandBigqueryConnectionConnectionAzure(d.Get("azure"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("azure"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, azureProp)) { |
| obj["azure"] = azureProp |
| } |
| cloudSpannerProp, err := expandBigqueryConnectionConnectionCloudSpanner(d.Get("cloud_spanner"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("cloud_spanner"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, cloudSpannerProp)) { |
| obj["cloudSpanner"] = cloudSpannerProp |
| } |
| cloudResourceProp, err := expandBigqueryConnectionConnectionCloudResource(d.Get("cloud_resource"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("cloud_resource"); ok || !reflect.DeepEqual(v, cloudResourceProp) { |
| obj["cloudResource"] = cloudResourceProp |
| } |
| sparkProp, err := expandBigqueryConnectionConnectionSpark(d.Get("spark"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("spark"); ok || !reflect.DeepEqual(v, sparkProp) { |
| obj["spark"] = sparkProp |
| } |
| |
| obj, err = resourceBigqueryConnectionConnectionEncoder(d, meta, obj) |
| if err != nil { |
| return err |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{BigqueryConnectionBasePath}}projects/{{project}}/locations/{{location}}/connections/{{connection_id}}") |
| if err != nil { |
| return err |
| } |
| |
| log.Printf("[DEBUG] Updating Connection %q: %#v", d.Id(), obj) |
| headers := make(http.Header) |
| updateMask := []string{} |
| |
| if d.HasChange("friendly_name") { |
| updateMask = append(updateMask, "friendlyName") |
| } |
| |
| if d.HasChange("description") { |
| updateMask = append(updateMask, "description") |
| } |
| |
| if d.HasChange("kms_key_name") { |
| updateMask = append(updateMask, "kmsKeyName") |
| } |
| |
| if d.HasChange("cloud_sql") { |
| updateMask = append(updateMask, "cloudSql") |
| } |
| |
| if d.HasChange("aws") { |
| updateMask = append(updateMask, "aws.access_role.iam_role_id") |
| } |
| |
| if d.HasChange("azure") { |
| updateMask = append(updateMask, "azure.customer_tenant_id", |
| "azure.federated_application_client_id") |
| } |
| |
| if d.HasChange("cloud_spanner") { |
| updateMask = append(updateMask, "cloudSpanner") |
| } |
| |
| if d.HasChange("cloud_resource") { |
| updateMask = append(updateMask, "cloudResource") |
| } |
| |
| if d.HasChange("spark") { |
| updateMask = append(updateMask, "spark") |
| } |
| // 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 Connection %q: %s", d.Id(), err) |
| } else { |
| log.Printf("[DEBUG] Finished updating Connection %q: %#v", d.Id(), res) |
| } |
| |
| } |
| |
| return resourceBigqueryConnectionConnectionRead(d, meta) |
| } |
| |
| func resourceBigqueryConnectionConnectionDelete(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 Connection: %s", err) |
| } |
| billingProject = project |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{BigqueryConnectionBasePath}}projects/{{project}}/locations/{{location}}/connections/{{connection_id}}") |
| 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 Connection %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, "Connection") |
| } |
| |
| log.Printf("[DEBUG] Finished deleting Connection %q: %#v", d.Id(), res) |
| return nil |
| } |
| |
| func resourceBigqueryConnectionConnectionImport(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { |
| config := meta.(*transport_tpg.Config) |
| if err := tpgresource.ParseImportId([]string{ |
| "^projects/(?P<project>[^/]+)/locations/(?P<location>[^/]+)/connections/(?P<connection_id>[^/]+)$", |
| "^(?P<project>[^/]+)/(?P<location>[^/]+)/(?P<connection_id>[^/]+)$", |
| "^(?P<location>[^/]+)/(?P<connection_id>[^/]+)$", |
| }, d, config); err != nil { |
| return nil, err |
| } |
| |
| // Replace import id for the resource id |
| id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{location}}/connections/{{connection_id}}") |
| if err != nil { |
| return nil, fmt.Errorf("Error constructing id: %s", err) |
| } |
| d.SetId(id) |
| |
| return []*schema.ResourceData{d}, nil |
| } |
| |
| func flattenBigqueryConnectionConnectionName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionConnectionId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| parts := strings.Split(d.Get("name").(string), "/") |
| return parts[len(parts)-1] |
| } |
| |
| func flattenBigqueryConnectionConnectionFriendlyName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionDescription(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionHasCredential(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionKmsKeyName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSql(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["instance_id"] = |
| flattenBigqueryConnectionConnectionCloudSqlInstanceId(original["instanceId"], d, config) |
| transformed["database"] = |
| flattenBigqueryConnectionConnectionCloudSqlDatabase(original["database"], d, config) |
| transformed["credential"] = |
| flattenBigqueryConnectionConnectionCloudSqlCredential(original["credential"], d, config) |
| transformed["type"] = |
| flattenBigqueryConnectionConnectionCloudSqlType(original["type"], d, config) |
| transformed["service_account_id"] = |
| flattenBigqueryConnectionConnectionCloudSqlServiceAccountId(original["serviceAccountId"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenBigqueryConnectionConnectionCloudSqlInstanceId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSqlDatabase(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSqlCredential(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return []interface{}{ |
| map[string]interface{}{ |
| "username": d.Get("cloud_sql.0.credential.0.username"), |
| "password": d.Get("cloud_sql.0.credential.0.password"), |
| }, |
| } |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSqlType(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSqlServiceAccountId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionAws(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["access_role"] = |
| flattenBigqueryConnectionConnectionAwsAccessRole(original["accessRole"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenBigqueryConnectionConnectionAwsAccessRole(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["iam_role_id"] = |
| flattenBigqueryConnectionConnectionAwsAccessRoleIamRoleId(original["iamRoleId"], d, config) |
| transformed["identity"] = |
| flattenBigqueryConnectionConnectionAwsAccessRoleIdentity(original["identity"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenBigqueryConnectionConnectionAwsAccessRoleIamRoleId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionAwsAccessRoleIdentity(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionAzure(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["application"] = |
| flattenBigqueryConnectionConnectionAzureApplication(original["application"], d, config) |
| transformed["client_id"] = |
| flattenBigqueryConnectionConnectionAzureClientId(original["clientId"], d, config) |
| transformed["object_id"] = |
| flattenBigqueryConnectionConnectionAzureObjectId(original["objectId"], d, config) |
| transformed["customer_tenant_id"] = |
| flattenBigqueryConnectionConnectionAzureCustomerTenantId(original["customerTenantId"], d, config) |
| transformed["federated_application_client_id"] = |
| flattenBigqueryConnectionConnectionAzureFederatedApplicationClientId(original["federatedApplicationClientId"], d, config) |
| transformed["redirect_uri"] = |
| flattenBigqueryConnectionConnectionAzureRedirectUri(original["redirectUri"], d, config) |
| transformed["identity"] = |
| flattenBigqueryConnectionConnectionAzureIdentity(original["identity"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenBigqueryConnectionConnectionAzureApplication(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionAzureClientId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionAzureObjectId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionAzureCustomerTenantId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionAzureFederatedApplicationClientId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionAzureRedirectUri(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionAzureIdentity(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSpanner(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["database"] = |
| flattenBigqueryConnectionConnectionCloudSpannerDatabase(original["database"], d, config) |
| transformed["use_parallelism"] = |
| flattenBigqueryConnectionConnectionCloudSpannerUseParallelism(original["useParallelism"], d, config) |
| transformed["max_parallelism"] = |
| flattenBigqueryConnectionConnectionCloudSpannerMaxParallelism(original["maxParallelism"], d, config) |
| transformed["use_data_boost"] = |
| flattenBigqueryConnectionConnectionCloudSpannerUseDataBoost(original["useDataBoost"], d, config) |
| transformed["database_role"] = |
| flattenBigqueryConnectionConnectionCloudSpannerDatabaseRole(original["databaseRole"], d, config) |
| transformed["use_serverless_analytics"] = |
| flattenBigqueryConnectionConnectionCloudSpannerUseServerlessAnalytics(original["useServerlessAnalytics"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenBigqueryConnectionConnectionCloudSpannerDatabase(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSpannerUseParallelism(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSpannerMaxParallelism(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 flattenBigqueryConnectionConnectionCloudSpannerUseDataBoost(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSpannerDatabaseRole(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudSpannerUseServerlessAnalytics(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionCloudResource(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["service_account_id"] = |
| flattenBigqueryConnectionConnectionCloudResourceServiceAccountId(original["serviceAccountId"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenBigqueryConnectionConnectionCloudResourceServiceAccountId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionSpark(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["service_account_id"] = |
| flattenBigqueryConnectionConnectionSparkServiceAccountId(original["serviceAccountId"], d, config) |
| transformed["metastore_service_config"] = |
| flattenBigqueryConnectionConnectionSparkMetastoreServiceConfig(original["metastoreServiceConfig"], d, config) |
| transformed["spark_history_server_config"] = |
| flattenBigqueryConnectionConnectionSparkSparkHistoryServerConfig(original["sparkHistoryServerConfig"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenBigqueryConnectionConnectionSparkServiceAccountId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionSparkMetastoreServiceConfig(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["metastore_service"] = |
| flattenBigqueryConnectionConnectionSparkMetastoreServiceConfigMetastoreService(original["metastoreService"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenBigqueryConnectionConnectionSparkMetastoreServiceConfigMetastoreService(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenBigqueryConnectionConnectionSparkSparkHistoryServerConfig(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["dataproc_cluster"] = |
| flattenBigqueryConnectionConnectionSparkSparkHistoryServerConfigDataprocCluster(original["dataprocCluster"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenBigqueryConnectionConnectionSparkSparkHistoryServerConfigDataprocCluster(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func expandBigqueryConnectionConnectionConnectionId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionFriendlyName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionDescription(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionKmsKeyName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSql(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{}) |
| |
| transformedInstanceId, err := expandBigqueryConnectionConnectionCloudSqlInstanceId(original["instance_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedInstanceId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["instanceId"] = transformedInstanceId |
| } |
| |
| transformedDatabase, err := expandBigqueryConnectionConnectionCloudSqlDatabase(original["database"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedDatabase); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["database"] = transformedDatabase |
| } |
| |
| transformedCredential, err := expandBigqueryConnectionConnectionCloudSqlCredential(original["credential"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedCredential); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["credential"] = transformedCredential |
| } |
| |
| transformedType, err := expandBigqueryConnectionConnectionCloudSqlType(original["type"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedType); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["type"] = transformedType |
| } |
| |
| transformedServiceAccountId, err := expandBigqueryConnectionConnectionCloudSqlServiceAccountId(original["service_account_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedServiceAccountId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["serviceAccountId"] = transformedServiceAccountId |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSqlInstanceId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSqlDatabase(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSqlCredential(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 := expandBigqueryConnectionConnectionCloudSqlCredentialUsername(original["username"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedUsername); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["username"] = transformedUsername |
| } |
| |
| transformedPassword, err := expandBigqueryConnectionConnectionCloudSqlCredentialPassword(original["password"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedPassword); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["password"] = transformedPassword |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSqlCredentialUsername(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSqlCredentialPassword(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSqlType(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSqlServiceAccountId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAws(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{}) |
| |
| transformedAccessRole, err := expandBigqueryConnectionConnectionAwsAccessRole(original["access_role"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedAccessRole); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["accessRole"] = transformedAccessRole |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAwsAccessRole(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{}) |
| |
| transformedIamRoleId, err := expandBigqueryConnectionConnectionAwsAccessRoleIamRoleId(original["iam_role_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedIamRoleId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["iamRoleId"] = transformedIamRoleId |
| } |
| |
| transformedIdentity, err := expandBigqueryConnectionConnectionAwsAccessRoleIdentity(original["identity"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedIdentity); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["identity"] = transformedIdentity |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAwsAccessRoleIamRoleId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAwsAccessRoleIdentity(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAzure(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{}) |
| |
| transformedApplication, err := expandBigqueryConnectionConnectionAzureApplication(original["application"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedApplication); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["application"] = transformedApplication |
| } |
| |
| transformedClientId, err := expandBigqueryConnectionConnectionAzureClientId(original["client_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedClientId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["clientId"] = transformedClientId |
| } |
| |
| transformedObjectId, err := expandBigqueryConnectionConnectionAzureObjectId(original["object_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedObjectId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["objectId"] = transformedObjectId |
| } |
| |
| transformedCustomerTenantId, err := expandBigqueryConnectionConnectionAzureCustomerTenantId(original["customer_tenant_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedCustomerTenantId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["customerTenantId"] = transformedCustomerTenantId |
| } |
| |
| transformedFederatedApplicationClientId, err := expandBigqueryConnectionConnectionAzureFederatedApplicationClientId(original["federated_application_client_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedFederatedApplicationClientId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["federatedApplicationClientId"] = transformedFederatedApplicationClientId |
| } |
| |
| transformedRedirectUri, err := expandBigqueryConnectionConnectionAzureRedirectUri(original["redirect_uri"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedRedirectUri); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["redirectUri"] = transformedRedirectUri |
| } |
| |
| transformedIdentity, err := expandBigqueryConnectionConnectionAzureIdentity(original["identity"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedIdentity); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["identity"] = transformedIdentity |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAzureApplication(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAzureClientId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAzureObjectId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAzureCustomerTenantId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAzureFederatedApplicationClientId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAzureRedirectUri(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionAzureIdentity(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSpanner(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{}) |
| |
| transformedDatabase, err := expandBigqueryConnectionConnectionCloudSpannerDatabase(original["database"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedDatabase); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["database"] = transformedDatabase |
| } |
| |
| transformedUseParallelism, err := expandBigqueryConnectionConnectionCloudSpannerUseParallelism(original["use_parallelism"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedUseParallelism); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["useParallelism"] = transformedUseParallelism |
| } |
| |
| transformedMaxParallelism, err := expandBigqueryConnectionConnectionCloudSpannerMaxParallelism(original["max_parallelism"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxParallelism); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxParallelism"] = transformedMaxParallelism |
| } |
| |
| transformedUseDataBoost, err := expandBigqueryConnectionConnectionCloudSpannerUseDataBoost(original["use_data_boost"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedUseDataBoost); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["useDataBoost"] = transformedUseDataBoost |
| } |
| |
| transformedDatabaseRole, err := expandBigqueryConnectionConnectionCloudSpannerDatabaseRole(original["database_role"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedDatabaseRole); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["databaseRole"] = transformedDatabaseRole |
| } |
| |
| transformedUseServerlessAnalytics, err := expandBigqueryConnectionConnectionCloudSpannerUseServerlessAnalytics(original["use_serverless_analytics"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedUseServerlessAnalytics); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["useServerlessAnalytics"] = transformedUseServerlessAnalytics |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSpannerDatabase(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSpannerUseParallelism(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSpannerMaxParallelism(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSpannerUseDataBoost(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSpannerDatabaseRole(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudSpannerUseServerlessAnalytics(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudResource(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{}) |
| |
| transformedServiceAccountId, err := expandBigqueryConnectionConnectionCloudResourceServiceAccountId(original["service_account_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedServiceAccountId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["serviceAccountId"] = transformedServiceAccountId |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionCloudResourceServiceAccountId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionSpark(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{}) |
| |
| transformedServiceAccountId, err := expandBigqueryConnectionConnectionSparkServiceAccountId(original["service_account_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedServiceAccountId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["serviceAccountId"] = transformedServiceAccountId |
| } |
| |
| transformedMetastoreServiceConfig, err := expandBigqueryConnectionConnectionSparkMetastoreServiceConfig(original["metastore_service_config"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMetastoreServiceConfig); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["metastoreServiceConfig"] = transformedMetastoreServiceConfig |
| } |
| |
| transformedSparkHistoryServerConfig, err := expandBigqueryConnectionConnectionSparkSparkHistoryServerConfig(original["spark_history_server_config"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedSparkHistoryServerConfig); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["sparkHistoryServerConfig"] = transformedSparkHistoryServerConfig |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionSparkServiceAccountId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionSparkMetastoreServiceConfig(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{}) |
| |
| transformedMetastoreService, err := expandBigqueryConnectionConnectionSparkMetastoreServiceConfigMetastoreService(original["metastore_service"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMetastoreService); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["metastoreService"] = transformedMetastoreService |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionSparkMetastoreServiceConfigMetastoreService(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandBigqueryConnectionConnectionSparkSparkHistoryServerConfig(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{}) |
| |
| transformedDataprocCluster, err := expandBigqueryConnectionConnectionSparkSparkHistoryServerConfigDataprocCluster(original["dataproc_cluster"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedDataprocCluster); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["dataprocCluster"] = transformedDataprocCluster |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandBigqueryConnectionConnectionSparkSparkHistoryServerConfigDataprocCluster(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func resourceBigqueryConnectionConnectionEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) { |
| // connection_id is needed to qualify the URL but cannot be sent in the body |
| delete(obj, "connection_id") |
| return obj, nil |
| } |
