gitlab-fog-google 1.13.0

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

@@ -0,0 +1,26 @@
+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)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # 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(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
+        def list_buckets
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+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)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      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
+        # @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
+        #   retrieve
+        # @option options [String] :page_token Token to select a particular page
+        #   of results
+        # @option options [String] :prefix String that an object must begin with
+        #   in order to be returned
+        # @option options ["full", "noAcl"] :projection Set of properties to
+        #   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 = {})
+          allowed_opts = %i(
+            delimiter
+            max_results
+            page_token
+            prefix
+            projection
+            versions
+          )
+
+          @storage_json.list_objects(
+            bucket,
+            options.select { |k, _| allowed_opts.include? k }
+          )
+        end
+      end
+
+      class Mock
+        def list_objects(_bucket, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # Create a Google Storage bucket
+        # @see https://cloud.google.com/storage/docs/json_api/v1/buckets/insert
+        #
+        # @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
+        #
+        # @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)
+          )
+
+          @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 = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # Change access control list for an Google Storage bucket
+        # https://cloud.google.com/storage/docs/json_api/v1/bucketAccessControls/insert
+        #
+        # @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
+
+          acl_update = ::Google::Apis::StorageV1::BucketAccessControl.new(acl)
+          @storage_json.insert_bucket_access_control(bucket_name, acl_update)
+        end
+      end
+
+      class Mock
+        def put_bucket_acl(_bucket_name, _acl)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # Create an object in an Google Storage bucket
+        # https://cloud.google.com/storage/docs/json_api/v1/objects/insert
+        #
+        # @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)
+          data, options = normalize_data(data, options)
+
+          object_config = ::Google::Apis::StorageV1::Object.new(
+            options.merge(:name => object_name)
+          )
+
+          @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
+
+        protected
+
+        def normalize_data(data, options)
+          raise ArgumentError.new("data is required") unless data
+          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"]
+          end
+
+          # Paperclip::AbstractAdapter
+          if data.respond_to?(:content_type) && data.respond_to?(:path)
+            options[:content_type] ||= data.content_type
+            data = data.path
+          end
+          [data, options]
+        end
+      end
+
+      class Mock
+        def put_object(_bucket_name, _object_name, _data, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # Change access control list for an Google Storage object
+        #
+        # @param bucket_name [String] name of bucket object is in
+        # @param object_name [String] name of object to add ACL to
+        # @param acl [Hash] ACL hash to add to bucket, see GCS documentation.
+        #
+        # @see https://cloud.google.com/storage/docs/json_api/v1/objectAccessControls/insert
+        # @return [Google::Apis::StorageV1::ObjectAccessControl]
+        def put_object_acl(bucket_name, object_name, acl)
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
+          raise ArgumentError.new("acl is required") unless acl
+
+          acl_object = ::Google::Apis::StorageV1::ObjectAccessControl.new(acl)
+
+          @storage_json.insert_object_access_control(
+            bucket_name, object_name, acl_object
+          )
+        end
+      end
+
+      class Mock
+        def put_object_acl(_bucket_name, _object_name, _acl)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # Get an expiring object url from Google Storage for putting an object
+        # https://cloud.google.com/storage/docs/access-control#Signed-URLs
+        #
+        # @param bucket_name [String] Name of bucket containing object
+        # @param object_name [String] Name of object to get expiring url for
+        # @param expires [Time] Expiry time for this URL
+        # @param headers [Hash] Optional hash of headers to include
+        # @option options [String] "x-goog-acl" Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read'].
+        #     If you want a file to be public you should to add { 'x-goog-acl' => 'public-read' } to headers
+        #     and then call for example: curl -H "x-goog-acl:public-read" "signed url"
+        # @return [String] Expiring object https URL
+        def put_object_url(bucket_name, object_name, expires, headers = {})
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
+          https_url({
+                      :headers  => headers,
+                      :host     => @host,
+                      :method   => "PUT",
+                      :path     => "#{bucket_name}/#{object_name}"
+                    }, expires)
+        end
+      end
+
+      class Mock
+        def put_object_url(bucket_name, object_name, expires, headers = {})
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
+          https_url({
+                      :headers  => headers,
+                      :host     => @host,
+                      :method   => "PUT",
+                      :path     => "#{bucket_name}/#{object_name}"
+                    }, expires)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'addressable'
+
+module Fog
+  module Storage
+    class GoogleJSON
+      module Utils
+        def http_url(params, expires)
+          "http://" << host_path_query(params, expires)
+        end
+
+        def https_url(params, expires)
+          "https://" << host_path_query(params, expires)
+        end
+
+        def url(params, expires)
+          Fog::Logger.deprecation("Fog::Storage::Google => #url is deprecated, use #https_url instead [light_black](#{caller.first})[/]")
+          https_url(params, expires)
+        end
+
+        private
+
+        def host_path_query(params, expires)
+          params[:headers]["Date"] = expires.to_i
+          params[:path] = ::Addressable::URI.encode_component(params[:path], Addressable::URI::CharacterClasses::PATH)
+          query = []
+
+          if params[:query]
+            filtered = params[:query].reject { |k, v| k.nil? || v.nil? }
+            query = filtered.map { |k, v| [k.to_s, Fog::Google.escape(v)].join("=") }
+          end
+
+          query << "GoogleAccessId=#{google_access_id}"
+          query << "Signature=#{CGI.escape(signature(params))}"
+          query << "Expires=#{params[:headers]['Date']}"
+          "#{params[:host]}/#{params[:path]}?#{query.join('&')}"
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/google_xml.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Storage
+    class GoogleXML < Fog::Service
+      autoload :Mock, File.expand_path("../google_xml/mock", __FILE__)
+      autoload :Real, File.expand_path("../google_xml/real", __FILE__)
+      autoload :Utils, File.expand_path("../google_xml/utils", __FILE__)
+
+      requires :google_storage_access_key_id, :google_storage_secret_access_key
+      recognizes :host, :port, :scheme, :persistent, :path_style
+
+      model_path "fog/storage/google_xml/models"
+      collection :directories
+      model :directory
+      collection :files
+      model :file
+
+      request_path "fog/storage/google_xml/requests"
+      request :copy_object
+      request :delete_bucket
+      request :delete_object
+      request :delete_object_url
+      request :get_bucket
+      request :get_bucket_acl
+      request :get_object
+      request :get_object_acl
+      request :get_object_http_url
+      request :get_object_https_url
+      request :get_object_url
+      request :get_service
+      request :head_object
+      request :put_bucket
+      request :put_bucket_acl
+      request :put_object
+      request :put_object_acl
+      request :put_object_url
+    end
+  end
+end