fog-google 0.6.0 → 1.0.0

data/lib/fog/storage/google_json/real.rb

@@ -14,7 +14,7 @@ module Fog
           @host = options[:host] || "storage.googleapis.com"
 
           @client = initialize_google_client(options)
-          @storage_json = @client.discovered_api("storage", api_version)
+          @storage_json = ::Google::Apis::StorageV1::StorageService.new
         end
 
         def signature(params)
@@ -31,7 +31,7 @@ DATA
             google_headers[key] = value if key[0..6] == "x-goog-"
           end
 
-          google_headers = google_headers.sort { |x, y| x[0] <=> y[0] }
+          google_headers = google_headers.sort_by { |a| a[0] }
           google_headers.each do |key, value|
             canonical_google_headers << "#{key}:#{value}\n"
           end
@@ -43,7 +43,7 @@ DATA
           end
           canonical_resource << params[:path].to_s
           canonical_resource << "?"
-          for key in (params[:query] || {}).keys
+          (params[:query] || {}).each_key do |key|
             if %w(acl cors location logging requestPayment versions versioning).include?(key)
               canonical_resource << "#{key}&"
             end
@@ -51,7 +51,7 @@ DATA
           canonical_resource.chop!
           string_to_sign << canonical_resource.to_s
 
-          key = OpenSSL::PKey::RSA.new(@client.authorization.signing_key)
+          key = OpenSSL::PKey::RSA.new(@client.signing_key)
           digest = OpenSSL::Digest::SHA256.new
           signed_string = key.sign(digest, string_to_sign)
 

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

@@ -3,62 +3,27 @@ module Fog
     class GoogleJSON
       class Real
         # Copy an object from one Google Storage bucket to another
-        # https://cloud.google.com/storage/docs/json_api/v1/objects/copy
         #
-        # ==== Parameters
-        # * source_bucket_name<~String> - Name of source bucket
-        # * source_object_name<~String> - Name of source object
-        # * target_bucket_name<~String> - Name of bucket to create copy in
-        # * target_object_name<~String> - Name for new copy of object
-        # * options<~Hash>:
-        #   * 'x-goog-metadata-directive'<~String> - Specifies whether to copy metadata from source or replace with data in request.  Must be in ['COPY', 'REPLACE']
-        #   * 'x-goog-copy_source-if-match'<~String> - Copies object if its etag matches this value
-        #   * 'x-goog-copy_source-if-modified_since'<~Time> - Copies object it it has been modified since this time
-        #   * 'x-goog-copy_source-if-none-match'<~String> - Copies object if its etag does not match this value
-        #   * 'x-goog-copy_source-if-unmodified-since'<~Time> - Copies object it it has not been modified since this time
+        # @param source_bucket [String] Name of source bucket
+        # @param source_object [String] Name of source object
+        # @param target_bucket [String] Name of bucket to create copy in
+        # @param target_object [String] Name of new copy of object
         #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'ETag'<~String> - etag of new object
-        #     * 'LastModified'<~Time> - date object was last modified
-        #
-        def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
-          api_method = @storage_json.objects.copy
-          parameters = {
-            "sourceBucket" => source_bucket_name,
-            "sourceObject" => source_object_name,
-            "destinationBucket" => target_bucket_name,
-            "destinationObject" => target_object_name
-          }
-          parameters.merge! options
-
-          request(api_method, parameters)
+        # @see https://cloud.google.com/storage/docs/json_api/v1/objects/copy
+        # @return [Google::Apis::StorageV1::Object] copy of object
+        def copy_object(source_bucket, source_object,
+                        target_bucket, target_object, options = {})
+          request_options = ::Google::Apis::RequestOptions.default.merge(options)
+          @storage_json.copy_object(source_bucket, source_object,
+                                    target_bucket, target_object,
+                                    request_options)
         end
       end
 
       class Mock
-        def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, _options = {})
-          response = Excon::Response.new
-          source_bucket = data[:buckets][source_bucket_name]
-          source_object = source_bucket && source_bucket[:objects][source_object_name]
-          target_bucket = data[:buckets][target_bucket_name]
-
-          if source_object && target_bucket
-            response.status = 200
-            target_object = source_object.dup
-            target_object.merge!("Name" => target_object_name)
-            target_bucket[:objects][target_object_name] = target_object
-            response.body = {
-              "ETag"          => target_object["ETag"],
-              "LastModified"  => Time.parse(target_object["Last-Modified"])
-            }
-          else
-            response.status = 404
-            raise(Excon::Errors.status_error({ :expects => 200 }, response))
-          end
-
-          response
+        def copy_object(_source_bucket, _source_object,
+                        _target_bucket, _target_object, _options = {})
+          Fog::Mock.not_implemented
         end
       end
     end

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

@@ -5,36 +5,15 @@ module Fog
         # Delete an Google Storage bucket
         # https://cloud.google.com/storage/docs/json_api/v1/buckets/delete
         #
-        # ==== Parameters
-        # * bucket_name<~String> - name of bucket to delete
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * status<~Integer> - 204
+        # @param bucket_name [String] Name of bucket to delete
         def delete_bucket(bucket_name)
-          api_method = @storage_json.buckets.delete
-          parameters = {
-            "bucket" => bucket_name
-          }
-
-          request(api_method, parameters)
+          @storage_json.delete_bucket(bucket_name)
         end
       end
 
       class Mock
-        def delete_bucket(bucket_name)
-          response = Excon::Response.new
-          if data[:buckets][bucket_name].nil?
-            response.status = 404
-            raise(Excon::Errors.status_error({ :expects => 204 }, response))
-          elsif data[:buckets][bucket_name] && !data[:buckets][bucket_name][:objects].empty?
-            response.status = 409
-            raise(Excon::Errors.status_error({ :expects => 204 }, response))
-          else
-            data[:buckets].delete(bucket_name)
-            response.status = 204
-          end
-          response
+        def delete_bucket(_bucket_name)
+          Fog::Mock.not_implemented
         end
       end
     end

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

@@ -5,40 +5,16 @@ module Fog
         # Delete an object from Google Storage
         # https://cloud.google.com/storage/docs/json_api/v1/objects/delete
         #
-        # ==== Parameters
-        # * bucket_name<~String> - Name of bucket containing object to delete
-        # * object_name<~String> - Name of object to delete
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * status<~Integer> - 204
+        # @param bucket_name [String] Name of bucket containing object to delete
+        # @param object_name [String] Name of object to delete
         def delete_object(bucket_name, object_name)
-          api_method = @storage_json.objects.delete
-          parameters = {
-            "bucket" => bucket_name,
-            "object" => object_name
-          }
-
-          request(api_method, parameters)
+          @storage_json.delete_object(bucket_name, object_name)
         end
       end
 
       class Mock
-        def delete_object(bucket_name, object_name)
-          response = Excon::Response.new
-          if bucket = data[:buckets][bucket_name]
-            if object = bucket[:objects][object_name]
-              response.status = 204
-              bucket[:objects].delete(object_name)
-            else
-              response.status = 404
-              raise(Excon::Errors.status_error({ :expects => 204 }, response))
-            end
-          else
-            response.status = 404
-            raise(Excon::Errors.status_error({ :expects => 204 }, response))
-          end
-          response
+        def delete_object(_bucket_name, _object_name)
+          Fog::Mock.not_implemented
         end
       end
     end

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

@@ -2,81 +2,38 @@ module Fog
   module Storage
     class GoogleJSON
       class Real
-        # List information about objects in an Google Storage bucket
+        # List information about objects in an Google Storage bucket #
+        # https://cloud.google.com/storage/docs/json_api/v1/buckets#resource
         #
-        # ==== Parameters
-        # * bucket_name<~String> - name of bucket to list object keys from
-        # * options<~Hash> - config arguments for list.  Defaults to {}.
-        #   * 'ifMetagenerationMatch'<~Long> - Makes the return of the bucket metadata
-        #     conditional on whether the bucket's current metageneration matches the
-        #     given value.
-        #   * 'ifMetagenerationNotMatch'<~Long> - Makes the return of the bucket
-        #     metadata conditional on whether the bucket's current metageneration does
-        #     not match the given value.
-        #   * 'projection'<~String> - Set of properties to return. Defaults to 'noAcl',
-        #     also accepts 'full'.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     See Google documentation on Bucket resource:
-        #     https://cloud.google.com/storage/docs/json_api/v1/buckets#resource
-        #
-
-        def get_bucket(bucket_name, options = {})
+        # @param bucket_name [String]
+        #   Name of bucket to list
+        # @param [Fixnum] if_metageneration_match
+        #   Makes the return of the bucket metadata conditional on whether the bucket's
+        #   current metageneration matches the given value.
+        # @param [Fixnum] if_metageneration_not_match
+        #   Makes the return of the bucket metadata conditional on whether the bucket's
+        #   current metageneration does not match the given value.
+        # @param [String] projection
+        #   Set of properties to return. Defaults to noAcl.
+        # @return [Google::Apis::StorageV1::Bucket]
+        def get_bucket(bucket_name,
+                       if_metageneration_match: nil,
+                       if_metageneration_not_match: nil,
+                       projection: nil)
           raise ArgumentError.new("bucket_name is required") unless bucket_name
 
-          api_method = @storage_json.buckets.get
-          parameters = {
-            "bucket" => bucket_name
-          }
-          parameters.merge! options
-
-          request(api_method, parameters)
+          @storage_json.get_bucket(
+            bucket_name,
+            :if_metageneration_match => if_metageneration_match,
+            :if_metageneration_not_match => if_metageneration_not_match,
+            :projection => projection
+          )
         end
       end
 
       class Mock
-        def get_bucket(bucket_name, options = {})
-          raise ArgumentError.new("bucket_name is required") unless bucket_name
-          response = Excon::Response.new
-          name = /(\w+\.?)*/.match(bucket_name)
-          if bucket_name == name.to_s
-            if bucket = data[:buckets][bucket_name]
-              contents = bucket[:objects].values.sort { |x, y| x["Key"] <=> y["Key"] }.reject do |object|
-                (options["prefix"] && object["Key"][0...options["prefix"].length] != options["prefix"]) ||
-                (options["marker"] && object["Key"] <= options["marker"])
-              end.map do |object|
-                data = object.reject { |key, _value| !%w(ETag Key).include?(key) }
-                data.merge!("LastModified" => Time.parse(object["Last-Modified"]),
-                            "Owner"        => bucket["Owner"],
-                            "Size"         => object["Content-Length"].to_i)
-                data
-              end
-              max_keys = options["max-keys"] || 1000
-              size = [max_keys, 1000].min
-              truncated_contents = contents[0...size]
-
-              response.status = 200
-              response.body = {
-                "CommonPrefixes"  => [],
-                "Contents"        => truncated_contents,
-                "Marker"          => options["marker"],
-                "Name"            => bucket["Name"],
-                "Prefix"          => options["prefix"]
-              }
-              if options["max-keys"] && options["max-keys"] < response.body["Contents"].length
-                response.body["Contents"] = response.body["Contents"][0...options["max-keys"]]
-              end
-            else
-              response.status = 404
-              raise(Excon::Errors.status_error({ :expects => 200 }, response))
-            end
-          else
-            response.status = 400
-            raise(Excon::Errors.status_error({ :expects => 200 }, response))
-          end
-          response
+        def get_bucket(_bucket_name, _options = {})
+          Fog::Mock.not_implemented
         end
       end
     end

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

@@ -2,51 +2,27 @@ module Fog
   module Storage
     class GoogleJSON
       class Real
-        # Get access control list for an Google Storage bucket
-        # https://cloud.google.com/storage/docs/json_api/v1/bucketAccessControls/list
+        # Get access control list entry for an Google Storage bucket
+        # @see https://cloud.google.com/storage/docs/json_api/v1/bucketAccessControls/get
         #
-        # ==== Parameters
-        # * bucket_name<~String> - name of bucket to get access control list for
-        #
-        # ==== 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_bucket_acl(bucket_name)
+        # @param bucket_name [String]
+        #   Name of bucket
+        # @param entity [String]
+        #   The entity holding the permission. Can be user-userId,
+        #   user-emailAddress, group-groupId, group-emailAddress, allUsers,
+        #   or allAuthenticatedUsers.
+        # @return [Google::Apis::StorageV1::BucketAccessControls]
+        def get_bucket_acl(bucket_name, entity)
           raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("entity is required") unless entity
 
-          api_method = @storage_json.bucket_access_controls.list
-          parameters = {
-            "bucket" => bucket_name
-          }
-
-          request(api_method, parameters)
+          @storage_json.get_bucket_access_control(bucket_name, entity)
         end
       end
 
       class Mock
-        def get_bucket_acl(bucket_name)
-          response = Excon::Response.new
-          if acl = data[:acls][:bucket][bucket_name]
-            response.status = 200
-            response.body = acl
-          else
-            response.status = 404
-            raise(Excon::Errors.status_error({ :expects => 200 }, response))
-          end
-          response
+        def get_bucket_acl(_bucket_name, _entity)
+          Fog::Mock.not_implemented
         end
       end
     end

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

@@ -1,96 +1,74 @@
+require "tempfile"
+
 module Fog
   module Storage
     class GoogleJSON
       class Real
         # Get an object from Google Storage
-        # https://cloud.google.com/storage/docs/json_api/v1/objects/get
-        #
-        # ==== Parameters
-        # * bucket_name<~String> - Name of bucket to read from
-        # * object_name<~String> - Name of object to read
-        # * options<~Hash>:
-        #   * 'If-Match'<~String> - Returns object only if its etag matches this value, otherwise returns 412 (Precondition Failed).
-        #   * 'If-Modified-Since'<~Time> - Returns object only if it has been modified since this time, otherwise returns 304 (Not Modified).
-        #   * 'If-None-Match'<~String> - Returns object only if its etag differs from this value, otherwise returns 304 (Not Modified)
-        #   * 'If-Unmodified-Since'<~Time> - Returns object only if it has not been modified since this time, otherwise returns 412 (Precodition Failed).
-        #   * 'Range'<~String> - Range of object to download
-        #   * 'versionId'<~String> - specify a particular version to retrieve
+        # @see https://cloud.google.com/storage/docs/json_api/v1/objects/get
         #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~String> - Contents of object
-        #   * headers<~Hash>:
-        #     * 'Content-Length'<~String> - Size of object contents
-        #     * 'Content-Type'<~String> - MIME type of object
-        #     * 'ETag'<~String> - Etag of object
-        #     * 'Last-Modified'<~String> - Last modified timestamp for object
-        #
-        def get_object(bucket_name, object_name, _options = {}, &_block)
+        # @param bucket_name [String] Name of bucket to create object in
+        # @param object_name [String] Name of object to create
+        # @param generation [Fixnum]
+        #   If present, selects a specific revision of this object (as opposed to the latest version, the default).
+        # @param ifGenerationMatch [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 ifGenerationNotMatch [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 ifMetagenerationMatch [Fixnum]
+        #   Makes the operation conditional on whether the object's current metageneration matches the given value.
+        # @param ifMetagenerationNotMatch [Fixnum]
+        #   Makes the operation conditional on whether the object's current metageneration does not match the given value.
+        # @param projection [Fixnum]
+        #   Set of properties to return
+        # @param options [Hash]
+        #   Request-specific options
+        # @return [Hash] Object metadata with :body attribute set to contents of object
+        def get_object(bucket_name, object_name,
+                       generation: nil,
+                       if_generation_match: nil,
+                       if_generation_not_match: nil,
+                       if_metageneration_match: nil,
+                       if_metageneration_not_match: nil,
+                       projection: nil,
+                       **options)
           raise ArgumentError.new("bucket_name is required") unless bucket_name
           raise ArgumentError.new("object_name is required") unless object_name
 
-          api_method = @storage_json.objects.get
-          parameters = {
-            "bucket" => bucket_name,
-            "object" => object_name,
-            "projection" => "full"
+          # The previous semantics require returning the content of the request
+          # rather than taking a filename to populate. Hence, tempfile.
+          buf = Tempfile.new("fog-google-storage-temp")
+
+          # Two requests are necessary, first for metadata, then for content.
+          # google-api-ruby-client doesn't allow fetching both metadata and content
+          request_options = ::Google::Apis::RequestOptions.default.merge(options)
+          all_opts = {
+            :generation => generation,
+            :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,
+            :projection => projection,
+            :options => request_options
           }
 
-          object = request(api_method, parameters)
+          object = @storage_json.get_object(bucket_name, object_name, all_opts).to_h
+          @storage_json.get_object(
+            bucket_name,
+            object_name,
+            all_opts.merge(:download_dest => buf.path)
+          )
 
-          # Get the body of the object (can't use request for this)
-          parameters["alt"] = "media"
-          client_parms = {
-            :api_method => api_method,
-            :parameters => parameters
-          }
+          object[:body] = buf.read
+          buf.unlink
 
-          result = @client.execute(client_parms)
-          object.headers = object.body
-          object.body = result.body.nil? || result.body.empty? ? nil : result.body
           object
         end
       end
 
       class Mock
-        def get_object(bucket_name, object_name, options = {}, &block)
-          raise ArgumentError.new("bucket_name is required") unless bucket_name
-          raise ArgumentError.new("object_name is required") unless object_name
-          response = Excon::Response.new
-          if (bucket = data[:buckets][bucket_name]) && (object = bucket[:objects][object_name])
-            if options["If-Match"] && options["If-Match"] != object["ETag"]
-              response.status = 412
-            elsif options["If-Modified-Since"] && options["If-Modified-Since"] >= Time.parse(object["Last-Modified"])
-              response.status = 304
-            elsif options["If-None-Match"] && options["If-None-Match"] == object["ETag"]
-              response.status = 304
-            elsif options["If-Unmodified-Since"] && options["If-Unmodified-Since"] < Time.parse(object["Last-Modified"])
-              response.status = 412
-            else
-              response.status = 200
-              for key, value in object
-                case key
-                when "Cache-Control", "Content-Disposition", "Content-Encoding", "Content-Length", "Content-MD5", "Content-Type", "ETag", "Expires", "Last-Modified", /^x-goog-meta-/
-                  response.headers[key] = value
-                end
-              end
-              unless block_given?
-                response.body = object[:body]
-              else
-                data = StringIO.new(object[:body])
-                remaining = data.length
-                while remaining > 0
-                  chunk = data.read([remaining, Excon::CHUNK_SIZE].min)
-                  block.call(chunk)
-                  remaining -= Excon::CHUNK_SIZE
-                end
-              end
-            end
-          else
-            response.status = 404
-            raise(Excon::Errors.status_error({ :expects => 200 }, response))
-          end
-          response
+        def get_object(_bucket_name, _object_name, _options = {})
+          Fog::Mock.not_implemented
         end
       end
     end