fog-google 0.1.3 → 0.2.0

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

@@ -0,0 +1,65 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Directory < Fog::Model
+        identity :key, :aliases => %w(Name name)
+
+        def acl=(new_acl)
+          valid_acls = %w(private projectPrivate publicRead publicReadWrite authenticatedRead)
+          unless valid_acls.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{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::GoogleJSON::Files.new(
+              :directory => self,
+              :service => service
+            )
+          end
+        end
+
+        def public=(new_public)
+          if new_public
+            @acl = "publicRead"
+          else
+            @acl = "private"
+          end
+          new_public
+        end
+
+        def public_url
+          requires :key
+          acl = service.get_bucket_acl(key).body
+          if acl["items"].detect { |entry| entry["entity"] == "allUsers" && entry["role"] == "READER" }
+            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["predefinedAcl"] = @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_json/models/file.rb

@@ -0,0 +1,148 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class File < Fog::Model
+        identity :key, :aliases => "Key"
+
+        attribute :acl
+        attribute :predefined_acl
+        attribute :cache_control,       :aliases => "cacheControl"
+        attribute :content_disposition, :aliases => "contentDisposition"
+        attribute :content_encoding,    :aliases => "contentEncoding"
+        attribute :content_length,      :aliases => "size", :type => :integer
+        attribute :content_md5,         :aliases => "md5Hash"
+        attribute :content_type,        :aliases => "contentType"
+        attribute :crc32c
+        attribute :etag,                :aliases => "etag"
+        attribute :time_created,        :aliases => "timeCreated"
+        attribute :last_modified,       :aliases => "updated"
+        attribute :generation
+        attribute :metageneration
+        attribute :metadata
+        attribute :self_link,           :aliases => "selfLink"
+        attribute :media_link,          :aliases => "mediaLink"
+        attribute :owner
+        attribute :storage_class, :aliases => "storageClass"
+
+        @valid_predefined_acls = %w(private projectPrivate bucketOwnerFullControl bucketOwnerRead authenticatedRead publicRead)
+
+        def predefined_acl=(new_acl)
+          unless @valid_predefined_acls.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{@valid_predefined_acls.join(', ')}]")
+          end
+          @predefined_acl = new_acl
+        end
+
+        # TODO: Implement object ACLs
+        # def acl=(new_acl)
+        #   valid_acls = ["private", "projectPrivate", "bucketOwnerFullControl", "bucketOwnerRead", "authenticatedRead", "publicRead"]
+        #   unless valid_acls.include?(new_acl)
+        #     raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
+        #   end
+        #   @acl = new_acl
+        # end
+
+        def body
+          attributes[:body] ||= last_modified && (file = collection.get(identity)) ? file.body : ""
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        attr_reader :directory
+
+        def copy(target_directory_key, target_file_key)
+          requires :directory, :key
+          service.copy_object(directory.key, key, target_directory_key, target_file_key)
+          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=(new_metadata)
+          if attributes[:metadata].nil?
+            attributes[:metadata] = {}
+          end
+          attributes[:metadata].merge!(new_metadata)
+        end
+
+        # TODO: Not functional
+        remove_method :owner=
+        def owner=(new_owner)
+          if new_owner
+            attributes[:owner] = {
+              :entity => new_owner["entity"],
+              :entityId  => new_owner["entityId"]
+            }
+          end
+        end
+
+        def public=(new_public)
+          if new_public
+            @predefined_acl = "publicRead"
+          else
+            @predefined_acl = "private"
+          end
+          new_public
+        end
+
+        def public_url
+          requires :directory, :key
+
+          acl = service.get_object_acl(directory.key, key).body
+          access_granted = acl["items"].detect { |entry| entry["entity"] == "allUsers" && entry["role"] == "READER" }
+
+          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["contentType"] = content_type if content_type
+          options["predefinedAcl"] ||= @predefined_acl if @predefined_acl # predefinedAcl may need to be in parameters
+          options["acl"] ||= @acl if @acl # Not sure if you can provide both acl and predefinedAcl
+          options["cacheControl"] = cache_control if cache_control
+          options["contentDisposition"] = content_disposition if content_disposition
+          options["contentEncoding"] = content_encoding if content_encoding
+          # TODO: Should these hashes be recomputed on changes to file contents?
+          # options["md5Hash"] = content_md5 if content_md5
+          # options["crc32c"] = crc32c if crc32c
+          options["metadata"] = metadata
+
+          data = service.put_object(directory.key, key, body, options)
+          merge_attributes(data.headers.reject { |key, _value| %w(contentLength contentType).include?(key) })
+          self.content_length = Fog::Storage.get_body_size(body)
+          self.content_type ||= Fog::Storage.get_content_type(body)
+          true
+        end
+
+        # params[:expires] : Eg: Time.now to integer value.
+        def url(expires)
+          requires :key
+          collection.get_https_url(key, expires)
+        end
+
+        private
+
+        attr_writer :directory
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      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 :page_token,      :aliases => %w(pageToken page_token)
+        attribute :max_results,     :aliases => ["MaxKeys", "max-keys"]
+        attribute :prefix,          :aliases => "Prefix"
+
+        model Fog::Storage::GoogleJSON::File
+
+        def all(options = {})
+          requires :directory
+          options = {
+            "delimiter"   => delimiter,
+            "pageToken"   => page_token,
+            "maxResults"  => max_results,
+            "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.merge!(:body => data.body,
+                           :key  => key)
+          new(file_data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def get_https_url(key, expires)
+          requires :directory
+          service.get_object_https_url(directory.key, key, expires)
+        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_json/requests/copy_object.rb

@@ -0,0 +1,66 @@
+module Fog
+  module Storage
+    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
+        #
+        # ==== 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)
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fog
+  module Storage
+    class GoogleJSON
+      class Real
+        # 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
+        def delete_bucket(bucket_name)
+          api_method = @storage_json.buckets.delete
+          parameters = {
+            "bucket" => bucket_name
+          }
+
+          request(api_method, parameters)
+        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
+        end
+      end
+    end
+  end
+end

data/lib/fog/{google/requests/storage → storage/google_json/requests}/delete_object.rb

@@ -1,8 +1,9 @@
 module Fog
   module Storage
-    class Google
+    class GoogleJSON
       class Real
         # 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
@@ -12,31 +13,30 @@ module Fog
         # * response<~Excon::Response>:
         #   * status<~Integer> - 204
         def delete_object(bucket_name, object_name)
-          request({
-            :expects    => 204,
-            :headers    => {},
-            :host       => "#{bucket_name}.#{@host}",
-            :idempotent => true,
-            :method     => 'DELETE',
-            :path       => CGI.escape(object_name)
-          })
+          api_method = @storage_json.objects.delete
+          parameters = {
+            "bucket" => bucket_name,
+            "object" => object_name
+          }
+
+          request(api_method, parameters)
         end
       end
 
       class Mock
         def delete_object(bucket_name, object_name)
           response = Excon::Response.new
-          if bucket = self.data[:buckets][bucket_name]
+          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))
+              raise(Excon::Errors.status_error({ :expects => 204 }, response))
             end
           else
             response.status = 404
-            raise(Excon::Errors.status_error({:expects => 204}, response))
+            raise(Excon::Errors.status_error({ :expects => 204 }, response))
           end
           response
         end