gitlab-fog-google 1.13.0

data/lib/fog/storage/google_xml/mock.rb

@@ -0,0 +1,102 @@
+module Fog
+  module Storage
+    class GoogleXML
+      class Mock
+        include Utils
+
+        def self.acls(type)
+          case type
+          when "private"
+            {
+              "AccessControlList" => [
+                {
+                  "Permission" => "FULL_CONTROL",
+                  "Scope" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0", "type" => "UserById" }
+                }
+              ],
+              "Owner" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0" }
+            }
+          when "public-read"
+            {
+              "AccessControlList" => [
+                {
+                  "Permission" => "FULL_CONTROL",
+                  "Scope" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0", "type" => "UserById" }
+                },
+                {
+                  "Permission" => "READ",
+                  "Scope" => { "type" => "AllUsers" }
+                }
+              ],
+              "Owner" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0" }
+            }
+          when "public-read-write"
+            {
+              "AccessControlList" => [
+                {
+                  "Permission" => "FULL_CONTROL",
+                  "Scope" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0", "type" => "UserById" }
+                },
+                {
+                  "Permission" => "READ",
+                  "Scope" => { "type" => "AllUsers" }
+                },
+                {
+                  "Permission" => "WRITE",
+                  "Scope" => { "type" => "AllUsers" }
+                }
+              ],
+              "Owner" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0" }
+            }
+          when "authenticated-read"
+            {
+              "AccessControlList" => [
+                {
+                  "Permission" => "FULL_CONTROL",
+                  "Scope" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0", "type" => "UserById" }
+                },
+                {
+                  "Permission" => "READ",
+                  "Scope" => { "type" => "AllAuthenticatedUsers" }
+                }
+              ],
+              "Owner" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0" }
+            }
+          end
+        end
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :acls => {
+                :bucket => {},
+                :object => {}
+              },
+              :buckets => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options = {})
+          @google_storage_access_key_id = options[:google_storage_access_key_id]
+        end
+
+        def data
+          self.class.data[@google_storage_access_key_id]
+        end
+
+        def reset_data
+          self.class.data.delete(@google_storage_access_key_id)
+        end
+
+        def signature(_params)
+          "foo"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Fog
+  module Storage
+    class GoogleXML
+      class Directories < Fog::Collection
+        model Fog::Storage::GoogleXML::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 = {}
+          data.each_pair do |k, v|
+            if %w(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/storage/google_xml/models/directory.rb

@@ -0,0 +1,65 @@
+module Fog
+  module Storage
+    class GoogleXML
+      class Directory < Fog::Model
+        identity :key, :aliases => %w(Name name)
+
+        attribute :creation_date, :aliases => "CreationDate"
+
+        def acl=(new_acl)
+          unless Utils::VALID_ACLS.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{Utils::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::GoogleXML::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"].detect { |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
+          end
+        end
+
+        def save
+          requires :key
+          options = {}
+          options["x-goog-acl"] = @acl if @acl
+          options["LocationConstraint"] = @location if @location
+          options["StorageClass"] = attributes[:storage_class] if attributes[:storage_class]
+          service.put_bucket(key, options)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Fog
+  module Storage
+    class GoogleXML
+      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 => %w(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)
+          unless Utils::VALID_ACLS.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{Utils::VALID_ACLS.join(', ')}]")
+          end
+          @acl = new_acl
+        end
+
+        def body
+          last_modified && (file = collection.get(identity)) ? attributes[:body] ||= file.body : attributes[:body] ||= ""
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        attr_reader :directory
+
+        def copy(target_directory_key, target_file_key, options = {})
+          requires :directory, :key
+          service.copy_object(directory.key, key, target_directory_key, target_file_key, options)
+          target_directory = service.directories.new(:key => target_directory_key)
+          target_directory.files.get(target_file_key)
+        end
+
+        def destroy
+          requires :directory, :key
+          service.delete_object(directory.key, key)
+          true
+        rescue Excon::Errors::NotFound
+          false
+        end
+
+        remove_method :metadata
+        def metadata
+          attributes.select { |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 = "project-private"
+          end
+          new_public
+        end
+
+        def public_url
+          requires :directory, :key
+
+          acl = service.get_object_acl(directory.key, key).body["AccessControlList"]
+          access_granted = acl.detect 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
+          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, options = {})
+          requires :key
+          collection.get_http_url(key, expires, options)
+        end
+
+        private
+
+        attr_writer :directory
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Fog
+  module Storage
+    class GoogleXML
+      class Files < Fog::Collection
+        extend Fog::Deprecation
+        deprecate :get_url, :get_https_url
+
+        attribute :common_prefixes, :aliases => "CommonPrefixes"
+        attribute :delimiter,       :aliases => "Delimiter"
+        attribute :directory
+        attribute :is_truncated,    :aliases => "IsTruncated"
+        attribute :marker,          :aliases => "Marker"
+        attribute :max_keys,        :aliases => ["MaxKeys", "max-keys"]
+        attribute :prefix,          :aliases => "Prefix"
+
+        model Fog::Storage::GoogleXML::File
+
+        def all(options = {})
+          requires :directory
+          options = {
+            "delimiter"   => delimiter,
+            "marker"      => marker,
+            "max-keys"    => max_keys,
+            "prefix"      => prefix
+          }.merge!(options)
+          options = options.reject { |_key, value| value.nil? || value.to_s.empty? }
+          merge_attributes(options)
+          parent = directory.collection.get(
+            directory.key,
+            options
+          )
+          if parent
+            merge_attributes(parent.files.attributes)
+            load(parent.files.map(&:attributes))
+          end
+        end
+
+        alias_method :each_file_this_page, :each
+        def each
+          if !block_given?
+            self
+          else
+            subset = dup.all
+
+            subset.each_file_this_page { |f| yield f }
+            while subset.is_truncated
+              subset = subset.all(:marker => subset.last.key)
+              subset.each_file_this_page { |f| yield f }
+            end
+
+            self
+          end
+        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 Excon::Errors::NotFound
+          nil
+        end
+
+        def get_http_url(key, expires, options = {})
+          requires :directory
+          service.get_object_http_url(directory.key, key, expires, options)
+        end
+
+        def get_https_url(key, expires, options = {})
+          requires :directory
+          service.get_object_https_url(directory.key, key, expires, options)
+        end
+
+        def head(key, options = {})
+          requires :directory
+          data = service.head_object(directory.key, key, options)
+          file_data = data.headers.merge(:key => key)
+          new(file_data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge(attributes))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Fog
+  module Storage
+    class GoogleXML
+      class Real
+        include Utils
+
+        # Initialize connection to Google Storage
+        #
+        # ==== Notes
+        # options parameter must include values for :google_storage_access_key_id and
+        # :google_storage_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   google_storage = Storage.new(
+        #     :google_storage_access_key_id => your_google_storage_access_key_id,
+        #     :google_storage_secret_access_key => your_google_storage_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #
+        # ==== Returns
+        # * Storage object with connection to google.
+        def initialize(options = {})
+          @google_storage_access_key_id = options[:google_storage_access_key_id]
+          @google_storage_secret_access_key = options[:google_storage_secret_access_key]
+          @connection_options = options[:connection_options] || {}
+          @hmac = Fog::HMAC.new("sha1", @google_storage_secret_access_key)
+          @host = options[:host] || "storage.googleapis.com"
+          @persistent = options.fetch(:persistent, true)
+          @port       = options[:port] || 443
+          @scheme     = options[:scheme] || "https"
+          @path_style = options[:path_style] || false
+        end
+
+        def reload
+          @connection.reset if @connection
+        end
+
+        def signature(params)
+          string_to_sign = <<-DATA
+#{params[:method]}
+#{params[:headers]['Content-MD5']}
+#{params[:headers]['Content-Type']}
+#{params[:headers]['Date']}
+DATA
+
+          google_headers = {}
+          canonical_google_headers = ""
+          params[:headers].each do |key, value|
+            google_headers[key] = value if key[0..6] == "x-goog-"
+          end
+
+          google_headers = google_headers.sort_by { |a| a[0] }
+          google_headers.each do |key, value|
+            canonical_google_headers << "#{key}:#{value}\n"
+          end
+          string_to_sign << canonical_google_headers.to_s
+
+          canonical_resource = "/"
+          if subdomain = params.delete(:subdomain)
+            canonical_resource << "#{CGI.escape(subdomain).downcase}/"
+          end
+          canonical_resource << params[:path].to_s
+          canonical_resource << "?"
+          (params[:query] || {}).keys.each do |key|
+            if %w(acl cors location logging requestPayment versions versioning).include?(key)
+              canonical_resource << "#{key}&"
+            end
+          end
+          canonical_resource.chop!
+          string_to_sign << canonical_resource.to_s
+
+          signed_string = @hmac.sign(string_to_sign)
+          Base64.encode64(signed_string).chomp!
+        end
+
+        def connection(scheme, host, port)
+          uri = "#{scheme}://#{host}:#{port}"
+          if @persistent
+            unless uri == @connection_uri
+              @connection_uri = uri
+              reload
+              @connection = nil
+            end
+          else
+            @connection = nil
+          end
+          @connection ||= Fog::XML::Connection.new(uri, @persistent, @connection_options)
+        end
+
+        private
+
+        def request(params, &block)
+          params = request_params(params)
+          scheme = params.delete(:scheme)
+          host   = params.delete(:host)
+          port   = params.delete(:port)
+
+          params[:headers]["Date"] = Fog::Time.now.to_date_header
+          params[:headers]["Authorization"] = "GOOG1 #{@google_storage_access_key_id}:#{signature(params)}"
+
+          connection(scheme, host, port).request(params, &block)
+        end
+      end
+    end
+  end
+end