gcloud 0.4.0 → 0.4.1

data/lib/gcloud/storage/bucket/acl.rb

@@ -318,7 +318,7 @@ module Gcloud
         end
 
         ##
-        # Permenently deletes the entity from the bucket's access control list.
+        # Permanently deletes the entity from the bucket's access control list.
         #
         # === Parameters
         #
@@ -468,11 +468,20 @@ module Gcloud
 
         protected
 
+        def clear!
+          @owners  = nil
+          @writers = nil
+          @readers = nil
+          self
+        end
+
         def update_predefined_acl! acl_role
           resp = @connection.patch_bucket @bucket,
-                                          acl: acl_role
+                                          predefined_acl: acl_role,
+                                          acl: []
 
-          resp.success?
+          return clear! if resp.success?
+          fail Gcloud::Storage::ApiError.from_response(resp)
         end
 
         def entities_from_acls acls, role
@@ -785,7 +794,7 @@ module Gcloud
         end
 
         ##
-        # Permenently deletes the entity from the bucket's default access
+        # Permanently deletes the entity from the bucket's default access
         # control list for files.
         #
         # === Parameters
@@ -957,11 +966,20 @@ module Gcloud
 
         protected
 
+        def clear!
+          @owners  = nil
+          @writers = nil
+          @readers = nil
+          self
+        end
+
         def update_predefined_default_acl! acl_role
           resp = @connection.patch_bucket @bucket,
-                                          default_acl: acl_role
+                                          predefined_default_acl: acl_role,
+                                          default_acl: []
 
-          resp.success?
+          return clear! if resp.success?
+          fail Gcloud::Storage::ApiError.from_response(resp)
         end
 
         def entities_from_acls acls, role

data/lib/gcloud/storage/bucket/cors.rb

@@ -0,0 +1,112 @@
+#--
+# Copyright 2015 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Gcloud
+  module Storage
+    class Bucket
+      ##
+      # = Bucket Cors
+      #
+      # A special-case Array for managing the website CORS rules for a bucket.
+      # Accessed via a block argument to Project#create_bucket, Bucket#cors, or
+      # Bucket#update.
+      #
+      # For more information about CORS, see {Cross-Origin Resource
+      # Sharing (CORS)}[https://cloud.google.com/storage/docs/cross-origin].
+      #
+      #   require "gcloud"
+      #
+      #   gcloud = Gcloud.new
+      #   storage = gcloud.storage
+      #   bucket = storage.bucket "my-todo-app"
+      #
+      #   bucket.cors do |c|
+      #     # Remove the last CORS rule from the array
+      #     c.pop
+      #     # Remove all existing rules with the https protocol
+      #     c.delete_if { |r| r["origin"].include? "http://example.com" }
+      #     c.add_rule ["http://example.org", "https://example.org"],
+      #                ["GET", "POST", "DELETE"],
+      #                response_headers: ["X-My-Custom-Header"],
+      #                max_age: 3600
+      #   end
+      #
+      class Cors < DelegateClass(::Array)
+        ##
+        # Initialize a new CORS rules builder with existing CORS rules, if any.
+        def initialize cors = [] #:nodoc:
+          super cors.dup
+          @original = cors.dup
+        end
+
+        def changed? #:nodoc:
+          @original != self
+        end
+
+        ##
+        # Add a CORS rule to the CORS rules for a bucket. Accepts options for
+        # setting preflight response headers. Preflight requests and responses
+        # are required if the request method and headers are not both {simple
+        # methods}[http://www.w3.org/TR/cors/#simple-method] and {simple
+        # headers}[http://www.w3.org/TR/cors/#simple-header].
+        #
+        # === Parameters
+        #
+        # +origin+::
+        #   The {origin}[http://tools.ietf.org/html/rfc6454] or origins
+        #   permitted for cross origin resource sharing with the bucket. Note:
+        #   "*" is permitted in the list of origins, and means "any Origin".
+        #   (+String+ or +Array+)
+        # +methods+::
+        #   The list of HTTP methods permitted in cross origin resource sharing
+        #   with the bucket. (GET, OPTIONS, POST, etc) Note: "*" is permitted in
+        #   the list of methods, and means "any method". (+String+ or +Array+)
+        # +options+::
+        #   An optional Hash for controlling additional behavior. (+Hash+)
+        # <code>options[:headers]</code>::
+        #   The list of header field names to send in the
+        #   Access-Control-Allow-Headers header in the preflight response.
+        #   Indicates the custom request headers that may be used in the actual
+        #   request. (+String+ or +Array+)
+        # <code>options[:max_age]</code>::
+        #   The value to send in the Access-Control-Max-Age header in the
+        #   preflight response. Indicates how many seconds the results of a
+        #   preflight request can be cached in a preflight result cache. The
+        #   default value is +1800+ (30 minutes.) (+Integer+)
+        #
+        # === Example
+        #
+        #   require "gcloud"
+        #
+        #   gcloud = Gcloud.new
+        #   storage = gcloud.storage
+        #
+        #   bucket = storage.create_bucket "my-bucket" do |c|
+        #     c.add_rule ["http://example.org", "https://example.org"],
+        #                "*",
+        #                response_headers: ["X-My-Custom-Header"],
+        #                max_age: 300
+        #   end
+        #
+        def add_rule origin, methods, options = {}
+          rule = { "origin" => Array(origin), "method" => Array(methods) }
+          rule["responseHeader"] = Array(options[:headers]) || []
+          rule["maxAgeSeconds"] = options[:max_age] || 1800
+          push rule
+        end
+      end
+    end
+  end
+end

data/lib/gcloud/storage/connection.rb

@@ -75,27 +75,28 @@ module Gcloud
           @client.execute(
             api_method: @storage.buckets.insert,
             parameters: params,
-            body_object: { name: bucket_name }
+            body_object: insert_bucket_request(bucket_name, options)
           )
         end
       end
 
       ##
-      # Updates a bucket's metadata.
+      # Updates a bucket, including its ACL metadata.
       def patch_bucket bucket_name, options = {}
         params = { bucket: bucket_name,
-                   predefinedAcl: options[:acl],
-                   predefinedDefaultObjectAcl: options.delete(:default_acl)
+                   predefinedAcl: options[:predefined_acl],
+                   predefinedDefaultObjectAcl: options[:predefined_default_acl]
                  }.delete_if { |_, v| v.nil? }
 
         @client.execute(
           api_method: @storage.buckets.patch,
-          parameters: params
+          parameters: params,
+          body_object: patch_bucket_request(options)
         )
       end
 
       ##
-      # Permenently deletes an empty bucket.
+      # Permanently deletes an empty bucket.
       def delete_bucket bucket_name, opts = {}
         incremental_backoff opts do
           @client.execute(
@@ -125,7 +126,7 @@ module Gcloud
       end
 
       ##
-      # Permenently deletes a bucket ACL.
+      # Permanently deletes a bucket ACL.
       def delete_bucket_acl bucket_name, entity
         @client.execute(
           api_method: @storage.bucket_access_controls.delete,
@@ -153,7 +154,7 @@ module Gcloud
       end
 
       ##
-      # Permenently deletes a default ACL.
+      # Permanently deletes a default ACL.
       def delete_default_acl bucket_name, entity
         @client.execute(
           api_method: @storage.default_object_access_controls.delete,
@@ -177,73 +178,25 @@ module Gcloud
         )
       end
 
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/AbcSize
-      # Disabled rubocop because the API we need to use
-      # is verbose. No getting around it.
-
-      ##
-      # Stores a new object and metadata.
-      # Uses a multipart form post.
-      def insert_file_multipart bucket_name, file, path = nil,
-                                options = {}
-        local_path = Pathname(file).to_path
-        upload_path = Pathname(path || local_path).to_path
-        mime_type = mime_type_for local_path
-
-        media = Google::APIClient::UploadIO.new local_path, mime_type
-
-        params = { uploadType: "multipart",
-                   bucket: bucket_name,
-                   name: upload_path,
-                   predefinedAcl: options[:acl]
-                 }.delete_if { |_, v| v.nil? }
-
-        @client.execute(
-          api_method: @storage.objects.insert,
-          media: media,
-          parameters: params,
-          body_object: { contentType: mime_type }
-        )
-      end
-
       ##
-      # Stores a new object and metadata.
-      # Uses a resumable upload.
-      def insert_file_resumable bucket_name, file, path = nil,
-                                chunk_size = nil, options = {}
+      # Stores a new object and metadata. If resumable is true, a resumable
+      # upload, otherwise uses a multipart form post.
+      #
+      # UploadIO comes from Faraday, which gets it from multipart-post
+      # The initializer signature is:
+      # filename_or_io, content_type, filename = nil, opts = {}
+      def upload_file resumable, bucket_name, file, path = nil, options = {}
         local_path = Pathname(file).to_path
+        options[:content_type] ||= mime_type_for(local_path)
+        media = file_media local_path, options, resumable
         upload_path = Pathname(path || local_path).to_path
-        # mime_type = options[:mime_type] || mime_type_for local_path
-        mime_type = mime_type_for local_path
-
-        # This comes from Faraday, which gets it from multipart-post
-        # The signature is:
-        # filename_or_io, content_type, filename = nil, opts = {}
-
-        media = Google::APIClient::UploadIO.new local_path, mime_type
-        media.chunk_size = chunk_size
-
-        params = { uploadType: "resumable",
-                   bucket: bucket_name,
-                   name: upload_path,
-                   predefinedAcl: options[:acl]
-                 }.delete_if { |_, v| v.nil? }
-
-        result = @client.execute(
-          api_method: @storage.objects.insert,
-          media: media,
-          parameters: params,
-          body_object: { contentType: mime_type }
-        )
+        result = insert_file resumable, bucket_name, upload_path, media, options
+        return result unless resumable
         upload = result.resumable_upload
         result = @client.execute upload while upload.resumable?
         result
       end
 
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/AbcSize
-
       ##
       # Retrieves an object or its metadata.
       def get_file bucket_name, file_path, options = {}
@@ -259,12 +212,12 @@ module Gcloud
       ## Copy a file from source bucket/object to a
       # destination bucket/object.
       def copy_file source_bucket_name, source_file_path,
-                    destination_bucket_name, destination_file_path,
-                    options = {}
+                    destination_bucket_name, destination_file_path, options = {}
         @client.execute(
           api_method: @storage.objects.copy,
           parameters: { sourceBucket: source_bucket_name,
                         sourceObject: source_file_path,
+                        sourceGeneration: options[:generation],
                         destinationBucket: destination_bucket_name,
                         destinationObject: destination_file_path,
                         predefinedAcl: options[:acl]
@@ -287,17 +240,18 @@ module Gcloud
       def patch_file bucket_name, file_path, options = {}
         params = { bucket: bucket_name,
                    object: file_path,
-                   predefinedAcl: options.delete(:acl)
+                   predefinedAcl: options[:predefined_acl]
                  }.delete_if { |_, v| v.nil? }
 
         @client.execute(
           api_method: @storage.objects.patch,
-          parameters: params
+          parameters: params,
+          body_object: patch_file_request(options)
         )
       end
 
       ##
-      # Permenently deletes a file.
+      # Permanently deletes a file.
       def delete_file bucket_name, file_path
         @client.execute(
           api_method: @storage.objects.delete,
@@ -329,7 +283,7 @@ module Gcloud
       end
 
       ##
-      # Permenently deletes a file ACL.
+      # Permanently deletes a file ACL.
       def delete_file_acl bucket_name, file_name, entity, options = {}
         query = { bucket: bucket_name, object: file_name, entity: entity }
         query[:generation] = options[:generation] if options[:generation]
@@ -353,11 +307,118 @@ module Gcloud
 
       protected
 
+      def insert_bucket_request name, options = {}
+        {
+          "name" => name,
+          "location" => options[:location],
+          "cors" => options[:cors],
+          "logging" => logging_config(options),
+          "storageClass" => storage_class(options[:storage_class]),
+          "versioning" => versioning_config(options[:versioning]),
+          "website" => website_config(options)
+        }.delete_if { |_, v| v.nil? }
+      end
+
+      def patch_bucket_request options = {}
+        {
+          "cors" => options[:cors],
+          "logging" => logging_config(options),
+          "versioning" => versioning_config(options[:versioning]),
+          "website" => website_config(options),
+          "acl" => options[:acl],
+          "defaultObjectAcl" => options[:default_acl]
+        }.delete_if { |_, v| v.nil? }
+      end
+
+      def versioning_config enabled
+        { "enabled" => enabled } unless enabled.nil?
+      end
+
+      def logging_config options
+        bucket = options[:logging_bucket]
+        prefix = options[:logging_prefix]
+        {
+          "logBucket" => bucket,
+          "logObjectPrefix" => prefix
+        }.delete_if { |_, v| v.nil? } if bucket || prefix
+      end
+
+      def website_config options
+        website_main = options[:website_main]
+        website_404 = options[:website_404]
+        {
+          "mainPageSuffix" => website_main,
+          "notFoundPage" => website_404
+        }.delete_if { |_, v| v.nil? } if website_main || website_404
+      end
+
+      def storage_class str #:nodoc:
+        { "durable_reduced_availability" => "DURABLE_REDUCED_AVAILABILITY",
+          "dra" => "DURABLE_REDUCED_AVAILABILITY",
+          "durable" => "DURABLE_REDUCED_AVAILABILITY",
+          "nearline" => "NEARLINE",
+          "standard" => "STANDARD" }[str.to_s.downcase]
+      end
+
+      def insert_file resumable, bucket_name, path, media, options
+        params = { uploadType: (resumable ? "resumable" : "multipart"),
+                   bucket: bucket_name,
+                   name: path,
+                   predefinedAcl: options[:acl]
+        }.delete_if { |_, v| v.nil? }
+
+        @client.execute api_method: @storage.objects.insert,
+                        media: media,
+                        parameters: params,
+                        body_object: insert_file_request(options)
+      end
+
+      def file_media local_path, options, resumable
+        media = Google::APIClient::UploadIO.new local_path,
+                                                options[:content_type]
+        return media unless resumable && options[:chunk_size]
+        media.chunk_size = verify_chunk_size!(options.delete(:chunk_size))
+        media
+      end
+
+      def insert_file_request options = {}
+        request = {
+          "crc32c" => options[:crc32c],
+          "md5Hash" => options[:md5],
+          "metadata" => options[:metadata]
+        }.delete_if { |_, v| v.nil? }
+        request.merge patch_file_request(options)
+      end
+
+      def patch_file_request options = {}
+        {
+          "cacheControl" => options[:cache_control],
+          "contentDisposition" => options[:content_disposition],
+          "contentEncoding" => options[:content_encoding],
+          "contentLanguage" => options[:content_language],
+          "contentType" => options[:content_type],
+          "metadata" => options[:metadata],
+          "acl" => options[:acl]
+        }.delete_if { |_, v| v.nil? }
+      end
+
       def incremental_backoff options = {}
         Gcloud::Backoff.new(options).execute do
           yield
         end
       end
+
+      ##
+      # Determines if a chunk_size is valid.
+      def verify_chunk_size! chunk_size
+        chunk_size = chunk_size.to_i
+        chunk_mod = 256 * 1024 # 256KB
+        if (chunk_size.to_i % chunk_mod) != 0
+          chunk_size = (chunk_size / chunk_mod) * chunk_mod
+        end
+        return if chunk_size.zero?
+        chunk_size
+      end
     end
   end
 end