fog 1.23.0 → 1.24.0

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

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/google/models/sql/instance'
+
+module Fog
+  module Google
+    class SQL
+      class Instances < Fog::Collection
+        model Fog::Google::SQL::Instance
+
+        ##
+        # Lists all instance
+        #
+        # @return [Array<Fog::Google::SQL::Instance>] List of instance resources
+        def all
+          data = service.list_instances.body['items'] || []
+          load(data)
+        end
+
+        ##
+        # Retrieves an instance
+        #
+        # @param [String] instance_id Instance ID
+        # @return [Fog::Google::SQL::Instance] Instance resource
+        def get(instance_id)
+          if instance = service.get_instance(instance_id).body
+            new(instance)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        rescue Fog::Errors::Error => e
+          # Google SQL returns a 403 if we try to access a non-existing resource
+          # The default behaviour in Fog is to return a nil
+          return nil if e.message == 'The client is not authorized to make this request.'
+          raise e
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class SQL
+      ##
+      # An Operation resource contains information about database instance operations
+      # such as create, delete, and restart
+      #
+      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/operations
+      class Operation < Fog::Model
+        identity :operation
+
+        attribute :end_time, :aliases => 'endTime'
+        attribute :enqueued_time, :aliases => 'enqueuedTime'
+        attribute :error
+        attribute :export_context, :aliases => 'exportContext'
+        attribute :import_context, :aliases => 'importContext'
+        attribute :instance
+        attribute :kind
+        attribute :operation_type, :aliases => 'operationType'
+        attribute :start_time, :aliases => 'startTime'
+        attribute :state
+        attribute :user_email_address, :aliases => 'userEmailAddress'
+
+        DONE_STATE    = 'DONE'
+        PENDING_STATE = 'PENDING'
+        RUNNING_STATE = 'RUNNING'
+        UNKNOWN_STATE = 'UNKNOWN'
+
+        ##
+        # Checks if the instance operation is pending
+        #
+        # @return [Boolean] True if the operation is pending; False otherwise
+        def pending?
+          self.state == PENDING_STATE
+        end
+
+        ##
+        # Checks if the instance operation is done
+        #
+        # @return [Boolean] True if the operation is done; False otherwise
+        def ready?
+          self.state == DONE_STATE
+        end
+
+        ##
+        # Reloads an instance operation
+        #
+        # @return [Fog::Google::SQL::Operation] Instance operation resource
+        def reload
+          requires :identity
+
+          data = collection.get(self.instance, self.identity)
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'fog/core/collection'
+require 'fog/google/models/sql/operation'
+
+module Fog
+  module Google
+    class SQL
+      class Operations < Fog::Collection
+        model Fog::Google::SQL::Operation
+
+        ##
+        # Lists all instance operations that have been performed on the given instance
+        #
+        # @param [String] instance_id Instance ID
+        # @return [Array<Fog::Google::SQL::Operation>] List of instance operation resources
+        def all(instance_id)
+          data = []
+          begin
+            data = service.list_operations(instance_id).body['items'] || []
+          rescue Fog::Errors::Error => e
+            # Google SQL returns a 403 if we try to access a non-existing resource
+            # The default behaviour in Fog is to return an empty Array
+            raise e unless e.message == 'The client is not authorized to make this request.'
+          end
+
+          load(data)
+        end
+
+        ##
+        # Retrieves an instance operation that has been performed on an instance
+        #
+        # @param [String] instance_id Instance ID
+        # @param [String] operation_id Instance operation ID
+        # @return [Fog::Google::SQL::Operation] Instance operation resource
+        def get(instance_id, operation_id)
+          if operation = service.get_operation(instance_id, operation_id).body
+            new(operation)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        rescue Fog::Errors::Error => e
+          # Google SQL returns a 403 if we try to access a non-existing resource
+          # The default behaviour in Fog is to return a nil
+          return nil if e.message == 'The client is not authorized to make this request.'
+          raise e
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class SQL
+      ##
+      # A SSL certificate resource
+      #
+      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/sslCerts
+      class SslCert < Fog::Model
+        identity :sha1_fingerprint, :aliases => 'sha1Fingerprint'
+
+        attribute :cert
+        attribute :cert_serial_number, :aliases => 'certSerialNumber'
+        attribute :common_name, :aliases => 'commonName'
+        attribute :create_time, :aliases => 'createTime'
+        attribute :expiration_time, :aliases => 'expirationTime'
+        attribute :instance
+        attribute :kind
+
+        # These attributes are not available in the representation of a 'SSL Certificate' returned by the SQL API.
+        # These attributes are only available as a reponse to a create operation
+        attribute :server_ca_cert, :aliases => 'serverCaCert'
+        attribute :cert_private_key, :aliases => 'certPrivateKey'
+
+        ##
+        # Deletes a SSL certificate. The change will not take effect until the instance is restarted.
+        #
+        # @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 :instance, :identity
+
+          data = service.delete_ssl_cert(self.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
+
+        ##
+        # Reloads a SSL certificate
+        #
+        # @return [Fog::Google::SQL::SslCert] SSL certificate resource
+        def reload
+          requires :instance, :identity
+
+          data = collection.get(self.instance, self.identity)
+          merge_attributes(data.attributes)
+          self
+        end
+
+        ##
+        # Creates a SSL certificate. The new certificate will not be usable until the instance is restarted.
+        #
+        # @raise [Fog::Errors::Error] If SSL certificate already exists
+        def save
+          requires :instance, :common_name
+
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+
+          data = service.insert_ssl_cert(self.instance, self.common_name).body
+          merge_attributes(data['clientCert']['certInfo'])
+          self.server_ca_cert = Fog::Google::SQL::SslCert.new(data['serverCaCert'])
+          self.cert_private_key = data['clientCert']['certPrivateKey']
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'fog/core/collection'
+require 'fog/google/models/sql/ssl_cert'
+
+module Fog
+  module Google
+    class SQL
+      class SslCerts < Fog::Collection
+        model Fog::Google::SQL::SslCert
+
+        ##
+        # Lists all of the current SSL certificates for the instance
+        #
+        # @param [String] instance_id Instance ID
+        # @return [Array<Fog::Google::SQL::SslCert>] List of SSL certificate resources
+        def all(instance_id)
+          data = []
+          begin
+            data = service.list_ssl_certs(instance_id).body['items'] || []
+          rescue Fog::Errors::Error => e
+            # Google SQL returns a 403 if we try to access a non-existing resource
+            # The default behaviour in Fog is to return an empty Array
+            raise e unless e.message == 'The client is not authorized to make this request.'
+          end
+
+          load(data)
+        end
+
+        ##
+        # Retrieves a particular SSL certificate (does not include the private key)
+        #
+        # @param [String] instance_id Instance ID
+        # @param [String] sha1_fingerprint Sha1 FingerPrint
+        # @return [Fog::Google::SQL::SslCert] SSL certificate resource
+        def get(instance_id, sha1_fingerprint)
+          if ssl_cert = service.get_ssl_cert(instance_id, sha1_fingerprint).body
+            new(ssl_cert)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        rescue Fog::Errors::Error => e
+          # Google SQL returns a 403 if we try to access a non-existing resource
+          # The default behaviour in Fog is to return a nil
+          return nil if e.message == 'The client is not authorized to make this request.'
+          raise e
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class SQL
+      ##
+      # A Google Cloud SQL service tier resource
+      #
+      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/tiers
+      class Tier < Fog::Model
+        identity :tier
+
+        attribute :disk_quota, :aliases => 'DiskQuota'
+        attribute :kind
+        attribute :ram, :aliases => 'RAM'
+        attribute :region
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'fog/core/collection'
+require 'fog/google/models/sql/tier'
+
+module Fog
+  module Google
+    class SQL
+      class Tiers < Fog::Collection
+        model Fog::Google::SQL::Tier
+
+        ##
+        # Lists all available service tiers
+        #
+        # @return [Array<Fog::Google::SQL::Tier>] List of tiers
+        def all
+          data = service.list_tiers.body['items'] || []
+          load(data)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/storage/files.rb

@@ -60,7 +60,11 @@ module Fog
         def get(key, options = {}, &block)
           requires :directory
           data = service.get_object(directory.key, key, options, &block)
-          file_data = data.headers.merge({
+          file_data = {}
+          data.headers.each do |key, value|
+            file_data[key] = value
+          end
+          file_data.merge({
             :body => data.body,
             :key  => key
           })

data/lib/fog/google/monitoring.rb

@@ -0,0 +1,89 @@
+require 'fog/google/core'
+
+module Fog
+  module Google
+    class Monitoring < Fog::Service
+      requires :google_project
+      recognizes :google_client_email, :google_key_location, :google_key_string, :google_client,
+                 :app_name, :app_version
+
+      GOOGLE_MONITORING_API_VERSION    = 'v2beta1'
+      GOOGLE_MONITORING_BASE_URL       = 'https://www.googleapis.com/cloudmonitoring/'
+      GOOGLE_MONITORING_API_SCOPE_URLS = %w(https://www.googleapis.com/auth/monitoring.readonly)
+
+      ##
+      # MODELS
+      model_path 'fog/google/models/monitoring'
+
+      # Timeseries
+      model :timeseries
+      collection :timeseries_collection
+
+      # TimeseriesDescriptors
+      model :timeseries_descriptor
+      collection :timeseries_descriptors
+
+      # MetricDescriptors
+      model :metric_descriptor
+      collection :metric_descriptors
+
+      ##
+      # REQUESTS
+      request_path 'fog/google/requests/monitoring'
+
+      # Timeseries
+      request :list_timeseries
+
+      # TimeseriesDescriptors
+      request :list_timeseries_descriptors
+
+      # MetricDescriptors
+      request :list_metric_descriptors
+
+      class Mock
+        include Fog::Google::Shared
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_MONITORING_API_VERSION, GOOGLE_MONITORING_BASE_URL)
+        end
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :timeseries => {},
+              :timeseries_descriptors => {},
+              :metric_descriptors => {},
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def data
+          self.class.data[project]
+        end
+
+        def reset_data
+          self.class.data.delete(project)
+        end
+      end
+
+      class Real
+        include Fog::Google::Shared
+
+        attr_accessor :client
+        attr_reader :monitoring
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_MONITORING_API_VERSION, GOOGLE_MONITORING_BASE_URL)
+          options.merge!(:google_api_scope_url => GOOGLE_MONITORING_API_SCOPE_URLS.join(' '))
+
+          @client = initialize_google_client(options)
+          @monitoring = @client.discovered_api('cloudmonitoring', api_version)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/compute/add_backend_service_backends.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def add_backend_service_backends(backend_service, new_backends)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        def add_backend_service_backends(backend_service, new_backends)
+          api_method = @compute.backend_services.patch
+          parameters = {
+            'project' => @project,
+            'backendService' => backend_service.name,
+          }
+          if backend_service.backends then
+            backend_service.backends.concat(new_backends)
+          else
+            backend_service.backends = new_backends
+          end
+          body_object = backend_service
+          
+          request(api_method, parameters, body_object)
+        end
+      end
+    end
+  end
+end