fog-google 0.6.0 → 1.0.0

data/lib/fog/google/models/monitoring/metric_descriptors.rb

@@ -10,16 +10,33 @@ module Fog
         ##
         # Lists all Metric Descriptors.
         #
-        # @param [Hash] options Optional query parameters.
-        # @option options [String] page_size Maximum number of metric descriptors per page. Used for pagination.
-        # @option options [String] page_token The pagination token, which is used to page through large result sets.
-        # @option options [String] filter Monitoring filter specifying which metric descriptors are to be returned.
-        # @see https://cloud.google.com/monitoring/api/v3/filters filter documentation
+        # @param filter [String] Monitoring filter specifying which metric descriptors are to be returned.
+        #   @see https://cloud.google.com/monitoring/api/v3/filters filter documentation
+        # @param page_size [String] Maximum number of metric descriptors per page. Used for pagination.
+        # @param page_token [String] The pagination token, which is used to page through large result sets.
         # @return [Array<Fog::Google::Monitoring::MetricDescriptor>] List of Metric Descriptors.
-        def all(options = {})
-          data = service.list_metric_descriptors(options).body["metricDescriptors"] || []
+        def all(filter: nil, page_size: nil, page_token: nil)
+          data = service.list_metric_descriptors(
+            :filter => filter,
+            :page_size => page_size,
+            :page_token => page_token
+          ).to_h[:metric_descriptors] || []
+
           load(data)
         end
+
+        ##
+        # Get a Metric Descriptors.
+        #
+        # @param metric_type [String] Metric type. For example, "custom.googleapis.com/test-metric"
+        # @return [Fog::Google::Monitoring::MetricDescriptor] A Metric Descriptor.
+        def get(metric_type)
+          data = service.get_metric_descriptor(metric_type).to_h
+          new(data)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
       end
     end
   end

data/lib/fog/google/models/monitoring/monitored_resource_descriptors.rb

@@ -10,16 +10,27 @@ module Fog
         ##
         # Lists all Monitored Resource Descriptors.
         #
-        # @param [Hash] options Optional query parameters.
-        # @option options [String] page_size Maximum number of metric descriptors per page. Used for pagination.
-        # @option options [String] page_token The pagination token, which is used to page through large result sets.
-        # @option options [String] filter The monitoring filter used to search against existing descriptors.
-        #   See
+        # @param filter [String] The monitoring filter used to search against existing descriptors.
+        #   @see https://cloud.google.com/monitoring/api/v3/filters filter documentation
+        # @param page_size [String]  Maximum number of metric descriptors per page. Used for pagination.
+        # @param page_token [String]  The pagination token, which is used to page through large result sets.
         # @return [Array<Fog::Google::Monitoring::MetricDescriptor>] List of Monitored Resource Descriptors.
-        def all(options = {})
-          data = service.list_monitored_resource_descriptors(options).body["resourceDescriptors"] || []
+        def all(filter: nil, page_size: nil, page_token: nil)
+          data = service.list_monitored_resource_descriptors(
+            :filter => filter,
+            :page_size => page_size,
+            :page_token => page_token
+          ).to_h[:resource_descriptors] || []
           load(data)
         end
+
+        def get(resource_type)
+          data = service.get_monitored_resource_descriptor(resource_type).to_h
+          new(data)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
       end
     end
   end

data/lib/fog/google/models/monitoring/timeseries_collection.rb

@@ -10,26 +10,36 @@ module Fog
         ##
         # Lists all Timeseries.
         #
-        # @param [Hash] options Query parameters.
-        # @option [String] filter  A monitoring filter that specifies which time series should be returned.
+        # @param filter [String] A monitoring filter that specifies which time series should be returned.
         #   The filter must specify a single metric type, and can additionally specify metric labels and other
         #   information.
-        # @option options [Hash] interval Required. The time interval for which results should be returned.
+        # @param interval [Hash] Required. The time interval for which results should be returned.
         # @option interval [String] end_time Required RFC3339 timestamp marking the end of interval
-        # @option interval [String] start_time Optional RFC3339 timestamp marking start of interval.
-        # @option options [Hash] aggregation
-        # @option aggregation [String] alignment_period
-        # @option aggregation [String] cross_series_reducer
-        # @option aggregation [String] group_by_fields
-        # @option aggregation [String] per_series_aligner
-        # @option options [String] order_by
-        # @option options [String] page_size
-        # @option options [String] page_token
-        # @option options [String] view
+        # @option interval [String] start_time Required RFC3339 timestamp marking start of interval.
+        # @param aggregation [Hash] Optional object describing how to combine multiple time series to provide
+        #   different views of the data. By default, the raw time series data is returned.
+        # @option aggregation [String] alignment_period The alignment period for per-time series alignment.
+        # @option aggregation [String] cross_series_reducer The approach to be used to align individual time series.
+        # @option aggregation [String] group_by_fields The set of fields to preserve when crossSeriesReducer is specified.
+        # @option aggregation [String] per_series_aligner The approach to be used to combine time series.
+        # @param order_by [String] Specifies the order in which the points of the time series should be returned.
+        #   By default, results are not ordered. Currently, this field must be left blank.
+        # @param page_size [String]
+        # @param page_token [String]
+        # @param view [String] Specifies which information is returned about the time series.
         #
         # @return [Array<Fog::Google::Monitoring::Timeseries>] List of Timeseries.
-        def all(options = {})
-          data = service.list_timeseries(options).body["timeSeries"] || []
+        def all(filter: nil, interval: nil, aggregation: nil, order_by: nil, page_size: nil, page_token: nil, view: nil)
+          data = service.list_timeseries(
+            :filter => filter,
+            :interval => interval,
+            :aggregation => aggregation,
+            :order_by => order_by,
+            :page_size => page_size,
+            :page_token => page_token,
+            :view => view
+          ).to_h[:time_series] || []
+
           load(data)
         end
       end

data/lib/fog/google/models/pubsub/subscription.rb

@@ -30,17 +30,17 @@ module Fog
         def pull(options = { :return_immediately => true, :max_messages => 10 })
           requires :name
 
-          data = service.pull_subscription(name, options).body
+          data = service.pull_subscription(name, options).to_h
 
-          return [] unless data.key?("receivedMessages")
+          return [] unless data.key?(:received_messages)
           # Turn into a list of ReceivedMessage, but ensure we perform a base64 decode first
-          data["receivedMessages"].map do |recv_message|
+          data[:received_messages].map do |recv_message|
             attrs = {
               :service => service,
               :subscription_name => name
             }.merge(recv_message)
 
-            attrs["message"]["data"] = Base64.decode64(recv_message["message"]["data"]) if recv_message["message"].key?("data")
+            attrs[:message][:data] = Base64.decode64(recv_message[:message][:data]) if recv_message[:message].key?(:data)
             ReceivedMessage.new(attrs)
           end
         end
@@ -68,7 +68,7 @@ module Fog
         def save
           requires :name, :topic
 
-          data = service.create_subscription(name, topic, push_config, ack_deadline_seconds).body
+          data = service.create_subscription(name, topic, push_config, ack_deadline_seconds).to_h
           merge_attributes(data)
         end
 

data/lib/fog/google/models/pubsub/subscriptions.rb

@@ -12,7 +12,7 @@ module Fog
         # @return [Array<Fog::Google::Pubsub::Subscription>] list of
         #   subscriptions
         def all
-          data = service.list_subscriptions.body["subscriptions"] || []
+          data = service.list_subscriptions.to_h[:subscriptions] || []
           load(data)
         end
 
@@ -21,9 +21,10 @@ module Fog
         # @param subscription_name [String] name of subscription to retrieve
         # @return [Fog::Google::Pubsub::Topic] topic found, or nil if not found
         def get(subscription_name)
-          subscription = service.get_subscription(subscription_name).body
+          subscription = service.get_subscription(subscription_name).to_h
           new(subscription)
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

data/lib/fog/google/models/pubsub/topic.rb

@@ -47,18 +47,17 @@ module Fog
           messages.each do |message|
             encoded_message = {}
             if message.is_a?(Hash)
-              encoded_message["attributes"] = message["attributes"]
               if message.key?("data")
-                encoded_message["data"] = Base64.strict_encode64(message["data"])
+                encoded_message[:data] = Base64.strict_encode64(message["data"])
               end
             else
-              encoded_message["data"] = Base64.strict_encode64(message.to_s)
+              encoded_message[:data] = Base64.strict_encode64(message.to_s)
             end
 
             encoded_messages << encoded_message
           end
 
-          service.publish_topic(name, encoded_messages).body["messageIds"]
+          service.publish_topic(name, encoded_messages).to_h[:message_ids]
         end
 
         # Save the instance (does the same thing as #create)

data/lib/fog/google/models/pubsub/topics.rb

@@ -11,7 +11,7 @@ module Fog
         #
         # @return [Array<Fog::Google::Pubsub::Topic>] list of topics
         def all
-          data = service.list_topics.body["topics"] || []
+          data = service.list_topics.to_h[:topics] || []
           load(data)
         end
 
@@ -20,9 +20,10 @@ module Fog
         # @param topic_name [String] name of topic to retrieve
         # @return [Fog::Google::Pubsub::Topic] topic found, or nil if not found
         def get(topic_name)
-          topic = service.get_topic(topic_name).body
+          topic = service.get_topic(topic_name).to_h
           new(topic)
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

data/lib/fog/google/models/sql/backup_run.rb

@@ -6,27 +6,30 @@ module Fog
       ##
       # A database instance backup run resource
       #
-      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/backupRuns
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/backupRuns
       class BackupRun < Fog::Model
-        identity :backup_configuration, :aliases => "backupConfiguration"
+        identity :id
 
-        attribute :due_time, :aliases => "dueTime"
+        attribute :description
         attribute :end_time, :aliases => "endTime"
         attribute :enqueued_time, :aliases => "enqueuedTime"
         attribute :error
         attribute :instance
         attribute :kind
+        attribute :self_link, :aliases => "selfLink"
         attribute :start_time, :aliases => "startTime"
         attribute :status
+        attribute :type
+        attribute :window_start_time, :aliases => "windowStartTime"
 
-        DONE_STATE = "DONE"
+        READY_STATUS = "DONE".freeze
 
         ##
         # Checks if the instance backup run is done
         #
         # @return [Boolean] True if the backup run is done; False otherwise
         def ready?
-          state == DONE_STATE
+          status == READY_STATUS
         end
       end
     end

data/lib/fog/google/models/sql/backup_runs.rb

@@ -8,13 +8,12 @@ module Fog
         model Fog::Google::SQL::BackupRun
 
         ##
-        # Lists all backup runs associated with a given instance and configuration
+        # Lists all backup runs associated with a given instance.
         #
         # @param [String] instance_id Instance ID
-        # @param [String] backup_configuration_id Backup Configuration ID
         # @return [Array<Fog::Google::SQL::BackupRun>] List of Backup run resources
-        def all(instance_id, backup_configuration_id)
-          data = service.list_backup_runs(instance_id, backup_configuration_id).body["items"] || []
+        def all(instance_id)
+          data = service.list_backup_runs(instance_id).to_h[:items] || []
           load(data)
         end
 
@@ -22,14 +21,15 @@ module Fog
         # Retrieves a resource containing information about a backup run
         #
         # @param [String] instance_id Instance ID
-        # @param [String] backup_configuration_id Backup Configuration ID
-        # @param [String] due_time The time when this run is due to start in RFC 3339 format
+        # @param [String] backup_run_id Backup Configuration ID
         # @return [Fog::Google::SQL::BackupRun] Backup run resource
-        def get(instance_id, backup_configuration_id, due_time)
-          if backup_run = service.get_backup_run(instance_id, backup_configuration_id, due_time).body
+        def get(instance_id, backup_run_id)
+          backup_run = service.get_backup_run(instance_id, backup_run_id).to_h
+          if backup_run
             new(backup_run)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

data/lib/fog/google/models/sql/flag.rb

@@ -6,7 +6,7 @@ module Fog
       ##
       # A Google Cloud SQL service flag resource
       #
-      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/flags
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/flags
       class Flag < Fog::Model
         identity :name
 
@@ -15,6 +15,7 @@ module Fog
         attribute :kind
         attribute :max_value, :aliases => "maxValue"
         attribute :min_value, :aliases => "minValue"
+        attribute :requires_restart, :aliases => "requiresRestart"
         attribute :type
       end
     end

data/lib/fog/google/models/sql/flags.rb

@@ -12,7 +12,7 @@ module Fog
         #
         # @return [Array<Fog::Google::SQL::Flag>] List of flags
         def all
-          data = service.list_flags.body["items"] || []
+          data = service.list_flags.to_h[:items] || []
           load(data)
         end
       end

data/lib/fog/google/models/sql/instance.rb

@@ -4,7 +4,7 @@ module Fog
   module Google
     class SQL
       class Instance < Fog::Model
-        identity :instance
+        identity :name
 
         attribute :current_disk_size, :aliases => "currentDiskSize"
         attribute :database_version, :aliases => "databaseVersion"
@@ -20,7 +20,7 @@ module Fog
 
         # These attributes are not available in the representation of an 'Instance' returned by the Google SQL API.
         attribute :activation_policy
-        attribute :autorized_gae_applications
+        attribute :authorized_gae_applications
         attribute :backup_configuration
         attribute :database_flags
         attribute :ip_configuration_authorized_networks
@@ -33,52 +33,54 @@ module Fog
         attribute :settings_version
         attribute :tier
 
-        MAINTENANCE_STATE    = "MAINTENANCE"
-        PENDING_CREATE_STATE = "PENDING_CREATE"
-        RUNNABLE_STATE       = "RUNNABLE"
-        SUSPENDED_STATE      = "SUSPENDED"
-        UNKNOWN_STATE        = "UNKNOWN_STATE"
+        MAINTENANCE_STATE    = "MAINTENANCE".freeze
+        PENDING_CREATE_STATE = "PENDING_CREATE".freeze
+        RUNNABLE_STATE       = "RUNNABLE".freeze
+        SUSPENDED_STATE      = "SUSPENDED".freeze
+        UNKNOWN_STATE        = "UNKNOWN_STATE".freeze
 
         ##
         # Returns the activation policy for this instance
         #
         # @return [String] The activation policy for this instance
         def activation_policy
-          settings["activationPolicy"]
+          settings[:activation_policy]
         end
 
         ##
         # Returns the AppEngine app ids that can access this instance
         #
         # @return [Array<String>] The AppEngine app ids that can access this instance
-        def autorized_gae_applications
-          settings["authorizedGaeApplications"]
+        def authorized_gae_applications
+          settings[:authorized_gae_applications]
         end
 
         ##
         # Returns the daily backup configuration for the instance
         #
-        # @return [Array<Hash>] The daily backup configuration for the instance
+        # @return [Hash] The daily backup configuration for the instance
         def backup_configuration
-          settings["backupConfiguration"]
+          settings["backup_configuration"]
         end
 
         ##
         # Creates a Cloud SQL instance as a clone of the source instance
         #
         # @param [String] destination_name Name of the Cloud SQL instance to be created as a clone
-        # @param [Hash] options Method options
-        # @option options [String] :log_filename Name of the binary log file for a Cloud SQL instance
-        # @option options [Integer] :log_position Position (offset) within the binary log file
-        # @option options [Boolean] :async If the operation must be performed asynchronously (true by default)
+        # @param [Boolean] async If the operation must be performed asynchronously (true by default)
+        # @param [String] log_filename Name of the binary log file for a Cloud SQL instance
+        # @param [Integer] log_position Position (offset) within the binary log file
         # @return [Fog::Google::SQL::Operation] A Operation resource
-        def clone(destination_name, options = {})
+        def clone(destination_name, async: true, log_filename: nil, log_position: nil)
           requires :identity
 
-          data = service.clone_instance(identity, destination_name, options)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
-          operation.wait_for { ready? } unless options.fetch(:async, true)
-          operation
+          data = service.clone_instance(
+            identity, destination_name,
+            :log_filename => log_filename,
+            :log_position => log_position
+          )
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)
+          operation.tap { |o| o.wait_for { ready? } unless async }
         end
 
         ##
@@ -89,7 +91,7 @@ module Fog
           requires :identity
 
           data = service.insert_instance(identity, attributes[:tier], attributes)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)
           operation.wait_for { !pending? }
           reload
         end
@@ -99,25 +101,20 @@ module Fog
         #
         # @return [Array<Hash>] The database flags passed to the instance at startup
         def database_flags
-          settings["databaseFlags"]
+          settings[:database_flags]
         end
 
         ##
         # Deletes a Cloud SQL instance
         #
-        # @param [Hash] options Method options
-        # @option options [Boolean] :async If the operation must be performed asynchronously (true by default)
+        # @param [Boolean] :async If the operation must be performed asynchronously (true by default)
         # @return [Fog::Google::SQL::Operation] A Operation resource
-        def destroy(options = {})
+        def destroy(async: nil)
           requires :identity
 
           data = service.delete_instance(identity)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
-          unless options.fetch(:async, true)
-            # DISABLED: A delete instance operation never reachs a 'DONE' state (bug?)
-            # operation.wait_for { ready? }
-          end
-          operation
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)
+          operation.tap { |o| o.wait_for { ready? } unless async }
         end
 
         ##
@@ -132,13 +129,12 @@ module Fog
         #   If you specify tables, specify one and only one database.
         # @option options [Boolean] :async If the operation must be performed asynchronously (true by default)
         # @return [Fog::Google::SQL::Operation] A Operation resource
-        def export(uri, options = {})
+        def export(uri, options: {})
           requires :identity
 
           data = service.export_instance(identity, uri, options)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
-          operation.wait_for { ready? } unless options.fetch(:async, true)
-          operation
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)
+          operation.tap { |o| o.wait_for { ready? } unless async }
         end
 
         ##
@@ -155,9 +151,8 @@ module Fog
           requires :identity
 
           data = service.import_instance(identity, uri, options)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
-          operation.wait_for { ready? } unless options.fetch(:async, true)
-          operation
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)
+          operation.tap { |o| o.wait_for { ready? } unless options.fetch(:async, true) }
         end
 
         ##
@@ -165,23 +160,24 @@ module Fog
         #
         # @return [Array<String>] The list of external networks that are allowed to connect to the instance using the IP
         def ip_configuration_authorized_networks
-          settings.fetch("ipConfiguration", {})["authorizedNetworks"]
+          settings.fetch(:ip_configuration, {})
+                  .fetch(:authorized_networks, [])
         end
 
         ##
         # Returns whether the instance should be assigned an IP address or not
         #
         # @return [Boolean] Whether the instance should be assigned an IP address or not
-        def ip_configuration_enabled
-          settings.fetch("ipConfiguration", {})["enabled"]
+        def ip_configuration_ipv4_enabled
+          settings.fetch(:ip_configuration, {})[:ipv4_enabled]
         end
 
         ##
-        # Returns whether the mysqld should default to 'REQUIRE X509' for users connecting over IP
+        # Returns whether SSL connections over IP should be enforced or not.
         #
-        # @return [Boolean] Whether the mysqld should default to 'REQUIRE X509' for users connecting over IP
+        # @return [Boolean] Whether SSL connections over IP should be enforced or not.
         def ip_configuration_require_ssl
-          settings.fetch("ipConfiguration", {})["requireSsl"]
+          settings.fetch(:ip_configuration, {})[:require_ssl]
         end
 
         ##
@@ -189,7 +185,7 @@ module Fog
         #
         # @return [String] The AppEngine application to follow
         def location_preference_zone_follow_gae_application
-          settings.fetch("locationPreference", {})["followGaeApplication"]
+          settings.fetch(:location_preference, {})[:follow_gae_application]
         end
 
         ##
@@ -197,7 +193,7 @@ module Fog
         #
         # @return [String] The preferred Compute Engine zone
         def location_preference_zone
-          settings.fetch("locationPreference", {})["zone"]
+          settings.fetch(:location_preference, {})[:zone]
         end
 
         ##
@@ -205,7 +201,7 @@ module Fog
         #
         # @return [String] The pricing plan for this instance
         def pricing_plan
-          settings["pricingPlan"]
+          settings[:pricing_plan]
         end
 
         ##
@@ -221,54 +217,47 @@ module Fog
         #
         # @return [String] The type of replication this instance uses
         def replication_type
-          settings["replicationType"]
+          settings[:replication_type]
         end
 
         ##
         # Deletes all client certificates and generates a new server SSL certificate for the instance
         #
-        # @param [Hash] options Method options
-        # @option options [Boolean] :async If the operation must be performed asynchronously (true by default)
+        # @param [Boolean] async If the operation must be performed asynchronously (true by default)
         # @return [Fog::Google::SQL::Operation] A Operation resource
-        def reset_ssl_config(options = {})
+        def reset_ssl_config(async: true)
           requires :identity
 
           data = service.reset_instance_ssl_config(identity)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
-          operation.wait_for { ready? } unless options.fetch(:async, true)
-          operation
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)
+          operation.tap { |o| o.wait_for { ready? } unless async }
         end
 
         ##
         # Restarts a Cloud SQL instance
         #
-        # @param [Hash] options Method options
-        # @option options [Boolean] :async If the operation must be performed asynchronously (true by default)
+        # @param [Boolean] async If the operation must be performed asynchronously (true by default)
         # @return [Fog::Google::SQL::Operation] A Operation resource
-        def restart(options = {})
+        def restart(async: true)
           requires :identity
 
           data = service.restart_instance(identity)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
-          operation.wait_for { ready? } unless options.fetch(:async, true)
-          operation
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)
+          operation.tap { |o| o.wait_for { ready? } unless async }
         end
 
         ##
         # Restores a backup of a Cloud SQL instance
         #
-        # @param [String] backup_configuration The identifier of the backup configuration
-        # @param [String] due_time The time when this run is due to start in RFC 3339 format
-        # @param [Hash] options Method options
-        # @option options [Boolean] :async If the operation must be performed asynchronously (true by default)
+        # @param [String] backup_run_id The identifier of the backup configuration
+        # @param [Boolean] async If the operation must be performed asynchronously (true by default)
         # @return [Fog::Google::SQL::Operation] A Operation resource
-        def restore_backup(backup_configuration, due_time, options = {})
+        def restore_backup(backup_run_id, async: true)
           requires :identity
 
-          data = service.restore_instance_backup(identity, backup_configuration, due_time)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
-          operation.wait_for { ready? } unless options.fetch(:async, true)
-          operation
+          data = service.restore_instance_backup(identity, backup_run_id)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)
+          operation.tap { |o| o.wait_for { ready? } unless async }
         end
 
         ##
@@ -279,28 +268,12 @@ module Fog
           etag ? update : create
         end
 
-        ##
-        # Sets the password for the root user
-        #
-        # @param [String] password The password for the root user
-        # @param [Hash] options Method options
-        # @option options [Boolean] :async If the operation must be performed asynchronously (true by default)
-        # @return [Fog::Google::SQL::Operation] A Operation resource
-        def set_root_password(password, options = {})
-          requires :identity
-
-          data = service.set_instance_root_password(identity, password)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
-          operation.wait_for { ready? } unless options.fetch(:async, true)
-          operation
-        end
-
         ##
         # Returns the version of instance settings
         #
         # @return [String] The version of instance settings
         def settings_version
-          settings["settingsVersion"]
+          settings[:settings_version]
         end
 
         ##
@@ -318,7 +291,7 @@ module Fog
         #
         # @return [String] The tier of service for this instance
         def tier
-          settings["tier"]
+          settings[:tier]
         end
 
         ##
@@ -326,13 +299,25 @@ module Fog
         #
         # @return [Fog::Google::SQL::Instance] Instance resource
         def update
-          requires :identity
+          requires :identity, :settings_version, :tier
 
-          data = service.update_instance(identity, settings_version, tier, attributes)
-          operation = Fog::Google::SQL::Operations.new(:service => service).get(instance, data.body["operation"])
+          data = service.update_instance(identity, settings_version, tier, settings)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)
           operation.wait_for { !pending? }
           reload
         end
+
+        ##
+        # Reload a Cloud SQL instance
+        #
+        # @return [Fog::Google::SQL::Instance] Instance resource
+        def reload
+          requires :identity
+
+          data = collection.get(identity)
+          merge_attributes(data.attributes)
+          self
+        end
       end
     end
   end