fog-google 0.1.3 → 0.2.0

data/lib/fog/{google/parsers/storage → parsers/storage/google}/copy_object.rb

@@ -5,9 +5,9 @@ module Fog
         class CopyObject < Fog::Parsers::Base
           def end_element(name)
             case name
-            when 'ETag'
-              @response[name] = value.gsub('"', '')
-            when 'LastModified'
+            when "ETag"
+              @response[name] = value.delete('"')
+            when "LastModified"
               @response[name] = Time.parse(value)
             end
           end

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

@@ -0,0 +1,58 @@
+module Fog
+  module Parsers
+    module Storage
+      module Google
+        class GetBucket < Fog::Parsers::Base
+          def reset
+            @object = { "Owner" => {} }
+            @response = { "Contents" => [], "CommonPrefixes" => [] }
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+            when "CommonPrefixes"
+              @in_common_prefixes = true
+            end
+          end
+
+          def end_element(name)
+            case name
+            when "CommonPrefixes"
+              @in_common_prefixes = false
+            when "Contents"
+              @response["Contents"] << @object
+              @object = { "Owner" => {} }
+            when "DisplayName", "ID"
+              @object["Owner"][name] = value
+            when "ETag"
+              @object[name] = value.delete('"')
+            when "IsTruncated"
+              if value == "true"
+                @response["IsTruncated"] = true
+              else
+                @response["IsTruncated"] = false
+              end
+            when "LastModified"
+              @object["LastModified"] = Time.parse(value)
+            when "Marker", "Name"
+              @response[name] = value
+            when "MaxKeys"
+              @response["MaxKeys"] = value.to_i
+            when "Prefix"
+              if @in_common_prefixes
+                @response["CommonPrefixes"] << value
+              else
+                @response[name] = value
+              end
+            when "Size"
+              @object["Size"] = value.to_i
+            when "Delimiter", "Key", "StorageClass"
+              @object[name] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Fog
+  module Parsers
+    module Storage
+      module Google
+        class AccessControlList < Fog::Parsers::Base
+          def reset
+            @grant = { "Grantee" => {} }
+            @response = { "BucketLoggingStatus" => {} }
+          end
+
+          def end_element(name)
+            case name
+            when "DisplayName", "ID"
+              if @in_access_control_list
+                @grant["Grantee"][name] = value
+              else
+                @response["Owner"][name] = value
+              end
+            when "Grant"
+              @response["BucketLoggingStatus"]["LoggingEnabled"]["TargetGrants"] << @grant
+              @grant = { "Grantee" => {} }
+            when "LoggingEnabled"
+              @response["BucketLoggingStatus"]["LoggingEnabled"] = { "TargetGrants" => [] }
+            when "Permission"
+              @grant[name] = value
+            when "TargetBucket", "TargetPrefix"
+              @response["BucketLoggingStatus"][name] = value
+            when "URI"
+              @grant["Grantee"][name] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Fog
+  module Parsers
+    module Storage
+      module Google
+        class GetBucketObjectVersions < Fog::Parsers::Base
+          def reset
+            @delete_marker = { "Owner" => {} }
+            @version = { "Owner" => {} }
+
+            @in_delete_marke = false
+            @in_version = false
+
+            @response = { "Versions" => [] }
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+            when "DeleteMarker"
+              @in_delete_marker = true
+            when "Version"
+              @in_version = true
+            end
+          end
+
+          def end_element(name)
+            case name
+            when "DeleteMarker"
+              @response["Versions"] << { "DeleteMarker" => @delete_marker }
+              @delete_marker = { "Owner" => {} }
+              @in_delete_marker = false
+            when "Version"
+              @response["Versions"] << { "Version" => @version }
+              @version = { "Owner" => {} }
+              @in_version = false
+            when "DisplayName", "ID"
+              if @in_delete_marker
+                @delete_marker
+              elsif @in_version
+                @version
+              end["Owner"][name] = value
+            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
+              end
+            when "IsTruncated"
+              if value == "true"
+                @response["IsTruncated"] = true
+              else
+                @response["IsTruncated"] = false
+              end
+            when "LastModified"
+              if @in_delete_marker
+                @delete_marker
+              elsif @in_version
+                @version
+              end["LastModified"] = Time.parse(value)
+            when "KeyMarker", "Name", "Prefix", "VersionIdMarker"
+              @response[name] = value
+            when "MaxKeys"
+              @response["MaxKeys"] = value.to_i
+            when "Size"
+              @version["Size"] = value.to_i
+            when "Key", "Name", "StorageClass", "VersionId"
+              if @in_delete_marker
+                @delete_marker
+              elsif @in_version
+                @version
+              end[name] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/{google/parsers/storage → parsers/storage/google}/get_bucket_versioning.rb

@@ -4,13 +4,13 @@ module Fog
       module Google
         class GetBucketVersioning < Fog::Parsers::Base
           def reset
-            @response = { 'VersioningConfiguration' => {} }
+            @response = { "VersioningConfiguration" => {} }
           end
 
           def end_element(name)
             case name
-            when 'Status'
-              @response['VersioningConfiguration'][name] = value
+            when "Status"
+              @response["VersioningConfiguration"][name] = value
             end
           end
         end

data/lib/fog/{google/parsers/storage → parsers/storage/google}/get_request_payment.rb

@@ -5,7 +5,7 @@ module Fog
         class GetRequestPayment < Fog::Parsers::Base
           def end_element(name)
             case name
-            when 'Payer'
+            when "Payer"
               @response[name] = value
             end
           end

data/lib/fog/{google/parsers/storage → parsers/storage/google}/get_service.rb

@@ -5,19 +5,19 @@ module Fog
         class GetService < Fog::Parsers::Base
           def reset
             @bucket = {}
-            @response = { 'Owner' => {}, 'Buckets' => [] }
+            @response = { "Owner" => {}, "Buckets" => [] }
           end
 
           def end_element(name)
             case name
-            when 'Bucket'
-              @response['Buckets'] << @bucket
+            when "Bucket"
+              @response["Buckets"] << @bucket
               @bucket = {}
-            when 'CreationDate'
-              @bucket['CreationDate'] = Time.parse(value)
-            when 'DisplayName', 'ID'
-              @response['Owner'][name] = value
-            when 'Name'
+            when "CreationDate"
+              @bucket["CreationDate"] = Time.parse(value)
+            when "DisplayName", "ID"
+              @response["Owner"][name] = value
+            when "Name"
               @bucket[name] = value
             end
           end

data/lib/fog/storage/google.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Storage
+    class Google < Fog::Service
+      def self.new(options = {})
+        begin
+          fog_creds = Fog.credentials
+        rescue
+          fog_creds = nil
+        end
+
+        if options.keys.include? :google_storage_access_key_id or
+          (not fog_creds.nil? and fog_creds.keys.include? :google_storage_access_key_id)
+          Fog::Storage::GoogleXML.new(options)
+        else
+          Fog::Storage::GoogleJSON.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/google_json.rb

@@ -0,0 +1,146 @@
+module Fog
+  module Storage
+    class GoogleJSON < Fog::Service
+      requires :google_project
+      recognizes :google_client_email, :google_key_location, :google_key_string, :google_client,
+                 :app_name, :app_version, :google_json_key_location, :google_json_key_string
+
+      # 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/"
+
+      # 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)
+
+      ##
+      # Models
+      model_path "fog/storage/google_json/models"
+      collection :directories
+      model :directory
+      collection :files
+      model :file
+
+      ##
+      # Requests
+      request_path "fog/storage/google_json/requests"
+      request :copy_object
+      request :delete_bucket
+      request :delete_object
+      request :get_bucket
+      request :get_bucket_acl
+      request :get_object
+      request :get_object_acl
+      # request :get_object_torrent
+      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
+
+      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] = CGI.escape(params[:path]).gsub("%2F", "/")
+          query = [params[:query]].compact
+          query << "GoogleAccessId=#{@client.authorization.issuer}"
+          query << "Signature=#{CGI.escape(signature(params))}"
+          query << "Expires=#{params[:headers]['Date']}"
+          "#{params[:host]}/#{params[:path]}?#{query.join('&')}"
+        end
+      end
+
+      class Mock
+        include Utils
+        include Fog::Google::Shared
+
+        def initialize(options = {})
+          shared_initialize(options[:google_project], GOOGLE_STORAGE_JSON_API_VERSION, GOOGLE_STORAGE_JSON_BASE_URL)
+        end
+
+        def signature(_params)
+          "foo"
+        end
+      end
+
+      class Real
+        include Utils
+        include Fog::Google::Shared
+
+        attr_accessor :client
+        attr_reader :storage_json
+
+        def initialize(options = {})
+          shared_initialize(options[:google_project], GOOGLE_STORAGE_JSON_API_VERSION, GOOGLE_STORAGE_JSON_BASE_URL)
+          options.merge!(:google_api_scope_url => GOOGLE_STORAGE_JSON_API_SCOPE_URLS.join(" "))
+          @host = options[:host] || "storage.googleapis.com"
+
+          @client = initialize_google_client(options)
+          @storage_json = @client.discovered_api("storage", api_version)
+        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 = ""
+          for key, value in params[:headers]
+            google_headers[key] = value if key[0..6] == "x-goog-"
+          end
+
+          google_headers = google_headers.sort { |x, y| x[0] <=> y[0] }
+          for key, value in google_headers
+            canonical_google_headers << "#{key}:#{value}\n"
+          end
+          string_to_sign << "#{canonical_google_headers}"
+
+          canonical_resource = "/"
+          if subdomain = params.delete(:subdomain)
+            canonical_resource << "#{CGI.escape(subdomain).downcase}/"
+          end
+          canonical_resource << "#{params[:path]}"
+          canonical_resource << "?"
+          for key in (params[:query] || {}).keys
+            if %w(acl cors location logging requestPayment torrent versions versioning).include?(key)
+              canonical_resource << "#{key}&"
+            end
+          end
+          canonical_resource.chop!
+          string_to_sign << "#{canonical_resource}"
+
+          key = OpenSSL::PKey::RSA.new(@client.authorization.signing_key)
+          digest = OpenSSL::Digest::SHA256.new
+          signed_string = key.sign(digest, string_to_sign)
+
+          Base64.encode64(signed_string).chomp!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Directories < Fog::Collection
+        model Fog::Storage::GoogleJSON::Directory
+
+        # TODO get_service does not return items like this
+        # def all
+        #   data = service.get_service.body["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 Excon::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end