fog-google 0.0.2

data/lib/fog/google/models/dns/records.rb

@@ -0,0 +1,52 @@
+require 'fog/core/collection'
+require 'fog/google/models/dns/record'
+
+module Fog
+  module DNS
+    class Google
+      class Records < Fog::Collection
+        model Fog::DNS::Google::Record
+
+        attribute :zone
+
+        ##
+        # Enumerates Resource Record Sets that have been created but not yet deleted
+        #
+        # @return [Array<Fog::DNS::Google::Record>] List of Resource Record Sets resources
+        def all
+          requires :zone
+
+          data = service.list_resource_record_sets(zone.identity).body['rrsets'] || []
+          load(data)
+        rescue Fog::Errors::NotFound
+          []
+        end
+
+        ##
+        # Fetches the representation of an existing Resource Record Set
+        #
+        # @param [String] name Resource Record Set name
+        # @param [String] type Resource Record Set type
+        # @return [Fog::DNS::Google::Record] Resource Record Set resource
+        def get(name, type)
+          requires :zone
+
+          records = service.list_resource_record_sets(zone.identity, { :name => name, :type => type }).body['rrsets'] || []
+          records.any? ? new(records.first) : nil
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        ##
+        # Creates a new instance of a Resource Record Set
+        #
+        # @return [Fog::DNS::Google::Record] Resource Record Set resource
+        def new(attributes = {})
+          requires :zone
+
+          super({ :zone => zone }.merge!(attributes))
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/dns/zone.rb

@@ -0,0 +1,74 @@
+require 'fog/core/model'
+
+module Fog
+  module DNS
+    class Google
+      ##
+      # Managed Zone resource
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/managedZones
+      class Zone < Fog::Model
+        identity :id
+
+        attribute :creation_time, :aliases => 'creationTime'
+        attribute :description
+        attribute :domain, :aliases => 'dnsName'
+        attribute :kind
+        attribute :name
+        attribute :nameservers, :aliases => 'nameServers'
+
+        ##
+        # Enumerates the list of Changes for the Managed Zone
+        #
+        # @return Array<Fog::DNS::Google::Change>] List of Changes for the Managed Zone
+        def changes
+          @changes = begin
+            Fog::DNS::Google::Changes.new(
+              :service => service,
+              :zone => self
+            )
+          end
+        end
+
+        ##
+        # Deletes a previously created Managed Zone
+        #
+        # @return [Boolean] If the Managed Zone has been deleted
+        def destroy
+          requires :identity
+
+          service.delete_managed_zone(self.identity)
+          true
+        end
+
+        ##
+        # Enumerates the list of Resource Record Sets for the Managed Zone
+        #
+        # @return Array<Fog::DNS::Google::Record>] List of Resource Record Sets for the Managed Zone
+        def records
+          @records = begin
+            Fog::DNS::Google::Records.new(
+              :service => service,
+              :zone => self
+            )
+          end
+        end
+
+        ##
+        # Creates a new Managed Zone
+        #
+        # @return [Fog::DNS::Google::Zone] Managed Zone
+        # @raise [Fog::Errors::Error] If Managed Zone already exists
+        def save
+          requires :name, :domain, :description
+
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+
+          data = service.create_managed_zone(self.name, self.domain, self.description)
+          merge_attributes(data.body)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/dns/zones.rb

@@ -0,0 +1,34 @@
+require 'fog/core/collection'
+require 'fog/google/models/dns/zone'
+
+module Fog
+  module DNS
+    class Google
+      class Zones < Fog::Collection
+        model Fog::DNS::Google::Zone
+
+        ##
+        # Enumerates Managed Zones that have been created but not yet deleted
+        #
+        # @return [Array<Fog::DNS::Google::Zone>] List of Managed Zone resources
+        def all
+          data = service.list_managed_zones.body['managedZones'] || []
+          load(data)
+        end
+
+        ##
+        # Fetches the representation of an existing Managed Zone
+        #
+        # @param [String] name_or_id Managed Zone name or identity
+        # @return [Fog::DNS::Google::Zone] Managed Zone resource
+        def get(name_or_id)
+          if zone = service.get_managed_zone(name_or_id).body
+            new(zone)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class Monitoring
+      ##
+      # A metricDescriptor defines the name, label keys, and data type of a particular metric.
+      #
+      # @see https://developers.google.com/cloud-monitoring/v2beta1/metricDescriptors
+      class MetricDescriptor < Fog::Model
+        identity :name
+
+        attribute :description
+        attribute :labels
+        attribute :project
+        attribute :type_descriptor, :aliases => 'typeDescriptor'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/google/models/monitoring/metric_descriptor'
+
+module Fog
+  module Google
+    class Monitoring
+      class MetricDescriptors < Fog::Collection
+        model Fog::Google::Monitoring::MetricDescriptor
+
+        ##
+        # Lists all Metric Descriptors.
+        #
+        # @param [Hash] options Optional query parameters.
+        # @option options [String] count Maximum number of time series 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] query The query used to search against existing metrics. Separate keywords with a space;
+        #   the service joins all keywords with AND, meaning that all keywords must match for a metric to be returned.
+        #   If this field is omitted, all metrics are returned. If an empty string is passed with this field,
+        #   no metrics are returned.
+        # @return [Array<Fog::Google::Monitoring::MetricDescriptor>] List of Metric Descriptors.
+        def all(options = {})
+          data = service.list_metric_descriptors(options).body['metrics'] || []
+          load(data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class Monitoring
+      ##
+      # A time series is a collection of data points that represents the value of a metric of a project over time.
+      #
+      # @see https://developers.google.com/cloud-monitoring/v2beta1/timeseries
+      class Timeseries < Fog::Model
+        identity :time_series_desc, :aliases => 'timeseriesDesc'
+
+        attribute :points
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/google/models/monitoring/timeseries'
+
+module Fog
+  module Google
+    class Monitoring
+      class TimeseriesCollection < Fog::Collection
+        model Fog::Google::Monitoring::Timeseries
+
+        ##
+        # Lists all Timeseries.
+        #
+        # @param [String] metric The name of the metric (Metric names are protocol-free URLs).
+        # @param [String] youngest End of the time interval (inclusive), which is expressed as an RFC 3339 timestamp.
+        # @param [Hash] options Optional query parameters.
+        # @option options [String] count Maximum number of time series descriptors per page. Used for pagination.
+        # @option options [String] labels A collection of labels for the matching time series.
+        # @option options [String] oldest Start of the time interval (exclusive), which is expressed as an RFC 3339
+        #   timestamp.
+        # @options options [String] page_token The pagination token, which is used to page through large result sets.
+        # @options options [String] timespan Length of the time interval to query, which is an alternative way to
+        #   declare the interval.
+        # @return [Array<Fog::Google::Monitoring::Timeseries>] List of Timeseries.
+        def all(metric, youngest, options = {})
+          data = service.list_timeseries(metric, youngest, options).body['timeseries'] || []
+          load(data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class Monitoring
+      ##
+      # A time series is a collection of data points that represents the value of a metric of a project over time.
+      # The metric is described by the time-series descriptor. Each time-series descriptor is uniquely identified by
+      # its metric name and a set of labels.
+      #
+      # @see https://developers.google.com/cloud-monitoring/v2beta1/timeseriesDescriptors
+      class TimeseriesDescriptor < Fog::Model
+        identity :metric
+
+        attribute :labels
+        attribute :project
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/google/models/monitoring/timeseries_descriptor'
+
+module Fog
+  module Google
+    class Monitoring
+      class TimeseriesDescriptors < Fog::Collection
+        model Fog::Google::Monitoring::TimeseriesDescriptor
+
+        ##
+        # Lists all Timeseries Descriptors.
+        #
+        # @param [String] metric The name of the metric (Metric names are protocol-free URLs).
+        # @param [String] youngest End of the time interval (inclusive), which is expressed as an RFC 3339 timestamp.
+        # @param [Hash] options Optional query parameters.
+        # @option options [String] count Maximum number of time series descriptors per page. Used for pagination.
+        # @option options [String] labels A collection of labels for the matching time series.
+        # @option options [String] oldest Start of the time interval (exclusive), which is expressed as an RFC 3339
+        #   timestamp.
+        # @options options [String] page_token The pagination token, which is used to page through large result sets.
+        # @options options [String] timespan Length of the time interval to query, which is an alternative way to
+        #   declare the interval.
+        # @return [Array<Fog::Google::Monitoring::TimeseriesDescriptor>] List of Timeseries Descriptors.
+        def all(metric, youngest, options = {})
+          data = service.list_timeseries_descriptors(metric, youngest, options).body['timeseries'] || []
+          load(data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class SQL
+      ##
+      # A database instance backup run resource
+      #
+      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/backupRuns
+      class BackupRun < Fog::Model
+        identity :backup_configuration, :aliases => 'backupConfiguration'
+
+        attribute :due_time, :aliases => 'dueTime'
+        attribute :end_time, :aliases => 'endTime'
+        attribute :enqueued_time, :aliases => 'enqueuedTime'
+        attribute :error
+        attribute :instance
+        attribute :kind
+        attribute :start_time, :aliases => 'startTime'
+        attribute :status
+
+        DONE_STATE = 'DONE'
+
+        ##
+        # Checks if the instance backup run is done
+        #
+        # @return [Boolean] True if the backup run is done; False otherwise
+        def ready?
+          self.state == DONE_STATE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'fog/core/collection'
+require 'fog/google/models/sql/backup_run'
+
+module Fog
+  module Google
+    class SQL
+      class BackupRuns < Fog::Collection
+        model Fog::Google::SQL::BackupRun
+
+        ##
+        # Lists all backup runs associated with a given instance and configuration
+        #
+        # @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'] || []
+          load(data)
+        end
+
+        ##
+        # 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
+        # @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
+            new(backup_run)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class SQL
+      ##
+      # A Google Cloud SQL service flag resource
+      #
+      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/flags
+      class Flag < Fog::Model
+        identity :name
+
+        attribute :allowed_string_values, :aliases => 'allowedStringValues'
+        attribute :applies_to, :aliases => 'appliesTo'
+        attribute :kind
+        attribute :max_value, :aliases => 'maxValue'
+        attribute :min_value, :aliases => 'minValue'
+        attribute :type
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'fog/core/collection'
+require 'fog/google/models/sql/flag'
+
+module Fog
+  module Google
+    class SQL
+      class Flags < Fog::Collection
+        model Fog::Google::SQL::Flag
+
+        ##
+        # List all available database flags
+        #
+        # @return [Array<Fog::Google::SQL::Flag>] List of flags
+        def all
+          data = service.list_flags.body['items'] || []
+          load(data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,353 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class SQL
+      class Instance < Fog::Model
+        identity :instance
+
+        attribute :current_disk_size, :aliases => 'currentDiskSize'
+        attribute :database_version, :aliases => 'databaseVersion'
+        attribute :etag
+        attribute :ip_addresses, :aliases => 'ipAddresses'
+        attribute :kind
+        attribute :max_disk_size, :aliases => 'maxDiskSize'
+        attribute :project
+        attribute :region
+        attribute :server_ca_cert, :aliases => 'serverCaCert'
+        attribute :settings
+        attribute :state
+
+        # 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 :backup_configuration
+        attribute :database_flags
+        attribute :ip_configuration_authorized_networks
+        attribute :ip_configuration_enabled
+        attribute :ip_configuration_require_ssl
+        attribute :location_preference_zone_follow_gae_application
+        attribute :location_preference_zone
+        attribute :pricing_plan
+        attribute :replication_type
+        attribute :settings_version
+        attribute :tier
+
+        MAINTENANCE_STATE    = 'MAINTENANCE'
+        PENDING_CREATE_STATE = 'PENDING_CREATE'
+        RUNNABLE_STATE       = 'RUNNABLE'
+        SUSPENDED_STATE      = 'SUSPENDED'
+        UNKNOWN_STATE        = 'UNKNOWN_STATE'
+
+        ##
+        # Returns the activation policy for this instance
+        #
+        # @return [String] The activation policy for this instance
+        def activation_policy
+          self.settings['activationPolicy']
+        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
+          self.settings['authorizedGaeApplications']
+        end
+
+        ##
+        # Returns the daily backup configuration for the instance
+        #
+        # @return [Array<Hash>] The daily backup configuration for the instance
+        def backup_configuration
+          self.settings['backupConfiguration']
+        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)
+        # @return [Fog::Google::SQL::Operation] A Operation resource
+        def clone(destination_name, options = {})
+          requires :identity
+
+          data = service.clone_instance(self.identity, destination_name, options)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.instance, data.body['operation'])
+          unless options.fetch(:async, true)
+            operation.wait_for { ready? }
+          end
+          operation
+        end
+
+        ##
+        # Creates a Cloud SQL instance
+        #
+        # @return [Fog::Google::SQL::Instance] Instance resource
+        def create
+          requires :identity
+
+          data = service.insert_instance(self.identity, self.attributes[:tier], self.attributes)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.instance, data.body['operation'])
+          operation.wait_for { !pending? }
+          reload
+        end
+
+        ##
+        # Returns the database flags passed to the instance at startup
+        #
+        # @return [Array<Hash>] The database flags passed to the instance at startup
+        def database_flags
+          self.settings['databaseFlags']
+        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)
+        # @return [Fog::Google::SQL::Operation] A Operation resource
+        def destroy(options = {})
+          requires :identity
+
+          data = service.delete_instance(self.identity)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.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
+        end
+
+        ##
+        # Exports data from a Cloud SQL instance to a Google Cloud Storage bucket as a MySQL dump file
+        #
+        # @param [String] uri The path to the file in Google Cloud Storage where the export will be stored,
+        #   or where it was already stored
+        # @param [Hash] options Method options
+        # @option options [Array<String>] :databases Databases (for example, guestbook) from which the export is made.
+        #   If unspecified, all databases are exported.
+        # @option options [Array<String>] :tables Tables to export, or that were exported, from the specified database.
+        #   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 = {})
+          requires :identity
+
+          data = service.export_instance(self.identity, uri, options)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.instance, data.body['operation'])
+          unless options.fetch(:async, true)
+            operation.wait_for { ready? }
+          end
+          operation
+        end
+
+        ##
+        # Imports data into a Cloud SQL instance from a MySQL dump file in Google Cloud Storage
+        #
+        # @param [Array<String>] uri A path to the MySQL dump file in Google Cloud Storage from which the import is
+        #   made
+        # @param [Hash] options Method options
+        # @option options [String] :database The database (for example, guestbook) to which the import is made.
+        #   If not set, it is assumed that the database is specified in the file to be imported.
+        # @option options [Boolean] :async If the operation must be performed asynchronously (true by default)
+        # @return [Fog::Google::SQL::Operation] A Operation resource
+        def import(uri, options = {})
+          requires :identity
+
+          data = service.import_instance(self.identity, uri, options)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.instance, data.body['operation'])
+          unless options.fetch(:async, true)
+            operation.wait_for { ready? }
+          end
+          operation
+        end
+
+        ##
+        # Returns the list of external networks that are allowed to connect to the instance using the IP
+        #
+        # @return [Array<String>] The list of external networks that are allowed to connect to the instance using the IP
+        def ip_configuration_authorized_networks
+          self.settings.fetch('ipConfiguration', {})['authorizedNetworks']
+        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
+          self.settings.fetch('ipConfiguration', {})['enabled']
+        end
+
+        ##
+        # Returns whether the mysqld should default to 'REQUIRE X509' for users connecting over IP
+        #
+        # @return [Boolean] Whether the mysqld should default to 'REQUIRE X509' for users connecting over IP
+        def ip_configuration_require_ssl
+          self.settings.fetch('ipConfiguration', {})['requireSsl']
+        end
+
+        ##
+        # Returns the AppEngine application to follow
+        #
+        # @return [String] The AppEngine application to follow
+        def location_preference_zone_follow_gae_application
+          self.settings.fetch('locationPreference', {})['followGaeApplication']
+        end
+
+        ##
+        # Returns the preferred Compute Engine zone
+        #
+        # @return [String] The preferred Compute Engine zone
+        def location_preference_zone
+          self.settings.fetch('locationPreference', {})['zone']
+        end
+
+        ##
+        # Returns the pricing plan for this instance
+        #
+        # @return [String] The pricing plan for this instance
+        def pricing_plan
+          self.settings['pricingPlan']
+        end
+
+        ##
+        # Checks if the instance is running
+        #
+        # @return [Boolean] True if the instance is running; False otherwise
+        def ready?
+          self.state == RUNNABLE_STATE
+        end
+
+        ##
+        # Returns the type of replication this instance uses
+        #
+        # @return [String] The type of replication this instance uses
+        def replication_type
+          self.settings['replicationType']
+        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)
+        # @return [Fog::Google::SQL::Operation] A Operation resource
+        def reset_ssl_config(options = {})
+          requires :identity
+
+          data = service.reset_instance_ssl_config(self.identity)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.instance, data.body['operation'])
+          unless options.fetch(:async, true)
+            operation.wait_for { ready? }
+          end
+          operation
+        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)
+        # @return [Fog::Google::SQL::Operation] A Operation resource
+        def restart(options = {})
+          requires :identity
+
+          data = service.restart_instance(self.identity)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.instance, data.body['operation'])
+          unless options.fetch(:async, true)
+            operation.wait_for { ready? }
+          end
+          operation
+        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)
+        # @return [Fog::Google::SQL::Operation] A Operation resource
+        def restore_backup(backup_configuration, due_time, options = {})
+          requires :identity
+
+          data = service.restore_instance_backup(self.identity, backup_configuration, due_time)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.instance, data.body['operation'])
+          unless options.fetch(:async, true)
+            operation.wait_for { ready? }
+          end
+          operation
+        end
+
+        ##
+        # Saves a Cloud SQL instance
+        #
+        # @return [Fog::Google::SQL::Instance] Instance resource
+        def save
+          self.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(self.identity, password)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.instance, data.body['operation'])
+          unless options.fetch(:async, true)
+            operation.wait_for { ready? }
+          end
+          operation
+        end
+
+        ##
+        # Returns the version of instance settings
+        #
+        # @return [String] The version of instance settings
+        def settings_version
+          self.settings['settingsVersion']
+        end
+
+        ##
+        # Lists all of the current SSL certificates for the instance
+        #
+        # @return [Array<Fog::Google::SQL::SslCert>] List of SSL certificate resources
+        def ssl_certs
+          requires :identity
+
+          service.ssl_certs.all(self.identity)
+        end
+
+        ##
+        # Returns the tier of service for this instance
+        #
+        # @return [String] The tier of service for this instance
+        def tier
+          self.settings['tier']
+        end
+
+        ##
+        # Updates settings of a Cloud SQL instance
+        #
+        # @return [Fog::Google::SQL::Instance] Instance resource
+        def update
+          requires :identity
+
+          data = service.update_instance(self.identity, self.settings_version, self.tier, self.attributes)
+          operation = Fog::Google::SQL::Operations.new(:service => service).get(self.instance, data.body['operation'])
+          operation.wait_for { !pending? }
+          reload
+        end
+      end
+    end
+  end
+end