fog-google 0.6.0 → 1.0.0

data/lib/fog/google/sql/real.rb

@@ -11,8 +11,8 @@ module Fog
           shared_initialize(options[:google_project], GOOGLE_SQL_API_VERSION, GOOGLE_SQL_BASE_URL)
           options[:google_api_scope_url] = GOOGLE_SQL_API_SCOPE_URLS.join(" ")
 
-          @client = initialize_google_client(options)
-          @sql = @client.discovered_api("sqladmin", api_version)
+          initialize_google_client(options)
+          @sql = ::Google::Apis::SqladminV1beta4::SQLAdminService.new
         end
       end
     end

data/lib/fog/google/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Google
-    VERSION = "0.6.0".freeze
+    VERSION = "1.0.0".freeze
   end
 end

data/lib/fog/parsers/storage/google/get_bucket_object_versions.rb

@@ -42,14 +42,18 @@ module Fog
             when "ETag"
               @version[name] = value.delete('"')
             when "IsLatest"
-              if @in_delete_marker
-                @delete_marker
-              elsif @in_version
-                @version
-              end["IsLatest"] = if value == "true"
-                                  true
-                                else
-                                  false
+              if value == "true"
+                if @in_delete_marker
+                  @delete_marker
+                elsif @in_version
+                  @version
+              end["IsLatest"] = true
+              else
+                if @in_delete_marker
+                  @delete_marker
+                elsif @in_version
+                  @version
+              end["IsLatest"] = false
               end
             when "IsTruncated"
               if value == "true"

data/lib/fog/storage/google_json.rb

@@ -9,6 +9,7 @@ module Fog
       recognizes(
         :app_name,
         :app_version,
+        :google_auth,
         :google_client,
         :google_client_email,
         :google_client_options,
@@ -19,18 +20,21 @@ module Fog
       )
 
       # https://cloud.google.com/storage/docs/json_api/v1/
-      GOOGLE_STORAGE_JSON_API_VERSION = "v1"
-      GOOGLE_STORAGE_JSON_BASE_URL = "https://www.googleapis.com/storage/"
+      GOOGLE_STORAGE_JSON_API_VERSION = "v1".freeze
+      GOOGLE_STORAGE_JSON_BASE_URL = "https://www.googleapis.com/storage/".freeze
+      GOOGLE_STORAGE_BUCKET_BASE_URL = "https://storage.googleapis.com/".freeze
 
       # TODO: Come up with a way to only request a subset of permissions.
       # https://cloud.google.com/storage/docs/json_api/v1/how-tos/authorizing
-      GOOGLE_STORAGE_JSON_API_SCOPE_URLS = %w(https://www.googleapis.com/auth/devstorage.full_control)
+      GOOGLE_STORAGE_JSON_API_SCOPE_URLS = %w(https://www.googleapis.com/auth/devstorage.full_control).freeze
 
       ##
       # Models
       model_path "fog/storage/google_json/models"
+
       collection :directories
       model :directory
+
       collection :files
       model :file
 
@@ -46,10 +50,12 @@ module Fog
       request :get_object_acl
       request :get_object_http_url
       request :get_object_https_url
+      request :get_object_metadata
       request :get_object_url
-      request :head_object
       request :list_buckets
+      request :list_bucket_acl
       request :list_objects
+      request :list_object_acl
       request :put_bucket
       request :put_bucket_acl
       request :put_object

data/lib/fog/storage/google_json/models/directories.rb

@@ -4,19 +4,26 @@ module Fog
       class Directories < Fog::Collection
         model Fog::Storage::GoogleJSON::Directory
 
-        def all
-          data = service.list_buckets.body["items"] || []
+        def all(opts = {})
+          data = service.list_buckets(opts).to_h[:items] || []
           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
-          new(:key => data["name"])
-        rescue Fog::Errors::NotFound
+        def get(bucket_name,
+                if_metageneration_match: nil,
+                if_metageneration_not_match: nil,
+                projection: nil)
+          data = service.get_bucket(
+            bucket_name,
+            :if_metageneration_match => if_metageneration_match,
+            :if_metageneration_not_match => if_metageneration_not_match,
+            :projection => projection
+          ).to_h
+
+          new(data)
+        rescue ::Google::Apis::ClientError => e
+          # metageneration check failures returns HTTP 412 Precondition Failed
+          raise e unless e.status_code == 404 || e.status_code == 412
           nil
         end
       end

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

@@ -1,22 +1,39 @@
 module Fog
   module Storage
     class GoogleJSON
+      ##
+      # Represents a Google Storage bucket
       class Directory < Fog::Model
-        identity :key, :aliases => %w(Name name)
+        identity :key, :aliases => ["Name", "name", :name]
 
-        def acl=(new_acl)
-          valid_acls = %w(private projectPrivate publicRead publicReadWrite authenticatedRead)
-          unless valid_acls.include?(new_acl)
-            raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
-          end
-          @acl = new_acl
-        end
+        attribute :acl
+        attribute :billing
+        attribute :cors
+        attribute :default_object_acl, aliases => "defaultObjectAcl"
+        attribute :etag
+        attribute :id
+        attribute :kind
+        attribute :labels
+        attribute :lifecycle
+        attribute :location
+        attribute :logging
+        attribute :metageneration
+        attribute :name
+        attribute :owner
+        attribute :project_number, aliases => "projectNumber"
+        attribute :self_link, aliases => "selfLink"
+        attribute :storage_class, aliases => "storageClass"
+        attribute :time_created, aliases => "timeCreated"
+        attribute :updated
+        attribute :versioning
+        attribute :website
 
         def destroy
           requires :key
           service.delete_bucket(key)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
@@ -29,34 +46,14 @@ module Fog
           end
         end
 
-        def public=(new_public)
-          if new_public
-            @acl = "publicRead"
-          else
-            @acl = "private"
-          end
-          new_public
-        end
-
         def public_url
           requires :key
-          acl = service.get_bucket_acl(key).body
-          if acl["items"].detect { |entry| entry["entity"] == "allUsers" && entry["role"] == "READER" }
-            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
-          end
+          "#{GOOGLE_STORAGE_BUCKET_BASE_URL}#{key}"
         end
 
         def save
           requires :key
-          options = {}
-          options["predefinedAcl"] = @acl if @acl
-          options["LocationConstraint"] = @location if @location
-          options["StorageClass"] = attributes[:storage_class] if attributes[:storage_class]
-          service.put_bucket(key, options)
+          service.put_bucket(key, attributes)
           true
         end
       end

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

@@ -2,48 +2,32 @@ module Fog
   module Storage
     class GoogleJSON
       class File < Fog::Model
-        identity :key, :aliases => %w{Key name}
+        identity :key, :aliases => ["Key", :name]
 
         attribute :acl
-        attribute :predefined_acl
-        attribute :cache_control,       :aliases => "cacheControl"
-        attribute :content_disposition, :aliases => "contentDisposition"
-        attribute :content_encoding,    :aliases => "contentEncoding"
-        attribute :content_length,      :aliases => "size", :type => :integer
-        attribute :content_md5,         :aliases => "md5Hash"
-        attribute :content_type,        :aliases => "contentType"
+        attribute :predefined_acl,      :aliases => ["predefinedAcl", :predefined_acl]
+        attribute :cache_control,       :aliases => ["cacheControl", :cache_control]
+        attribute :content_disposition, :aliases => ["contentDisposition", :content_disposition]
+        attribute :content_encoding,    :aliases => ["contentEncoding", :content_encoding]
+        attribute :content_length,      :aliases => ["size", :size], :type => :integer
+        attribute :content_md5,         :aliases => ["md5Hash", :md5_hash]
+        attribute :content_type,        :aliases => ["contentType", :content_type]
         attribute :crc32c
-        attribute :etag,                :aliases => "etag"
-        attribute :time_created,        :aliases => "timeCreated"
-        attribute :last_modified,       :aliases => "updated"
+        attribute :etag,                :aliases => ["etag", :etag]
+        attribute :time_created,        :aliases => ["timeCreated", :time_created]
+        attribute :last_modified,       :aliases => ["updated", :updated]
         attribute :generation
         attribute :metageneration
-        attribute :metadata
-        attribute :self_link,           :aliases => "selfLink"
-        attribute :media_link,          :aliases => "mediaLink"
+        attribute :metadata,            :aliases => ["metadata", :metadata]
+        attribute :self_link,           :aliases => ["selfLink", :self_link]
+        attribute :media_link,          :aliases => ["mediaLink", :media_link]
         attribute :owner
         attribute :storage_class, :aliases => "storageClass"
 
-        @valid_predefined_acls = %w(private projectPrivate bucketOwnerFullControl bucketOwnerRead authenticatedRead publicRead)
-
-        def predefined_acl=(new_acl)
-          unless @valid_predefined_acls.include?(new_acl)
-            raise ArgumentError.new("acl must be one of [#{@valid_predefined_acls.join(', ')}]")
-          end
-          @predefined_acl = new_acl
-        end
-
-        # TODO: Implement object ACLs
-        # def acl=(new_acl)
-        #   valid_acls = ["private", "projectPrivate", "bucketOwnerFullControl", "bucketOwnerRead", "authenticatedRead", "publicRead"]
-        #   unless valid_acls.include?(new_acl)
-        #     raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
-        #   end
-        #   @acl = new_acl
-        # end
+        # attribute :body
 
         def body
-          attributes[:body] ||= last_modified && (file = collection.get(identity)) ? file.body : ""
+          last_modified && (file = collection.get(identity)) ? attributes[:body] ||= file.body : attributes[:body] ||= ""
         end
 
         def body=(new_body)
@@ -63,71 +47,35 @@ module Fog
           requires :directory, :key
           service.delete_object(directory.key, key)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
-        remove_method :metadata=
-        def metadata=(new_metadata)
-          if attributes[:metadata].nil?
-            attributes[:metadata] = {}
-          end
-          attributes[:metadata].merge!(new_metadata)
-        end
-
-        # TODO: Not functional
-        remove_method :owner=
-        def owner=(new_owner)
-          if new_owner
-            attributes[:owner] = {
-              :entity => new_owner["entity"],
-              :entityId  => new_owner["entityId"]
-            }
-          end
-        end
-
-        def public=(new_public)
-          if new_public
-            @predefined_acl = "publicRead"
-          else
-            @predefined_acl = "private"
-          end
-          new_public
-        end
-
         def public_url
           requires :directory, :key
-
-          acl = service.get_object_acl(directory.key, key).body
-          access_granted = acl["items"].detect { |entry| entry["entity"] == "allUsers" && entry["role"] == "READER" }
-
-          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
-          end
+          "https://storage.googleapis.com/#{directory.key}/#{key}"
         end
 
-        def save(options = {})
+        FILE_INSERTABLE_FIELDS = %i(
+          content_type
+          predefined_acl
+          acl
+          cache_control
+          content_disposition
+          content_encoding
+          metadata
+        ).freeze
+
+        def save
           requires :body, :directory, :key
-          if options != {}
-            Fog::Logger.deprecation("options param is deprecated, use acl= instead [light_black](#{caller.first})[/]")
-          end
-          options["contentType"] = content_type if content_type
-          options["predefinedAcl"] ||= @predefined_acl if @predefined_acl # predefinedAcl may need to be in parameters
-          options["acl"] ||= @acl if @acl # Not sure if you can provide both acl and predefinedAcl
-          options["cacheControl"] = cache_control if cache_control
-          options["contentDisposition"] = content_disposition if content_disposition
-          options["contentEncoding"] = content_encoding if content_encoding
-          # TODO: Should these hashes be recomputed on changes to file contents?
-          # options["md5Hash"] = content_md5 if content_md5
-          # options["crc32c"] = crc32c if crc32c
-          options["metadata"] = metadata
 
-          data = service.put_object(directory.key, key, body, options)
-          merge_attributes(data.headers.reject { |key, _value| %w(contentLength contentType).include?(key) })
+          options = Hash[
+            FILE_INSERTABLE_FIELDS.map { |k| [k, attributes[k]] }
+                                  .reject { |pair| pair[1].nil? }
+          ]
+
+          service.put_object(directory.key, key, body, options)
           self.content_length = Fog::Storage.get_body_size(body)
           self.content_type ||= Fog::Storage.get_content_type(body)
           true

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

@@ -2,6 +2,8 @@ module Fog
   module Storage
     class GoogleJSON
       class Files < Fog::Collection
+        model Fog::Storage::GoogleJSON::File
+
         extend Fog::Deprecation
         deprecate :get_url, :get_https_url
 
@@ -12,39 +14,29 @@ module Fog
         attribute :max_results,     :aliases => ["MaxKeys", "max-keys"]
         attribute :prefix,          :aliases => "Prefix"
 
-        model Fog::Storage::GoogleJSON::File
-
         def all(options = {})
           requires :directory
 
-          body = service.list_objects(directory.key, options).body
-          load(body["items"] || [])
+          data = service.list_objects(directory.key, options).to_h[:items] || []
+          load(data)
         end
 
         alias_method :each_file_this_page, :each
         def each
-          if !block_given?
-            self
-          else
+          if block_given?
             subset = dup.all
 
             subset.each_file_this_page { |f| yield f }
-
-            self
           end
+          self
         end
 
         def get(key, options = {}, &block)
           requires :directory
-          data = service.get_object(directory.key, key, options, &block)
-          file_data = {}
-          data.headers.each do |k, v|
-            file_data[k] = v
-          end
-          file_data[:body] = data.body
-          file_data[:key] = key
-          new(file_data)
-        rescue Fog::Errors::NotFound
+          data = service.get_object(directory.key, key, options, &block).to_h
+          new(data)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
 
@@ -53,18 +45,17 @@ module Fog
           service.get_object_https_url(directory.key, key, expires)
         end
 
-        def head(key, options = {})
+        def metadata(key, options = {})
           requires :directory
-          data = service.head_object(directory.key, key, options)
-          file_data = data.headers.merge(:key => key)
-          new(file_data)
-        rescue Fog::Errors::NotFound
+          data = service.get_object_metadata(directory.key, key, options).to_h
+          new(data)
+        rescue ::Google::Apis::ClientError
           nil
         end
 
-        def new(attributes = {})
+        def new(opts = {})
           requires :directory
-          super({ :directory => directory }.merge(attributes))
+          super({ :directory => directory }.merge(opts))
         end
       end
     end