fog-google 0.0.2

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/directories.rb

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/google/models/storage/directory'
+
+module Fog
+  module Storage
+    class Google
+      class Directories < Fog::Collection
+        model Fog::Storage::Google::Directory
+
+        def all
+         data = service.get_service.body['Buckets']
+         load(data)
+        end
+
+        def get(key, options = {})
+          remap_attributes(options, {
+            :delimiter  => 'delimiter',
+            :marker     => 'marker',
+            :max_keys   => 'max-keys',
+            :prefix     => 'prefix'
+          })
+          data = service.get_bucket(key, options).body
+          directory = new(:key => data['Name'])
+          options = {}
+          for k, v in data
+            if ['CommonPrefixes', 'Delimiter', 'IsTruncated', 'Marker', 'MaxKeys', 'Prefix'].include?(k)
+              options[k] = v
+            end
+          end
+          directory.files.merge_attributes(options)
+          directory.files.load(data['Contents'])
+          directory
+        rescue Excon::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'fog/core/model'
+require 'fog/google/models/storage/files'
+
+module Fog
+  module Storage
+    class Google
+      class Directory < Fog::Model
+        identity  :key,           :aliases => ['Name', 'name']
+
+        attribute :creation_date, :aliases => 'CreationDate'
+
+        def acl=(new_acl)
+          valid_acls = ['private', 'public-read', 'public-read-write', 'authenticated-read']
+          unless valid_acls.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
+          end
+          @acl = new_acl
+        end
+
+        def destroy
+          requires :key
+          service.delete_bucket(key)
+          true
+        rescue Excon::Errors::NotFound
+          false
+        end
+
+        def files
+          @files ||= begin
+            Fog::Storage::Google::Files.new(
+              :directory    => self,
+              :service   => service
+            )
+          end
+        end
+
+        def public=(new_public)
+          if new_public
+            @acl = 'public-read'
+          else
+            @acl = 'private'
+          end
+          new_public
+        end
+
+        def public_url
+          requires :key
+          if service.get_bucket_acl(key).body['AccessControlList'].find {|entry| entry['Scope']['type'] == 'AllUsers' && entry['Permission'] == 'READ'}
+            if key.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
+              "https://#{key}.storage.googleapis.com"
+            else
+              "https://storage.googleapis.com/#{key}"
+            end
+          else
+            nil
+          end
+        end
+
+        def save
+          requires :key
+          options = {}
+          if @acl
+            options['x-goog-acl'] = @acl
+          end
+          if @location
+            options['LocationConstraint'] = @location
+          end
+          service.put_bucket(key, options)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Google
+      class File < Fog::Model
+        identity  :key,                 :aliases => 'Key'
+
+        attribute :cache_control,       :aliases => 'Cache-Control'
+        attribute :content_disposition, :aliases => 'Content-Disposition'
+        attribute :content_encoding,    :aliases => 'Content-Encoding'
+        attribute :content_length,      :aliases => ['Content-Length', 'Size'], :type => :integer
+        attribute :content_md5,         :aliases => 'Content-MD5'
+        attribute :content_type,        :aliases => 'Content-Type'
+        attribute :etag,                :aliases => ['Etag', 'ETag']
+        attribute :expires,             :aliases => 'Expires'
+        attribute :last_modified,       :aliases => ['Last-Modified', 'LastModified']
+        attribute :metadata
+        attribute :owner,               :aliases => 'Owner'
+        attribute :storage_class,       :aliases => ['x-goog-storage-class', 'StorageClass']
+
+        def acl=(new_acl)
+          valid_acls = ['private', 'public-read', 'public-read-write', 'authenticated-read']
+          unless valid_acls.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
+          end
+          @acl = new_acl
+        end
+
+        def body
+          attributes[:body] ||= if last_modified && (file = collection.get(identity))
+            file.body
+          else
+            ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        def directory
+          @directory
+        end
+
+        def copy(target_directory_key, target_file_key)
+          requires :directory, :key
+          service.copy_object(directory.key, key, target_directory_key, target_file_key)
+          target_directory = service.directories.new(:key => target_directory_key)
+          target_directory.files.get(target_file_key)
+        end
+
+        def destroy
+          requires :directory, :key
+          begin
+            service.delete_object(directory.key, key)
+          rescue Excon::Errors::NotFound
+          end
+          true
+        end
+
+        remove_method :metadata
+        def metadata
+          attributes.reject {|key, value| !(key.to_s =~ /^x-goog-meta-/)}
+        end
+
+        remove_method :metadata=
+        def metadata=(new_metadata)
+          merge_attributes(new_metadata)
+        end
+
+        remove_method :owner=
+        def owner=(new_owner)
+          if new_owner
+            attributes[:owner] = {
+              :display_name => new_owner['DisplayName'],
+              :id           => new_owner['ID']
+            }
+          end
+        end
+
+        def public=(new_public)
+          if new_public
+            @acl = 'public-read'
+          else
+            @acl = 'private'
+          end
+          new_public
+        end
+
+        def public_url
+          requires :directory, :key
+
+          acl = service.get_object_acl(directory.key, key).body['AccessControlList']
+          access_granted = acl.find do |entry|
+            entry['Scope']['type'] == 'AllUsers' && entry['Permission'] == 'READ'
+          end
+
+          if access_granted
+            if directory.key.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
+              "https://#{directory.key}.storage.googleapis.com/#{key}"
+            else
+              "https://storage.googleapis.com/#{directory.key}/#{key}"
+            end
+          else
+            nil
+          end
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          if options != {}
+            Fog::Logger.deprecation("options param is deprecated, use acl= instead [light_black](#{caller.first})[/]")
+          end
+          options['x-goog-acl'] ||= @acl if @acl
+          options['Cache-Control'] = cache_control if cache_control
+          options['Content-Disposition'] = content_disposition if content_disposition
+          options['Content-Encoding'] = content_encoding if content_encoding
+          options['Content-MD5'] = content_md5 if content_md5
+          options['Content-Type'] = content_type if content_type
+          options['Expires'] = expires if expires
+          options.merge!(metadata)
+
+          data = service.put_object(directory.key, key, body, options)
+          merge_attributes(data.headers.reject {|key, value| ['Content-Length', 'Content-Type'].include?(key)})
+          self.content_length = Fog::Storage.get_body_size(body)
+          self.content_type ||= Fog::Storage.get_content_type(body)
+          true
+        end
+
+        def url(expires)
+          requires :key
+          collection.get_http_url(key, expires)
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+      end
+    end
+  end
+end