fog 1.37.0 → 1.38.0

data/lib/fog/rackspace/requests/storage/head_containers.rb

@@ -1,44 +0,0 @@
-module Fog
-  module Storage
-    class Rackspace
-      class Real
-        # List number of containers and total bytes stored
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * headers<~Hash>:
-        #     * 'X-Account-Container-Count'<~String> - Count of containers
-        #     * 'X-Account-Bytes-Used'<~String> - Bytes used
-        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
-        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
-        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
-        # @raise [Fog::Storage::Rackspace::ServiceError]
-        def head_containers
-          request(
-            :expects  => 204,
-            :method   => 'HEAD',
-            :path     => '',
-            :query    => {'format' => 'json'}
-          )
-        end
-      end
-
-      class Mock
-        def head_containers
-          bytes_used = data.values.map { |c| c.bytes_used }.reduce(0) { |a, b| a + b }
-          container_count = data.size
-          object_count = data.values.map { |c| c.objects.size }.reduce(0) { |a, b| a + b }
-
-          response = Excon::Response.new
-          response.status = 204
-          response.headers = {
-            'X-Account-Bytes-Used' => bytes_used,
-            'X-Account-Container-Count' => container_count,
-            'X-Account-Object-Count' => object_count
-          }.merge(account_meta)
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/storage/head_object.rb

@@ -1,48 +0,0 @@
-module Fog
-  module Storage
-    class Rackspace
-      class Real
-        # Get headers for object
-        #
-        # ==== Parameters
-        # * container<~String> - Name of container to look in
-        # * object<~String> - Name of object to look for
-        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
-        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
-        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
-        # @raise [Fog::Storage::Rackspace::ServiceError]
-        def head_object(container, object)
-          request({
-            :expects  => 200,
-            :method   => 'HEAD',
-            :path     => "#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object)}"
-          }, false)
-        end
-      end
-
-      class Mock
-        def head_object(container, object)
-          c = mock_container! container
-          o = c.mock_object! object
-
-          headers = o.to_headers
-
-          hashes, length = [], 0
-          o.each_part do |part|
-            hashes << part.hash
-            length += part.bytes_used
-          end
-
-          headers['Etag'] = "\"#{Digest::MD5.hexdigest(hashes.join)}\""
-          headers['Content-Length'] = length.to_s
-          headers['X-Static-Large-Object'] = "True" if o.static_manifest?
-
-          response = Excon::Response.new
-          response.status = 200
-          response.headers = headers
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/storage/post_set_meta_temp_url_key.rb

@@ -1,46 +0,0 @@
-module Fog
-  module Storage
-    class Rackspace
-      class Real
-        # Set the account wide Temp URL Key. This is a secret key that's
-        # used to generate signed expiring URLs.
-        #
-        # Once the key has been set with this request you should create new
-        # Storage objects with the :rackspace_temp_url_key option then use
-        # the get_object_https_url method to generate expiring URLs.
-        #
-        # *** CAUTION *** changing this secret key will invalidate any expiring
-        # URLS generated with old keys.
-        #
-        # ==== Parameters
-        # * key<~String> - The new Temp URL Key
-        #
-        # ==== Returns
-        # * response<~Excon::Response>
-        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
-        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
-        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
-        # @raise [Fog::Storage::Rackspace::ServiceError]
-        # ==== See Also
-        # http://docs.rackspace.com/files/api/v1/cf-devguide/content/Set_Account_Metadata-d1a4460.html
-        def post_set_meta_temp_url_key(key)
-          request(
-            :expects  => [201, 202, 204],
-            :method   => 'POST',
-            :headers  => {'X-Account-Meta-Temp-Url-Key' => key}
-          )
-        end
-      end
-
-      class Mock
-        def post_set_meta_temp_url_key(key)
-          account_meta['X-Account-Meta-Temp-Url-Key'] = key
-
-          response = Excon::Response.new
-          response.status = 204
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/storage/put_container.rb

@@ -1,42 +0,0 @@
-module Fog
-  module Storage
-    class Rackspace
-      class Real
-        # Create a new container
-        #
-        # ==== Parameters
-        # * name<~String> - Name for container, should be < 256 bytes and must not contain '/'
-        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
-        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
-        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
-        # @raise [Fog::Storage::Rackspace::ServiceError]
-        def put_container(name, options={})
-          if name =~ /\//
-            raise Fog::Errors::Error.new('Folder names cannot include "/".')
-          else
-            request(
-              :expects  => [201, 202],
-              :method   => 'PUT',
-              :headers => options,
-              :path     => Fog::Rackspace.escape(name)
-            )
-          end
-        end
-      end
-
-      class Mock
-        def put_container(name, options={})
-          existed = ! mock_container(name).nil?
-          container = add_container(name)
-          options.keys.each do |k|
-            container.meta[k] = options[k].to_s if k =~ /^X-Container-Meta/
-          end
-
-          response = Excon::Response.new
-          response.status = existed ? 202 : 201
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/storage/put_dynamic_obj_manifest.rb

@@ -1,63 +0,0 @@
-module Fog
-  module Storage
-    class Rackspace
-      class Real
-        # Create a new dynamic large object manifest
-        #
-        # Creates an object with a +X-Object-Manifest+ header that specifies the common prefix ("<container>/<prefix>")
-        # for all uploaded segments. Retrieving the manifest object streams all segments matching this prefix.
-        # Segments must sort in the order they should be concatenated. Note that any future objects stored in the container
-        # along with the segments that match the prefix will be included when retrieving the manifest object.
-        #
-        # All segments must be stored in the same container, but may be in a different container than the manifest object.
-        # The default +X-Object-Manifest+ header is set to "+container+/+object+", but may be overridden in +options+
-        # to specify the prefix and/or the container where segments were stored.
-        # If overridden, names should be CGI escaped (excluding spaces) if needed (see {Fog::Rackspace.escape}).
-        #
-        # @param container [String] Name for container where +object+ will be stored. Should be < 256 bytes and must not contain '/'
-        # @param object [String] Name for manifest object.
-        # @param options [Hash] Config headers for +object+.
-        # @option options [String] 'X-Object-Manifest' ("container/object") "<container>/<prefix>" for segment objects.
-        #
-        # @raise [Fog::Storage::Rackspace::NotFound] HTTP 404
-        # @raise [Fog::Storage::Rackspace::BadRequest] HTTP 400
-        # @raise [Fog::Storage::Rackspace::InternalServerError] HTTP 500
-        # @raise [Fog::Storage::Rackspace::ServiceError]
-        # @raise [Excon::Errors::Unauthorized]
-        #
-        # @see http://docs.rackspace.com/files/api/v1/cf-devguide/content/Large_Object_Creation-d1e2019.html
-        def put_dynamic_obj_manifest(container, object, options = {})
-          path = "#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object)}"
-          headers = {'X-Object-Manifest' => path}.merge(options)
-          request(
-            :expects  => 201,
-            :headers  => headers,
-            :method   => 'PUT',
-            :path     => path
-          )
-        end
-      end
-
-      class Mock
-        def put_dynamic_obj_manifest(container, object, options = {})
-          path = "#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object)}"
-
-          # Escape the X-Object-Manifest header to match.
-          explicit_manifest = options['X-Object-Manifest']
-          if explicit_manifest
-            parts = explicit_manifest.split('/', 2)
-            explicit_manifest = parts.map { |p| Fog::Rackspace.escape p }.join('/')
-          end
-
-          c = mock_container! container
-          o = c.add_object object, ''
-          o.meta['X-Object-Manifest'] = explicit_manifest || path
-
-          response = Excon::Response.new
-          response.status = 201
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/storage/put_object.rb

@@ -1,77 +0,0 @@
-module Fog
-  module Storage
-    class Rackspace
-      class Real
-        # Create a new object
-        #
-        # When passed a block, it will make a chunked request, calling
-        # the block for chunks until it returns an empty string.
-        # In this case the data parameter is ignored.
-        #
-        # ==== Parameters
-        # * container<~String> - Name for container, should be < 256 bytes and must not contain '/'
-        # * object<~String> - Name for object
-        # * data<~String|File> - data to upload
-        # * options<~Hash> - config headers for object. Defaults to #{}.
-        # * block<~Proc> - chunker
-        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
-        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
-        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
-        # @raise [Fog::Storage::Rackspace::ServiceError]
-        def put_object(container, object, data, options = {}, &block)
-          data = Fog::Storage.parse_data(data)
-          headers = data[:headers].merge!(options)
-
-          params = block_given? ? { :request_block => block } : { :body => data[:body] }
-
-          params.merge!(
-            :expects    => 201,
-            :idempotent => !params[:request_block],
-            :headers    => headers,
-            :method     => 'PUT',
-            :path       => "#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object)}"
-          )
-
-          request(params)
-        end
-      end
-
-      class Mock
-        HeaderOptions = %w{
-          Content-Type Access-Control-Allow-Origin Origin Content-Disposition
-          Etag Content-Encoding
-        }.freeze
-
-        def put_object(container, object, data, options = {}, &block)
-          c = mock_container! container
-
-          if block_given?
-            data = ""
-            loop do
-              chunk = yield
-              break if chunk.empty?
-              data << chunk
-            end
-          end
-
-          o = c.add_object object, data
-          options.keys.each do |k|
-            o.meta[k] = options[k].to_s if k =~ /^X-Object-Meta/
-            o.meta[k] = options[k] if HeaderOptions.include? k
-          end
-
-          # Validate the provided Etag
-          etag = o.meta['Etag']
-          if etag && etag != o.hash
-            c.remove_object object
-            raise Fog::Storage::Rackspace::ServiceError.new
-          end
-
-          response = Excon::Response.new
-          response.status = 201
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/storage/put_object_manifest.rb

@@ -1,22 +0,0 @@
-module Fog
-  module Storage
-    class Rackspace
-      module Common
-        # Create a new dynamic large object manifest
-        #
-        # This is an alias for {#put_dynamic_obj_manifest} for backward compatibility.
-        def put_object_manifest(container, object, options = {})
-          put_dynamic_obj_manifest(container, object, options)
-        end
-      end
-
-      class Real
-        include Common
-      end
-
-      class Mock
-        include Common
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/storage/put_static_obj_manifest.rb

@@ -1,102 +0,0 @@
-module Fog
-  module Storage
-    class Rackspace
-      class Real
-        # Create a new static large object manifest.
-        #
-        # A static large object is similar to a dynamic large object. Whereas a GET for a dynamic large object manifest
-        # will stream segments based on the manifest's +X-Object-Manifest+ object name prefix, a static large object
-        # manifest streams segments which are defined by the user within the manifest. Information about each segment is
-        # provided in +segments+ as an Array of Hash objects, ordered in the sequence which the segments should be streamed.
-        #
-        # When the SLO manifest is received, each segment's +etag+ and +size_bytes+ will be verified.
-        # The +etag+ for each segment is returned in the response to {#put_object}, but may also be calculated.
-        # e.g. +Digest::MD5.hexdigest(segment_data)+
-        #
-        # The maximum number of segments for a static large object is 1000, and all segments (except the last) must be
-        # at least 1 MiB in size. Unlike a dynamic large object, segments are not required to be in the same container.
-        #
-        # @example
-        #   segments = [
-        #     { :path => 'segments_container/first_segment',
-        #       :etag => 'md5 for first_segment',
-        #       :size_bytes => 'byte size of first_segment' },
-        #     { :path => 'segments_container/second_segment',
-        #       :etag => 'md5 for second_segment',
-        #       :size_bytes => 'byte size of second_segment' }
-        #   ]
-        #   put_static_obj_manifest('my_container', 'my_large_object', segments)
-        #
-        # @param container [String] Name for container where +object+ will be stored.
-        #     Should be < 256 bytes and must not contain '/'
-        # @param object [String] Name for manifest object.
-        # @param segments [Array<Hash>] Segment data for the object.
-        # @param options [Hash] Config headers for +object+.
-        #
-        # @raise [Fog::Storage::Rackspace::NotFound] HTTP 404
-        # @raise [Fog::Storage::Rackspace::BadRequest] HTTP 400
-        # @raise [Fog::Storage::Rackspace::InternalServerError] HTTP 500
-        # @raise [Fog::Storage::Rackspace::ServiceError]
-        # @raise [Excon::Errors::Unauthorized] HTTP 401
-        #
-        # @see http://docs.rackspace.com/files/api/v1/cf-devguide/content/Uploading_the_Manifext-d1e2227.html
-        def put_static_obj_manifest(container, object, segments, options = {})
-          request(
-            :expects  => 201,
-            :method   => 'PUT',
-            :headers  => options,
-            :body     => Fog::JSON.encode(segments),
-            :path     => "#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object)}",
-            :query    => { 'multipart-manifest' => 'put' }
-          )
-        end
-      end
-
-      class Mock
-        def put_static_obj_manifest(container, object, segments, options = {})
-          c = mock_container! container
-
-          # Verify paths.
-          errors = []
-          segments.each do |segment|
-            cname, oname = segment[:path].split('/', 2)
-            target_container = mock_container(cname)
-
-            raise Fog::Storage::Rackspace::NotFound.new unless target_container
-
-            target_object = target_container.mock_object oname
-            unless target_object
-              errors << [segment[:path], '404 Not Found']
-              next
-            end
-
-            unless target_object.hash == segment[:etag]
-              errors << [segment[:path], 'Etag Mismatch']
-            end
-
-            unless target_object.bytes_used == segment[:size_bytes]
-              errors << [segment[:path], 'Size Mismatch']
-            end
-          end
-
-          unless errors.empty?
-            response = Excon::Response.new
-            response.status = 400
-            response.body = Fog::JSON.encode({ 'Errors' => errors })
-
-            error = Excon::Errors.status_error({}, response)
-            raise Fog::Storage::Rackspace::BadRequest.slurp(error)
-          end
-
-          data = Fog::JSON.encode(segments)
-          o = c.add_object object, data
-          o.static_manifest = true
-
-          response = Excon::Response.new
-          response.status = 201
-          response
-        end
-      end
-    end
-  end
-end