public/terraform-provider-google
0
0
Fork 0
mirror of https://github.com/letic/terraform-provider-google.git synced 2024-07-03 08:42:39 +00:00
Code Issues Projects Releases Wiki Activity

Make google_sql_database_instance authoritative. (#2203)

Browse Source
This commit is contained in:
Riley Karson 2018-10-11 10:07:50 -07:00 committed by Nathan McKinley
parent 22ecabd739
commit 5eab9af814
1 changed files with 8 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

267
google/resource_sql_database_instance.go
View File

@ -528,6 +528,8 @@ func expandSqlDatabaseInstanceSettings(configured []interface{}, secondGen bool)
_settings := configured[0].(map[string]interface{})
settings := &sqladmin.Settings{
// Version is unset in Create but is set during update
SettingsVersion: int64(_settings["version"].(int)),
Tier: _settings["tier"].(string),
ForceSendFields: []string{"StorageAutoResize"},
ActivationPolicy: _settings["activation_policy"].(string),
@ -701,10 +703,7 @@ func resourceSqlDatabaseInstanceRead(d *schema.ResourceData, meta interface{}) e
}
if len(ipAddresses) > 0 {
firstIpAddress := ipAddresses[0]["ip_address"]
if err := d.Set("first_ip_address", firstIpAddress); err != nil {
log.Printf("[WARN] Failed to set SQL Database Instance First IP Address")
}
d.Set("first_ip_address", ipAddresses[0]["ip_address"])
}
if err := d.Set("server_ca_cert", flattenServerCaCert(instance.ServerCaCert)); err != nil {
@ -727,261 +726,11 @@ func resourceSqlDatabaseInstanceUpdate(d *schema.ResourceData, meta interface{})
return err
}
d.Partial(true)
instance, err := config.clientSqlAdmin.Instances.Get(project,
d.Get("name").(string)).Do()
if err != nil {
return fmt.Errorf("Error retrieving instance %s: %s",
d.Get("name").(string), err)
// Update only updates the settings, so they are all we need to set.
instance := &sqladmin.DatabaseInstance{
Settings: expandSqlDatabaseInstanceSettings(d.Get("settings").([]interface{}), !isFirstGen(d)),
}
if d.HasChange("settings") {
_oListCast, _settingsListCast := d.GetChange("settings")
_oList := _oListCast.([]interface{})
_o := _oList[0].(map[string]interface{})
_settingsList := _settingsListCast.([]interface{})
_settings := _settingsList[0].(map[string]interface{})
settings := &sqladmin.Settings{
Tier: _settings["tier"].(string),
SettingsVersion: instance.Settings.SettingsVersion,
ForceSendFields: []string{"StorageAutoResize"},
}
if !isFirstGen(d) {
autoResize := _settings["disk_autoresize"].(bool)
settings.StorageAutoResize = &autoResize
}
if v, ok := _settings["activation_policy"]; ok {
settings.ActivationPolicy = v.(string)
}
if v, ok := _settings["authorized_gae_applications"]; ok {
settings.AuthorizedGaeApplications = make([]string, 0)
for _, app := range v.([]interface{}) {
settings.AuthorizedGaeApplications = append(settings.AuthorizedGaeApplications,
app.(string))
}
}
if v, ok := _settings["availability_type"]; ok {
settings.AvailabilityType = v.(string)
}
if v, ok := _settings["backup_configuration"]; ok {
_backupConfigurationList := v.([]interface{})
settings.BackupConfiguration = &sqladmin.BackupConfiguration{}
if len(_backupConfigurationList) == 1 && _backupConfigurationList[0] != nil {
_backupConfiguration := _backupConfigurationList[0].(map[string]interface{})
if vp, okp := _backupConfiguration["binary_log_enabled"]; okp {
settings.BackupConfiguration.BinaryLogEnabled = vp.(bool)
}
if vp, okp := _backupConfiguration["enabled"]; okp {
settings.BackupConfiguration.Enabled = vp.(bool)
}
if vp, okp := _backupConfiguration["start_time"]; okp {
settings.BackupConfiguration.StartTime = vp.(string)
}
}
}
if v, ok := _settings["crash_safe_replication"]; ok {
settings.CrashSafeReplicationEnabled = v.(bool)
}
if v, ok := _settings["disk_size"]; ok {
if v.(int) > 0 && int64(v.(int)) > instance.Settings.DataDiskSizeGb {
settings.DataDiskSizeGb = int64(v.(int))
}
}
if v, ok := _settings["disk_type"]; ok && len(v.(string)) > 0 {
settings.DataDiskType = v.(string)
}
_oldDatabaseFlags := make([]interface{}, 0)
if ov, ook := _o["database_flags"]; ook {
_oldDatabaseFlags = ov.([]interface{})
}
if v, ok := _settings["database_flags"]; ok || len(_oldDatabaseFlags) > 0 {
oldDatabaseFlags := settings.DatabaseFlags
settings.DatabaseFlags = make([]*sqladmin.DatabaseFlags, 0)
_databaseFlagsList := make([]interface{}, 0)
if v != nil {
_databaseFlagsList = v.([]interface{})
}
_odbf_map := make(map[string]interface{})
for _, _dbf := range _oldDatabaseFlags {
_entry := _dbf.(map[string]interface{})
_odbf_map[_entry["name"].(string)] = true
}
// First read the flags from the server, and reinsert those that
// were not previously defined
for _, entry := range oldDatabaseFlags {
_, ok_old := _odbf_map[entry.Name]
if !ok_old {
settings.DatabaseFlags = append(
settings.DatabaseFlags, entry)
}
}
// finally, insert only those that were previously defined
// and are still defined.
for _, _flag := range _databaseFlagsList {
_entry := _flag.(map[string]interface{})
flag := &sqladmin.DatabaseFlags{}
if vp, okp := _entry["name"]; okp {
flag.Name = vp.(string)
}
if vp, okp := _entry["value"]; okp {
flag.Value = vp.(string)
}
settings.DatabaseFlags = append(settings.DatabaseFlags, flag)
}
}
if v, ok := _settings["ip_configuration"]; ok {
_ipConfigurationList := v.([]interface{})
settings.IpConfiguration = &sqladmin.IpConfiguration{}
if len(_ipConfigurationList) == 1 && _ipConfigurationList[0] != nil {
_ipConfiguration := _ipConfigurationList[0].(map[string]interface{})
if vp, okp := _ipConfiguration["ipv4_enabled"]; okp {
settings.IpConfiguration.Ipv4Enabled = vp.(bool)
}
if vp, okp := _ipConfiguration["require_ssl"]; okp {
settings.IpConfiguration.RequireSsl = vp.(bool)
}
_oldAuthorizedNetworkList := make([]interface{}, 0)
if ov, ook := _o["ip_configuration"]; ook {
_oldIpConfList := ov.([]interface{})
if len(_oldIpConfList) > 0 {
_oldIpConf := _oldIpConfList[0].(map[string]interface{})
if ovp, ookp := _oldIpConf["authorized_networks"]; ookp {
_oldAuthorizedNetworkList = ovp.(*schema.Set).List()
}
}
}
if vp, okp := _ipConfiguration["authorized_networks"]; okp || len(_oldAuthorizedNetworkList) > 0 {
oldAuthorizedNetworks := instance.Settings.IpConfiguration.AuthorizedNetworks
settings.IpConfiguration.AuthorizedNetworks = make([]*sqladmin.AclEntry, 0)
_authorizedNetworksList := make([]interface{}, 0)
if vp != nil {
_authorizedNetworksList = vp.(*schema.Set).List()
}
_oipc_map := make(map[string]interface{})
for _, _ipc := range _oldAuthorizedNetworkList {
_entry := _ipc.(map[string]interface{})
_oipc_map[_entry["value"].(string)] = true
}
// Next read the network tuples from the server, and reinsert those that
// were not previously defined
for _, entry := range oldAuthorizedNetworks {
_, ok_old := _oipc_map[entry.Value]
if !ok_old {
settings.IpConfiguration.AuthorizedNetworks = append(
settings.IpConfiguration.AuthorizedNetworks, entry)
}
}
// finally, update old entries and insert new ones
// and are still defined.
for _, _ipc := range _authorizedNetworksList {
_entry := _ipc.(map[string]interface{})
entry := &sqladmin.AclEntry{}
if vpp, okpp := _entry["expiration_time"]; okpp {
entry.ExpirationTime = vpp.(string)
}
if vpp, okpp := _entry["name"]; okpp {
entry.Name = vpp.(string)
}
if vpp, okpp := _entry["value"]; okpp {
entry.Value = vpp.(string)
}
settings.IpConfiguration.AuthorizedNetworks = append(
settings.IpConfiguration.AuthorizedNetworks, entry)
}
}
}
}
if v, ok := _settings["location_preference"]; ok {
_locationPreferenceList := v.([]interface{})
settings.LocationPreference = &sqladmin.LocationPreference{}
if len(_locationPreferenceList) == 1 && _locationPreferenceList[0] != nil {
_locationPreference := _locationPreferenceList[0].(map[string]interface{})
if vp, okp := _locationPreference["follow_gae_application"]; okp {
settings.LocationPreference.FollowGaeApplication = vp.(string)
}
if vp, okp := _locationPreference["zone"]; okp {
settings.LocationPreference.Zone = vp.(string)
}
}
}
if v, ok := _settings["maintenance_window"]; ok && len(v.([]interface{})) > 0 {
_maintenanceWindowList := v.([]interface{})
settings.MaintenanceWindow = &sqladmin.MaintenanceWindow{}
if len(_maintenanceWindowList) == 1 && _maintenanceWindowList[0] != nil {
_maintenanceWindow := _maintenanceWindowList[0].(map[string]interface{})
if vp, okp := _maintenanceWindow["day"]; okp {
settings.MaintenanceWindow.Day = int64(vp.(int))
}
if vp, okp := _maintenanceWindow["hour"]; okp {
settings.MaintenanceWindow.Hour = int64(vp.(int))
}
if vp, ok := _maintenanceWindow["update_track"]; ok {
if len(vp.(string)) > 0 {
settings.MaintenanceWindow.UpdateTrack = vp.(string)
}
}
}
}
if v, ok := _settings["pricing_plan"]; ok {
settings.PricingPlan = v.(string)
}
if v, ok := _settings["replication_type"]; ok {
settings.ReplicationType = v.(string)
}
if v, ok := _settings["user_labels"]; ok {
settings.UserLabels = convertStringMap(v.(map[string]interface{}))
}
instance.Settings = settings
}
d.Partial(false)
// Lock on the master_instance_name just in case updating any replica
// settings causes operations on the master.
if v, ok := d.GetOk("master_instance_name"); ok {
@ -989,9 +738,9 @@ func resourceSqlDatabaseInstanceUpdate(d *schema.ResourceData, meta interface{})
defer mutexKV.Unlock(instanceMutexKey(project, v.(string)))
}
op, err := config.clientSqlAdmin.Instances.Update(project, instance.Name, instance).Do()
op, err := config.clientSqlAdmin.Instances.Update(project, d.Get("name").(string), instance).Do()
if err != nil {
return fmt.Errorf("Error, failed to update instance %s: %s", instance.Name, err)
return fmt.Errorf("Error, failed to update instance settings for %s: %s", instance.Name, err)
}
err = sqladminOperationWaitTime(config, op, project, "Update Instance", int(d.Timeout(schema.TimeoutUpdate).Minutes()))