gcloud 0.11.0 → 0.12.0

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

@@ -56,9 +56,8 @@ module Gcloud
         def initialize file
           @bucket = file.bucket
           @file = file.name
-          @connection = file.connection
+          @service = file.service
           @owners  = nil
-          @writers = nil
           @readers = nil
         end
 
@@ -77,10 +76,13 @@ module Gcloud
         #   file.acl.reload!
         #
         def reload!
-          resp = @connection.list_file_acls @bucket, @file
-          acls = resp.data["items"]
+          gapi = @service.list_file_acls @bucket, @file
+          acls = Array(gapi.items).map do |acl|
+            return acl if acl.is_a? Google::Apis::StorageV1::ObjectAccessControl
+            fail "Unknown ACL format: #{acl.class}" unless acl.is_a? Hash
+            Google::Apis::StorageV1::ObjectAccessControl.from_json acl.to_json
+          end
           @owners  = entities_from_acls acls, "OWNER"
-          @writers = entities_from_acls acls, "WRITER"
           @readers = entities_from_acls acls, "READER"
         end
         alias_method :refresh!, :reload!
@@ -106,27 +108,6 @@ module Gcloud
           @owners
         end
 
-        ##
-        # Lists the owners of the file.
-        #
-        # @return [Array<String>]
-        #
-        # @example
-        #   require "gcloud"
-        #
-        #   gcloud = Gcloud.new
-        #   storage = gcloud.storage
-        #
-        #   bucket = storage.bucket "my-bucket"
-        #
-        #   file = bucket.file "path/to/my-file.ext"
-        #   file.acl.writers.each { |writer| puts writer }
-        #
-        def writers
-          reload! if @writers.nil?
-          @writers
-        end
-
         ##
         # Lists the readers of the file.
         #
@@ -192,68 +173,11 @@ module Gcloud
         #
         def add_owner entity, generation: nil
           options = { generation: generation }
-          resp = @connection.insert_file_acl @bucket, @file, entity,
-                                             "OWNER", options
-          if resp.success?
-            entity = resp.data["entity"]
-            @owners.push entity unless @owners.nil?
-            return entity
-          end
-          nil
-        end
-
-        ##
-        # Grants writer permission to the file.
-        #
-        # @param [String] entity The entity holding the permission, in one of
-        #   the following forms:
-        #
-        #   * user-userId
-        #   * user-email
-        #   * group-groupId
-        #   * group-email
-        #   * domain-domain
-        #   * project-team-projectId
-        #   * allUsers
-        #   * allAuthenticatedUsers
-        #
-        # @param [Integer] generation When present, selects a specific revision
-        #   of this object. Default is the latest version.
-        #
-        # @example Grant access to a user by pre-pending `"user-"` to an email:
-        #   require "gcloud"
-        #
-        #   gcloud = Gcloud.new
-        #   storage = gcloud.storage
-        #
-        #   bucket = storage.bucket "my-bucket"
-        #
-        #   file = bucket.file "path/to/my-file.ext"
-        #   email = "heidi@example.net"
-        #   file.acl.add_writer "user-#{email}"
-        #
-        # @example Grant access to a group by pre-pending `"group-"` to an email
-        #   require "gcloud"
-        #
-        #   gcloud = Gcloud.new
-        #   storage = gcloud.storage
-        #
-        #   bucket = storage.bucket "my-bucket"
-        #
-        #   file = bucket.file "path/to/my-file.ext"
-        #   email = "authors@example.net"
-        #   file.acl.add_writer "group-#{email}"
-        #
-        def add_writer entity, generation: nil
-          options = { generation: generation }
-          resp = @connection.insert_file_acl @bucket, @file, entity,
-                                             "WRITER", options
-          if resp.success?
-            entity = resp.data["entity"]
-            @writers.push entity unless @writers.nil?
-            return entity
-          end
-          nil
+          gapi = @service.insert_file_acl @bucket, @file, entity, "OWNER",
+                                          options
+          entity = gapi.entity
+          @owners.push entity unless @owners.nil?
+          entity
         end
 
         ##
@@ -300,14 +224,11 @@ module Gcloud
         #
         def add_reader entity, generation: nil
           options = { generation: generation }
-          resp = @connection.insert_file_acl @bucket, @file, entity,
-                                             "READER", options
-          if resp.success?
-            entity = resp.data["entity"]
-            @readers.push entity unless @readers.nil?
-            return entity
-          end
-          nil
+          gapi = @service.insert_file_acl @bucket, @file, entity, "READER",
+                                          options
+          entity = gapi.entity
+          @readers.push entity unless @readers.nil?
+          entity
         end
 
         ##
@@ -342,14 +263,10 @@ module Gcloud
         #
         def delete entity, generation: nil
           options = { generation: generation }
-          resp = @connection.delete_file_acl @bucket, @file, entity, options
-          if resp.success?
-            @owners.delete entity  unless @owners.nil?
-            @writers.delete entity unless @writers.nil?
-            @readers.delete entity unless @readers.nil?
-            return true
-          end
-          false
+          @service.delete_file_acl @bucket, @file, entity, options
+          @owners.delete entity  unless @owners.nil?
+          @readers.delete entity unless @readers.nil?
+          true
         end
 
         # @private
@@ -486,23 +403,20 @@ module Gcloud
 
         def clear!
           @owners  = nil
-          @writers = nil
           @readers = nil
           self
         end
 
         def update_predefined_acl! acl_role
-          resp = @connection.patch_file @bucket, @file,
-                                        predefined_acl: acl_role,
-                                        acl: []
-
-          return clear! if resp.success?
-          fail Gcloud::Storage::ApiError.from_response(resp)
+          patched_file = Google::Apis::StorageV1::Object.new acl: nil
+          @service.patch_file \
+            @bucket, @file, patched_file, predefined_acl: acl_role
+          clear!
         end
 
         def entities_from_acls acls, role
-          selected = acls.select { |acl| acl["role"] == role }
-          entities = selected.map { |acl| acl["entity"] }
+          selected = acls.select { |acl| acl.role == role }
+          entities = selected.map(&:entity)
           entities
         end
       end

data/lib/gcloud/storage/file/list.rb

@@ -77,15 +77,14 @@ module Gcloud
         #
         def next
           return nil unless next?
-          ensure_connection!
+          ensure_service!
           options = {
             prefix: @prefix, delimiter: @delimiter, token: @token, max: @max,
             versions: @versions
           }
-          resp = @connection.list_files @bucket, options
-          fail ApiError.from_response(resp) unless resp.success?
-          File::List.from_response resp, @connection, @bucket, @prefix,
-                                   @delimiter, @max, @versions
+          gapi = @service.list_files @bucket, options
+          File::List.from_gapi gapi, @service, @bucket, @prefix,
+                               @delimiter, @max, @versions
         end
 
         ##
@@ -161,29 +160,30 @@ module Gcloud
         end
 
         ##
-        # @private New File::List from a response object.
-        def self.from_response resp, conn, bucket = nil, prefix = nil,
-                               delimiter = nil, max = nil, versions = nil
-          files = new(Array(resp.data["items"]).map do |gapi_object|
-            File.from_gapi gapi_object, conn
+        # @private New File::List from a Google API Client
+        # Google::Apis::StorageV1::Objects object.
+        def self.from_gapi gapi_list, service, bucket = nil, prefix = nil,
+                           delimiter = nil, max = nil, versions = nil
+          files = new(Array(gapi_list.items).map do |gapi_object|
+            File.from_gapi gapi_object, service
           end)
-          files.instance_variable_set "@token", resp.data["nextPageToken"]
-          files.instance_variable_set "@prefixes", Array(resp.data["prefixes"])
-          files.instance_variable_set "@connection", conn
-          files.instance_variable_set "@bucket", bucket
-          files.instance_variable_set "@prefix", prefix
-          files.instance_variable_set "@delimiter", delimiter
-          files.instance_variable_set "@max", max
-          files.instance_variable_set "@versions", versions
+          files.instance_variable_set :@token, gapi_list.next_page_token
+          files.instance_variable_set :@prefixes, Array(gapi_list.prefixes)
+          files.instance_variable_set :@service, service
+          files.instance_variable_set :@bucket, bucket
+          files.instance_variable_set :@prefix, prefix
+          files.instance_variable_set :@delimiter, delimiter
+          files.instance_variable_set :@max, max
+          files.instance_variable_set :@versions, versions
           files
         end
 
         protected
 
         ##
-        # Raise an error unless an active connection is available.
-        def ensure_connection!
-          fail "Must have active connection" unless @connection
+        # Raise an error unless an active service is available.
+        def ensure_service!
+          fail "Must have active connection" unless @service
         end
       end
     end

data/lib/gcloud/storage/project.rb

@@ -15,7 +15,7 @@
 
 require "gcloud/gce"
 require "gcloud/storage/errors"
-require "gcloud/storage/connection"
+require "gcloud/storage/service"
 require "gcloud/storage/credentials"
 require "gcloud/storage/bucket"
 require "gcloud/storage/bucket/cors"
@@ -48,17 +48,15 @@ module Gcloud
     #
     class Project
       ##
-      # @private The Connection object.
-      attr_accessor :connection
+      # @private The Service object.
+      attr_accessor :service
 
       ##
       # @private Creates a new Project instance.
       #
       # See {Gcloud#storage}
-      def initialize project, credentials
-        project = project.to_s # Always cast to a string
-        fail ArgumentError, "project is missing" if project.empty?
-        @connection = Connection.new project, credentials
+      def initialize service
+        @service = service
       end
 
       ##
@@ -74,7 +72,7 @@ module Gcloud
       #   storage.project #=> "my-todo-project"
       #
       def project
-        connection.project
+        service.project
       end
 
       ##
@@ -133,12 +131,8 @@ module Gcloud
       #
       def buckets prefix: nil, token: nil, max: nil
         options = { prefix: prefix, token: token, max: max }
-        resp = connection.list_buckets options
-        if resp.success?
-          Bucket::List.from_response resp, connection, prefix, max
-        else
-          fail ApiError.from_response(resp)
-        end
+        gapi = service.list_buckets options
+        Bucket::List.from_gapi gapi, service, prefix, max
       end
       alias_method :find_buckets, :buckets
 
@@ -160,13 +154,10 @@ module Gcloud
       #   puts bucket.name
       #
       def bucket bucket_name
-        resp = connection.get_bucket bucket_name
-        if resp.success?
-          Bucket.from_gapi resp.data, connection
-        else
-          return nil if resp.data["error"]["code"] == 404
-          fail ApiError.from_response(resp)
-        end
+        gapi = service.get_bucket bucket_name
+        Bucket.from_gapi gapi, service
+      rescue Gcloud::NotFoundError
+        nil
       end
       alias_method :find_bucket, :bucket
 
@@ -176,7 +167,7 @@ module Gcloud
       # bucket. See {Bucket::Cors} for details.
       #
       # The API call to create the bucket may be retried under certain
-      # conditions. See {Gcloud::Backoff} to control this behavior.
+      # conditions. See {Gcloud#storage} to control this behavior.
       #
       # You can pass [website
       # settings](https://cloud.google.com/storage/docs/website-configuration)
@@ -221,10 +212,6 @@ module Gcloud
       #     and project team members get access according to their roles.
       #   * `public`, `public_read`, `publicRead` - File owner gets OWNER
       #     access, and allUsers get READER access.
-      # @param [String] cors The CORS rules for the bucket. Accepts an array of
-      #   hashes containing the attributes specified for the [resource
-      #   description of
-      #   cors](https://cloud.google.com/storage/docs/json_api/v1/buckets#cors).
       # @param [String] location The location of the bucket. Object data for
       #   objects in the bucket resides in physical storage within this region.
       #   Possible values include `ASIA`, `EU`, and `US`. (See the [developer's
@@ -260,8 +247,8 @@ module Gcloud
       #   does not exist. For more information, see [How to Host a Static
       #   Website
       #   ](https://cloud.google.com/storage/docs/website-configuration#step4).
-      # @yield [cors] a block for setting CORS rules
-      # @yieldparam [Bucket::Cors] cors the object accepting CORS rules
+      # @yield [bucket] a block for configuring the bucket before it is created
+      # @yieldparam [Bucket] cors the bucket object to be configured
       #
       # @return [Gcloud::Storage::Bucket]
       #
@@ -273,38 +260,42 @@ module Gcloud
       #
       #   bucket = storage.create_bucket "my-bucket"
       #
-      # @example Add CORS rules in a block:
+      # @example Configure the bucket in a block:
       #   require "gcloud"
       #
       #   gcloud = Gcloud.new
       #   storage = gcloud.storage
       #
-      #   options = {
-      #     website_main: "index.html"
-      #     website_404: "not_found.html"
-      #   }
-      #   bucket = storage.create_bucket "my-bucket", options do |c|
-      #     c.add_rule ["http://example.org", "https://example.org"],
-      #                "*",
-      #                response_headers: ["X-My-Custom-Header"],
-      #                max_age: 300
+      #   bucket = storage.create_bucket "my-bucket" do |b|
+      #     b.website_main = "index.html"
+      #     b.website_404 = "not_found.html"
+      #     b.cors.add_rule ["http://example.org", "https://example.org"],
+      #                      "*",
+      #                      response_headers: ["X-My-Custom-Header"],
+      #                      max_age: 300
       #   end
       #
-      def create_bucket bucket_name, acl: nil, default_acl: nil, cors: nil,
-                        location: nil, logging_bucket: nil, logging_prefix: nil,
-                        storage_class: nil, versioning: nil, website_main: nil,
-                        website_404: nil
-        opts = { acl: acl_rule(acl), default_acl: acl_rule(default_acl),
-                 cors: cors, location: location, logging_bucket: logging_bucket,
-                 logging_prefix: logging_prefix, storage_class: storage_class,
-                 versioning: versioning, website_main: website_main,
-                 website_404: website_404 }
-        if block_given?
-          cors_builder = Bucket::Cors.new
-          yield cors_builder
-          opts[:cors] = cors_builder if cors_builder.changed?
+      def create_bucket bucket_name, acl: nil, default_acl: nil,
+                        location: nil, storage_class: nil, logging_bucket: nil,
+                        logging_prefix: nil, website_main: nil,
+                        website_404: nil, versioning: nil
+        new_bucket = Google::Apis::StorageV1::Bucket.new({
+          name: bucket_name,
+          location: location,
+          storage_class: storage_class_for(storage_class)
+        }.delete_if { |_, v| v.nil? })
+        updater = Bucket::Updater.new(new_bucket).tap do |b|
+          b.logging_bucket = logging_bucket unless logging_bucket.nil?
+          b.logging_prefix = logging_prefix unless logging_prefix.nil?
+          b.website_main = website_main unless website_main.nil?
+          b.website_404 = website_404 unless website_404.nil?
+          b.versioning = versioning unless versioning.nil?
         end
-        insert_bucket bucket_name, opts
+        yield updater if block_given?
+        updater.check_for_mutable_cors!
+        gapi = service.insert_bucket \
+          new_bucket, acl: acl_rule(acl), default_acl: acl_rule(default_acl)
+        Bucket.from_gapi gapi, service
       end
 
       protected
@@ -313,13 +304,12 @@ module Gcloud
         Bucket::Acl.predefined_rule_for option_name
       end
 
-      def insert_bucket bucket_name, options
-        resp = connection.insert_bucket bucket_name, options
-        if resp.success?
-          Bucket.from_gapi resp.data, connection
-        else
-          fail ApiError.from_response(resp)
-        end
+      def storage_class_for str
+        { "durable_reduced_availability" => "DURABLE_REDUCED_AVAILABILITY",
+          "dra" => "DURABLE_REDUCED_AVAILABILITY",
+          "durable" => "DURABLE_REDUCED_AVAILABILITY",
+          "nearline" => "NEARLINE",
+          "standard" => "STANDARD" }[str.to_s.downcase]
       end
     end
   end

data/lib/gcloud/storage/service.rb

@@ -0,0 +1,347 @@
+# Copyright 2014 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.
+
+
+require "gcloud/version"
+require "gcloud/backoff"
+require "google/apis/storage_v1"
+require "digest"
+require "mime/types"
+require "pathname"
+
+module Gcloud
+  module Storage
+    ##
+    # @private Represents the connection to Storage,
+    # as well as expose the API calls.
+    class Service
+      ##
+      # Alias to the Google Client API module
+      API = Google::Apis::StorageV1
+
+      # @private
+      attr_accessor :project
+
+      # @private
+      attr_accessor :credentials
+
+      ##
+      # Creates a new Service instance.
+      def initialize project, credentials, retries: nil, timeout: nil
+        @project = project
+        @credentials = credentials
+        @credentials = credentials
+        @service = API::StorageService.new
+        @service.client_options.application_name    = "gcloud-ruby"
+        @service.client_options.application_version = Gcloud::VERSION
+        @service.request_options.retries = retries || 3
+        @service.request_options.timeout_sec = timeout if timeout
+        @service.authorization = @credentials.client
+      end
+
+      def service
+        return mocked_service if mocked_service
+        @service
+      end
+      attr_accessor :mocked_service
+
+      ##
+      # Retrieves a list of buckets for the given project.
+      def list_buckets prefix: nil, token: nil, max: nil
+        service.list_buckets @project, prefix: prefix, page_token: token,
+                                       max_results: max
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Retrieves bucket by name.
+      # Returns Google::Apis::StorageV1::Bucket.
+      def get_bucket bucket_name
+        service.get_bucket bucket_name
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Creates a new bucket.
+      # Returns Google::Apis::StorageV1::Bucket.
+      def insert_bucket bucket_gapi, options = {}
+        service.insert_bucket \
+          @project, bucket_gapi,
+          predefined_acl: options[:acl],
+          predefined_default_object_acl: options[:default_acl]
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Updates a bucket, including its ACL metadata.
+      def patch_bucket bucket_name, bucket_gapi = nil, predefined_acl: nil,
+                       predefined_default_acl: nil
+        bucket_gapi ||= Google::Apis::StorageV1::Bucket.new
+        bucket_gapi.acl = nil if predefined_acl
+        bucket_gapi.default_object_acl = nil if predefined_default_acl
+
+        service.patch_bucket \
+          bucket_name, bucket_gapi,
+          predefined_acl: predefined_acl,
+          predefined_default_object_acl: predefined_default_acl
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Permanently deletes an empty bucket.
+      def delete_bucket bucket_name
+        service.delete_bucket bucket_name
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Retrieves a list of ACLs for the given bucket.
+      def list_bucket_acls bucket_name
+        service.list_bucket_access_controls bucket_name
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Creates a new bucket ACL.
+      def insert_bucket_acl bucket_name, entity, role
+        new_acl = Google::Apis::StorageV1::BucketAccessControl.new \
+          entity: entity, role: role
+        service.insert_bucket_access_control bucket_name, new_acl
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Permanently deletes a bucket ACL.
+      def delete_bucket_acl bucket_name, entity
+        service.delete_bucket_access_control bucket_name, entity
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Retrieves a list of default ACLs for the given bucket.
+      def list_default_acls bucket_name
+        service.list_default_object_access_controls bucket_name
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Creates a new default ACL.
+      def insert_default_acl bucket_name, entity, role
+        new_acl = Google::Apis::StorageV1::ObjectAccessControl.new \
+          entity: entity, role: role
+        service.insert_default_object_access_control bucket_name, new_acl
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Permanently deletes a default ACL.
+      def delete_default_acl bucket_name, entity
+        service.delete_default_object_access_control bucket_name, entity
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Retrieves a list of files matching the criteria.
+      def list_files bucket_name, options = {}
+        service.list_objects \
+          bucket_name, delimiter: options[:delimiter],
+                       max_results: options[:max], page_token: options[:token],
+                       prefix: options[:prefix], versions: options[:versions]
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Inserts a new file for the given bucket
+      def insert_file bucket_name, source, path = nil, acl: nil,
+                      cache_control: nil, content_disposition: nil,
+                      content_encoding: nil, content_language: nil,
+                      content_type: nil, crc32c: nil, md5: nil, metadata: nil,
+                      key: nil, key_sha256: nil
+        file_obj = Google::Apis::StorageV1::Object.new \
+          cache_control: cache_control, content_type: content_type,
+          content_disposition: content_disposition, md5_hash: md5,
+          content_encoding: content_encoding, crc32c: crc32c,
+          content_language: content_language, metadata: metadata
+        content_type ||= mime_type_for(Pathname(source).to_path)
+        service.insert_object \
+          bucket_name, file_obj,
+          name: path, predefined_acl: acl, upload_source: source,
+          content_encoding: content_encoding, content_type: content_type,
+          options: key_options(key: key, key_sha256: key_sha256)
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Retrieves an object or its metadata.
+      def get_file bucket_name, file_path, generation: nil, key: nil,
+                   key_sha256: nil
+        service.get_object \
+          bucket_name, file_path,
+          generation: generation,
+          options: key_options(key: key, key_sha256: key_sha256)
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ## 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 = {}
+        service.copy_object \
+          source_bucket_name, source_file_path,
+          destination_bucket_name, destination_file_path,
+          destination_predefined_acl: options[:acl],
+          source_generation: options[:generation],
+          options: key_options(key: options[:key],
+                               key_sha256: options[:key_sha256])
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Download contents of a file.
+      def download_file bucket_name, file_path, target_path, generation: nil,
+                        key: nil, key_sha256: nil
+        service.get_object \
+          bucket_name, file_path,
+          download_dest: target_path, generation: generation,
+          options: key_options(key: key, key_sha256: key_sha256)
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Updates a file's metadata.
+      def patch_file bucket_name, file_path, file_gapi = nil,
+                     predefined_acl: nil
+        file_gapi ||= Google::Apis::StorageV1::Object.new
+        service.patch_object \
+          bucket_name, file_path, file_gapi,
+          predefined_acl: predefined_acl
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Permanently deletes a file.
+      def delete_file bucket_name, file_path
+        service.delete_object bucket_name, file_path
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Retrieves a list of ACLs for the given file.
+      def list_file_acls bucket_name, file_name
+        service.list_object_access_controls bucket_name, file_name
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Creates a new file ACL.
+      def insert_file_acl bucket_name, file_name, entity, role, options = {}
+        new_acl = Google::Apis::StorageV1::ObjectAccessControl.new \
+          entity: entity, role: role
+        service.insert_object_access_control \
+          bucket_name, file_name, new_acl, generation: options[:generation]
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Permanently deletes a file ACL.
+      def delete_file_acl bucket_name, file_name, entity, options = {}
+        service.delete_object_access_control \
+          bucket_name, file_name, entity, generation: options[:generation]
+      rescue Google::Apis::Error => e
+        raise Gcloud::Error.from_error(e)
+      end
+
+      ##
+      # Retrieves the mime-type for a file path.
+      # An empty string is returned if no mime-type can be found.
+      def mime_type_for path
+        MIME::Types.of(path).first.to_s
+      end
+
+      # @private
+      def inspect
+        "#{self.class}(#{@project})"
+      end
+
+      protected
+
+      def key_options key: nil, key_sha256: nil
+        options = {}
+        if key
+          headers = {}
+          headers["x-goog-encryption-algorithm"] = "AES256"
+          headers["x-goog-encryption-key"] = Base64.strict_encode64 key
+          key_sha256 ||= Digest::SHA256.digest key
+          headers["x-goog-encryption-key-sha256"] = \
+            Base64.strict_encode64 key_sha256
+          options[:header] = headers
+        end
+        options
+      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]
+        {
+          log_bucket: bucket,
+          log_object_prefix: prefix
+        }.delete_if { |_, v| v.nil? } if bucket || prefix
+      end
+
+      def website_config options
+        website_main = options[:website_main]
+        website_404 = options[:website_404]
+        {
+          main_page_suffix: website_main,
+          not_found_page: website_404
+        }.delete_if { |_, v| v.nil? } if website_main || website_404
+      end
+    end
+  end
+end