fog-google 0.6.0 → 1.0.0

data/lib/fog/storage/google_json/requests/get_object_acl.rb

@@ -5,53 +5,27 @@ module Fog
         # Get access control list for an Google Storage object
         # https://cloud.google.com/storage/docs/json_api/v1/objectAccessControls/get
         #
-        # ==== Parameters
-        # * bucket_name<~String> - name of bucket containing object
-        # * object_name<~String> - name of object to get access control list for
-        # * options<~Hash>:
-        #   * 'versionId'<~String> - specify a particular version to retrieve
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'AccessControlPolicy'<~Hash>
-        #       * 'Owner'<~Hash>:
-        #         * 'DisplayName'<~String> - Display name of object owner
-        #         * 'ID'<~String> - Id of object owner
-        #       * 'AccessControlList'<~Array>:
-        #         * 'Grant'<~Hash>:
-        #           * 'Grantee'<~Hash>:
-        #              * 'DisplayName'<~String> - Display name of grantee
-        #              * 'ID'<~String> - Id of grantee
-        #             or
-        #              * 'URI'<~String> - URI of group to grant access for
-        #           * 'Permission'<~String> - Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]
-        #
-        def get_object_acl(bucket_name, object_name, _options = {})
+        # @param bucket_name [String] Name of bucket object is in
+        # @param object_name [String] Name of object to add ACL to
+        # @param entity [String] The entity holding the permission.
+        #   Can be user-userId, user-emailAddress, group-groupId,
+        #   group-emailAddress, allUsers, or allAuthenticatedUsers.
+        # @param generation [Hash] Specify a particular version to retrieve
+        # @return [Google::Apis::StorageV1::ObjectAccessControls]
+        def get_object_acl(bucket_name, object_name, entity, generation: nil)
           raise ArgumentError.new("bucket_name is required") unless bucket_name
           raise ArgumentError.new("object_name is required") unless object_name
 
-          api_method = @storage_json.object_access_controls.list
-          parameters = {
-            "bucket" => bucket_name,
-            "object" => object_name
-          }
-
-          request(api_method, parameters)
+          @storage_json.get_object_access_control(
+            bucket_name, object_name, entity,
+            :generation => generation
+          )
         end
       end
 
       class Mock
-        def get_object_acl(bucket_name, object_name)
-          response = Excon::Response.new
-          if acl = data[:acls][:object][bucket_name] && data[:acls][:object][bucket_name][object_name]
-            response.status = 200
-            response.body = acl
-          else
-            response.status = 404
-            raise(Excon::Errors.status_error({ :expects => 200 }, response))
-          end
-          response
+        def get_object_acl(_bucket_name, _object_name)
+          Fog::Mock.not_implemented
         end
       end
     end

data/lib/fog/storage/google_json/requests/get_object_http_url.rb

@@ -15,20 +15,13 @@ module Fog
       end
 
       class Real
-        # Get an expiring object http url from GCS
-        #
-        # ==== Parameters
-        # * bucket_name<~String> - Name of bucket containing object
-        # * object_name<~String> - Name of object to get expiring url for
-        # * expires<~Time> - An expiry time for this url
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~String> - url for object
-        #
-        # ==== See Also
+        # Get an expiring object http url from Google Storage
         # https://cloud.google.com/storage/docs/access-control#Signed-URLs
-
+        #
+        # @param bucket_name [String] Name of bucket to read from
+        # @param object_name [String] Name of object to read
+        # @param expires [Time] Expiry time for this URL
+        # @return [String] Expiring object http URL
         include GetObjectHttpUrl
       end
 

data/lib/fog/storage/google_json/requests/get_object_https_url.rb

@@ -17,19 +17,12 @@ module Fog
 
       class Real
         # Get an expiring object https url from Google Storage
-        #
-        # ==== Parameters
-        # * bucket_name<~String> - Name of bucket containing object
-        # * object_name<~String> - Name of object to get expiring url for
-        # * expires<~Time> - An expiry time for this url
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~String> - url for object
-        #
-        # ==== See Also
         # https://cloud.google.com/storage/docs/access-control#Signed-URLs
-
+        #
+        # @param bucket_name [String] Name of bucket to read from
+        # @param object_name [String] Name of object to read
+        # @param expires [Time] Expiry time for this URL
+        # @return [String] Expiring object https URL
         include GetObjectHttpsUrl
       end
 

data/lib/fog/storage/google_json/requests/get_object_metadata.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # Fetch metadata for an object in Google Storage
+        #
+        # @param bucket_name [String] Name of bucket to read from
+        # @param object_name [String] Name of object to read
+        # @param options [Hash] Optional parameters
+        # @see https://cloud.google.com/storage/docs/json_api/v1/objects/get
+        #
+        # @return [Google::Apis::StorageV1::Object]
+        def get_object_metadata(bucket_name, object_name, options = {})
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
+
+          request_options = ::Google::Apis::RequestOptions.default.merge(options)
+          @storage_json.get_object(bucket_name, object_name,
+                                   :options => request_options)
+        end
+      end
+
+      class Mock
+        def get_object_metadata(_bucket_name, _object_name, _options = {})
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/google_json/requests/get_object_url.rb

@@ -4,16 +4,15 @@ module Fog
       class Real
         # Get an expiring object url from GCS
         # Deprecated, redirects to get_object_https_url.rb
-
         def get_object_url(bucket_name, object_name, expires)
-          Fog::Logger.deprecation("Fog::Storage::Google => ##{get_object_url} is deprecated, use ##{get_object_https_url} instead[/] [light_black](#{caller.first})")
+          Fog::Logger.deprecation("Fog::Storage::Google => ##{get_object_url} is deprecated, use ##{get_object_https_url} instead[/] [light_black](#{caller(0..0)})")
           get_object_https_url(bucket_name, object_name, expires)
         end
       end
 
       class Mock # :nodoc:all
         def get_object_url(bucket_name, object_name, expires)
-          Fog::Logger.deprecation("Fog::Storage::Google => ##{get_object_url} is deprecated, use ##{get_object_https_url} instead[/] [light_black](#{caller.first})")
+          Fog::Logger.deprecation("Fog::Storage::Google => ##{get_object_url} is deprecated, use ##{get_object_https_url} instead[/] [light_black](#{caller(0..0)})")
           get_object_https_url(bucket_name, object_name, expires)
         end
       end

data/lib/fog/storage/google_json/requests/list_bucket_acl.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # Get access control list for an Google Storage bucket
+        # @see https://cloud.google.com/storage/docs/json_api/v1/bucketAccessControls/list
+        #
+        # @param bucket_name [String] Name of bucket object is in
+        # @return [Google::Apis::StorageV1::BucketAccessControls]
+        def list_bucket_acl(bucket_name)
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+
+          @storage_json.list_bucket_access_controls(bucket_name)
+        end
+      end
+
+      class Mock
+        def list_bucket_acl(_bucket_name)
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/google_json/requests/list_buckets.rb

@@ -2,24 +2,20 @@ module Fog
   module Storage
     class GoogleJSON
       class Real
-        # Retrieves a list of buckets for a given project.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash> - Hash of bucket items
-        #     * 'kind'<~String> - The kind of item this is (storage#buckets)
-        #     * 'items'<~Array> - The array of items.
-        #
-        # ==== See Also
+        # Retrieves a list of buckets for a given project
         # https://cloud.google.com/storage/docs/json_api/v1/buckets/list
+        #
+        # @return [Google::Apis::StorageV1::Buckets]
         # TODO: check if very large lists require working with nextPageToken
-        def list_buckets
-          api_method = @storage_json.buckets.list
-          parameters = {
-            "project" => @project
-          }
-
-          request(api_method, parameters)
+        def list_buckets(max_results: nil, page_token: nil,
+                         prefix: nil, projection: nil)
+          @storage_json.list_buckets(
+            @project,
+            :max_results => max_results,
+            :page_token => page_token,
+            :prefix => prefix,
+            :projection => projection
+          )
         end
       end
       class Mock

data/lib/fog/storage/google_json/requests/list_object_acl.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # List access control list for an Google Storage object
+        # https://cloud.google.com/storage/docs/json_api/v1/objectAccessControls/get
+        #
+        # @param bucket_name [String] Name of bucket object is in
+        # @param object_name [String] Name of object to add ACL to
+        # @return [Google::Apis::StorageV1::ObjectAccessControls]
+        def list_object_acl(bucket_name, object_name, generation: nil)
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
+
+          @storage_json.list_object_access_controls(bucket_name, object_name,
+                                                    :generation => generation)
+        end
+      end
+
+      class Mock
+        def list_object_acl(_bucket_name, _object_name)
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/google_json/requests/list_objects.rb

@@ -4,8 +4,8 @@ module Fog
       class Real
         # Lists objects in a bucket matching some criteria.
         #
-        # @param bucket [String] name of bucket to list
-        # @param options [Hash] optional hash of options
+        # @param bucket [String] Name of bucket to list
+        # @param options [Hash] Optional hash of options
         # @option options [String] :delimiter Delimiter to collapse objects
         #   under to emulate a directory-like mode
         # @option options [Integer] :max_results Maximum number of results to
@@ -18,25 +18,10 @@ module Fog
         #   return (defaults to "noAcl")
         # @option options [Boolean] :versions If true, lists all versions of an
         #   object as distinct results (defaults to False)
+        # @return [Google::Apis::StorageV1::Objects]
         def list_objects(bucket, options = {})
-          api_method = @storage_json.objects.list
-          parameters = {
-            "bucket" => bucket
-          }
-
-          # Optional parameters
-          {
-            :delimiter   => "delimiter",
-            :max_results => "maxResults",
-            :page_token  => "pageToken",
-            :prefix      => "prefix",
-            :projection  => "projection",
-            :versions    => "versions"
-          }.each do |k, v|
-            parameters[v] = options[k] unless options[k].nil?
-          end
-
-          request(api_method, parameters)
+          request_options = ::Google::Apis::RequestOptions.default.merge(options)
+          @storage_json.list_objects(bucket, :options => request_options)
         end
       end
 

data/lib/fog/storage/google_json/requests/put_bucket.rb

@@ -3,70 +3,36 @@ module Fog
     class GoogleJSON
       class Real
         # Create a Google Storage bucket
+        # @see https://cloud.google.com/storage/docs/json_api/v1/buckets/insert
         #
-        # ==== Parameters
-        # * bucket_name<~String> - name of bucket to create
-        # * options<~Hash> - config arguments for bucket.  Defaults to {}.
-        #   * 'LocationConstraint'<~Symbol> - sets the location for the bucket
-        #   * 'predefinedAcl'<~String> - Apply a predefined set of access controls to this bucket.
-        #   * 'predefinedDefaultObjectAcl'<~String> - Apply a predefined set of default object access controls to this bucket.
-        # * body_options<~Hash> - body arguments for bucket creation.
-        #   See https://cloud.google.com/storage/docs/json_api/v1/buckets/insert#request-body
+        # @param bucket_name [String] Name of bucket to create
+        # @param options [Hash]
+        #   Optional fields. Acceptable options include
+        #   any writeable bucket attribute (see docs)
+        #   or one of the following options:
+        # @param predefined_acl [String] Applies a predefined set of access controls to this bucket.
+        # @param predefined_default_object_acl [String] Applies a predefined set of default object access controls
         #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * status<~Integer> - 200
-        #
-        # ==== See also
-        # https://cloud.google.com/storage/docs/json_api/v1/buckets/insert
-        def put_bucket(bucket_name, options = {}, body_options = {})
-          location = options["LocationConstraint"] if options["LocationConstraint"]
-
-          api_method = @storage_json.buckets.insert
-          parameters = {
-            "project" => @project,
-            "projection" => "full"
-          }
-          parameters.merge! options
-          body_object = {
-            "name" => bucket_name,
-            "location" => location
-          }
-          body_object.merge! body_options
+        # @return [Google::Apis::StorageV1::Bucket]
+        def put_bucket(bucket_name,
+                       predefined_acl: nil,
+                       predefined_default_object_acl: nil,
+                       **options)
+          bucket = ::Google::Apis::StorageV1::Bucket.new(
+            options.merge(:name => bucket_name)
+          )
 
-          request(api_method, parameters, body_object = body_object)
+          @storage_json.insert_bucket(
+            @project, bucket,
+            :predefined_acl => predefined_acl,
+            :predefined_default_object_acl => predefined_default_object_acl
+          )
         end
       end
 
       class Mock
-        def put_bucket(bucket_name, options = {}, _body_options = {})
-          acl = options["x-goog-acl"] || "private"
-          if !%w(private publicRead publicReadWrite authenticatedRead).include?(acl)
-            raise Excon::Errors::BadRequest.new("invalid x-goog-acl")
-          else
-            data[:acls][:bucket][bucket_name] = self.class.acls(options[acl])
-          end
-          response = Excon::Response.new
-          response.status = 200
-          bucket = {
-            :objects        => {},
-            "Name"          => bucket_name,
-            "CreationDate"  => Time.now,
-            "Owner"         => { "DisplayName" => "owner", "ID" => "some_id" },
-            "Payer"         => "BucketOwner"
-          }
-          if options["LocationConstraint"]
-            bucket["LocationConstraint"] = options["LocationConstraint"]
-          else
-            bucket["LocationConstraint"] = ""
-          end
-          if data[:buckets][bucket_name].nil?
-            data[:buckets][bucket_name] = bucket
-          else
-            response.status = 409
-            raise(Excon::Errors.status_error({ :expects => 200 }, response))
-          end
-          response
+        def put_bucket(_bucket_name, _options = {})
+          Fog::Mock.not_implemented
         end
       end
     end

data/lib/fog/storage/google_json/requests/put_bucket_acl.rb

@@ -1,32 +1,25 @@
 module Fog
   module Storage
     class GoogleJSON
-      class Mock
-        def put_bucket_acl(_bucket_name, _acl)
-          Fog::Mock.not_implemented
-        end
-      end
-
       class Real
         # Change access control list for an Google Storage bucket
         # https://cloud.google.com/storage/docs/json_api/v1/bucketAccessControls/insert
         #
-        # ==== Parameters
-        # * bucket_name<~String> - name of bucket to create
-        # * acl<~Hash> - ACL hash to add to bucket, see GCS documentation above
-        #    * entity
-        #    * role
-        def put_bucket_acl(bucket_name, acl)
+        # @param bucket_name [String] Name of bucket object is in
+        # @param acl [Hash] ACL hash to add to bucket, see GCS documentation above
+        # @return [Google::Apis::StorageV1::BucketAccessControl]
+        def put_bucket_acl(bucket_name, acl = {})
           raise ArgumentError.new("bucket_name is required") unless bucket_name
           raise ArgumentError.new("acl is required") unless acl
 
-          api_method = @storage_json.bucket_access_controls.insert
-          parameters = {
-            "bucket" => bucket_name
-          }
-          body_object = acl
+          acl_update = ::Google::Apis::StorageV1::BucketAccessControl.new(acl)
+          @storage_json.insert_bucket_access_control(bucket_name, acl_update)
+        end
+      end
 
-          request(api_method, parameters, body_object = body_object)
+      class Mock
+        def put_bucket_acl(_bucket_name, _acl)
+          Fog::Mock.not_implemented
         end
       end
     end

data/lib/fog/storage/google_json/requests/put_object.rb

@@ -5,112 +5,83 @@ module Fog
         # Create an object in an Google Storage bucket
         # https://cloud.google.com/storage/docs/json_api/v1/objects/insert
         #
-        # ==== Parameters
-        # * bucket_name<~String> - Name of bucket to create object in
-        # * object_name<~String> - Name of object to create
-        # * data<~File> - File or String to create object from
-        # * options<~Hash>:
-        #   * 'Cache-Control'<~String> - Caching behaviour
-        #   * 'Content-Disposition'<~String> - Presentational information for the object
-        #   * 'Content-Encoding'<~String> - Encoding of object data
-        #   * 'Content-Length'<~String> - Size of object in bytes (defaults to object.read.length)
-        #   * 'Content-MD5'<~String> - Base64 encoded 128-bit MD5 digest of message (defaults to Base64 encoded MD5 of object.read)
-        #   * 'Content-Type'<~String> - Standard MIME type describing contents (defaults to MIME::Types.of.first)
-        #   * 'x-goog-acl'<~String> - Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']
-        #   * "x-goog-meta-#{name}" - Headers to be returned with object, note total size of request without body must be less than 8 KB.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * headers<~Hash>:
-        #     * 'ETag'<~String> - etag of new object
-        def put_object(bucket_name, object_name, data, options = {})
-          if options["contentType"]
-            mime_type = options["contentType"]
-            if data.is_a? String
+        # @param bucket_name [String] Name of bucket to create object in
+        # @param object_name [String] Name of object to create
+        # @param data [File|String|Paperclip::AbstractAdapter] File, String or Paperclip adapter to create object from
+        # @param options [Hash] Optional query parameters or Object attributes
+        #   Optional query parameters are listed below.
+        # @param content_encoding [String]
+        #   If set, sets the contentEncoding property of the final object to
+        #   this value.
+        # @param if_generation_match [Fixnum]
+        #   Makes the operation conditional on whether the object's current
+        #   generation matches the given value. Setting to 0 makes the operation
+        #   succeed only if there are no live versions of the object.
+        # @param if_generation_not_match [Fixnum]
+        #   Makes the operation conditional on whether the object's current
+        #   generation does not match the given value. If no live object exists,
+        #   the precondition fails. Setting to 0 makes the operation succeed
+        #   only if there is a live version of the object.
+        # @param if_metageneration_match [Fixnum]
+        #   Makes the operation conditional on whether the object's
+        #   current metageneration matches the given value.
+        # @param if_metageneration_not_match [Fixnum]
+        #   Makes the operation conditional on whether the object's
+        #   current metageneration does not match the given value.
+        # @param predefined_acl [String]
+        #   Apply a predefined set of access controls to this object.
+        # @param projection [String]
+        #   Set of properties to return. Defaults to noAcl,
+        #   unless the object resource specifies the acl property,
+        #   when it defaults to full.
+        # @return [Google::Apis::StorageV1::Object]
+        def put_object(bucket_name,
+                       object_name,
+                       data,
+                       content_encoding: nil,
+                       if_generation_match: nil,
+                       if_generation_not_match: nil,
+                       if_metageneration_match: nil,
+                       if_metageneration_not_match: nil,
+                       kms_key_name: nil,
+                       predefined_acl: nil,
+                       **options)
+          unless options[:content_type]
+            if data.is_a?(String)
               data = StringIO.new(data)
+              options[:content_type] = "text/plain"
+            elsif data.is_a?(::File)
+              options[:content_type] = Fog::Storage.parse_data(data)[:headers]["Content-Type"]
+            elsif data.respond_to?(:content_type) && data.respond_to?(:path)
+              options[:content_type] = data.content_type
+              data = data.path
             end
-          elsif data.is_a? String
-            data = StringIO.new(data)
-            mime_type = "text/plain"
-          elsif data.is_a? ::File
-            mime_type = Fog::Storage.parse_data(data)[:headers]["Content-Type"]
-          end
-
-          media = ::Google::APIClient::UploadIO.new(data, mime_type, object_name)
-          api_method = @storage_json.objects.insert
-          parameters = {
-            "uploadType" => "multipart",
-            "bucket" => bucket_name,
-            "name" => object_name
-          }
-
-          body_object = {
-            :contentType => mime_type,
-            :contentEncoding => options["contentEncoding"]
-          }
-          body_object.merge! options
-
-          acl = []
-          case options["predefinedAcl"]
-          when "publicRead"
-            acl.push({ "entity" => "allUsers", "role" => "READER" })
-          when "publicReadWrite"
-            acl.push({ "entity" => "allUsers", "role" => "OWNER" })
-          when "authenticatedRead"
-            acl.push({ "entity" => "allAuthenticatedUsers", "role" => "READER" })
           end
 
-          unless acl.empty?
-            body_object[:acl] = acl
-          end
+          object_config = ::Google::Apis::StorageV1::Object.new(
+            options.merge(:name => object_name)
+          )
 
-          request(api_method, parameters, body_object = body_object, media = media)
+          @storage_json.insert_object(
+            bucket_name, object_config,
+            :content_encoding => content_encoding,
+            :if_generation_match => if_generation_match,
+            :if_generation_not_match => if_generation_not_match,
+            :if_metageneration_match => if_metageneration_match,
+            :if_metageneration_not_match => if_metageneration_not_match,
+            :kms_key_name => kms_key_name,
+            :predefined_acl => predefined_acl,
+            :options => ::Google::Apis::RequestOptions.default.merge(options),
+            # see https://developers.google.com/api-client-library/ruby/guide/media_upload
+            :content_type => options[:content_type],
+            :upload_source => data
+          )
         end
       end
 
       class Mock
-        def put_object(bucket_name, object_name, data, options = {})
-          acl = options["x-goog-acl"] || "private"
-          if !%w(private publicRead publicReadWrite authenticatedRead).include?(acl)
-            raise Excon::Errors::BadRequest.new("invalid x-goog-acl")
-          else
-            self.data[:acls][:object][bucket_name] ||= {}
-            self.data[:acls][:object][bucket_name][object_name] = self.class.acls(acl)
-          end
-
-          data = Fog::Storage.parse_data(data)
-          data[:body] = data[:body].read unless data[:body].is_a?(String)
-          response = Excon::Response.new
-          if (bucket = self.data[:buckets][bucket_name])
-            response.status = 200
-            object = {
-              :body             => data[:body],
-              "Content-Type"    => options["Content-Type"] || data[:headers]["Content-Type"],
-              "ETag"            => Fog::Google::Mock.etag,
-              "Key"             => object_name,
-              "Last-Modified"   => Fog::Time.now.to_date_header,
-              "Content-Length"  => options["Content-Length"] || data[:headers]["Content-Length"]
-            }
-
-            for key, value in options
-              case key
-              when "Cache-Control", "Content-Disposition", "Content-Encoding", "Content-MD5", "Expires", /^x-goog-meta-/
-                object[key] = value
-              end
-            end
-
-            bucket[:objects][object_name] = object
-            response.headers = {
-              "Content-Length"  => object["Content-Length"],
-              "Content-Type"    => object["Content-Type"],
-              "ETag"            => object["ETag"],
-              "Last-Modified"   => object["Last-Modified"]
-            }
-          else
-            response.status = 404
-            raise(Excon::Errors.status_error({ :expects => 200 }, response))
-          end
-          response
+        def put_object(_bucket_name, _object_name, _data, _options = {})
+          Fog::Mock.not_implemented
         end
       end
     end