fog-rackspace 0.1.0

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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,102 @@
+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

data/lib/fog/rackspace/service.rb

@@ -0,0 +1,142 @@
+module Fog
+  module Rackspace
+    class Service
+      def service_name
+        raise Fog::Errors::NotImplemented.new("Please implement the #service_name method")
+      end
+
+      def region
+        raise Fog::Errors::NotImplemented.new("Please implement the #region method")
+      end
+
+      def endpoint_uri(service_endpoint=nil, endpoint_name=nil)
+        return @uri if @uri
+
+        url = service_endpoint
+
+        unless url
+          if v1_authentication?
+            raise "Service Endpoint must be specified via #{endpoint_name} parameter"
+          else
+            url = endpoint_uri_v2
+          end
+        end
+
+        @uri = URI.parse url
+      end
+
+      def authenticate(options={})
+         self.send authentication_method, options
+      end
+
+      def request_without_retry(params, parse_json = true)
+        response = @connection.request(request_params(params))
+
+        process_response(response) if parse_json
+        response
+      end
+
+      def request(params, parse_json = true)
+        first_attempt = true
+        begin
+          response = @connection.request(request_params(params))
+        rescue Excon::Errors::Unauthorized => error
+          raise error unless first_attempt
+          first_attempt = false
+          authenticate
+          retry
+        end
+
+        process_response(response) if parse_json
+        response
+      end
+
+      def service_net?
+        false
+      end
+
+      private
+
+      def process_response(response)
+        if response &&
+           response.body &&
+           response.body.is_a?(String) &&
+           !response.body.strip.empty? &&
+           Fog::Rackspace.json_response?(response)
+          begin
+            response.body = Fog::JSON.decode(response.body)
+          rescue Fog::JSON::DecodeError => e
+            Fog::Logger.warning("Error Parsing response json - #{e}")
+            response.body = {}
+          end
+        end
+      end
+
+      def headers(options={})
+        { 'Content-Type' => 'application/json',
+          'Accept' => 'application/json',
+          'X-Auth-Token' => auth_token
+        }.merge(options[:headers] || {})
+      end
+
+      def request_params(params)
+        params.merge({
+          :headers  => headers(params),
+          :path     => "#{endpoint_uri.path}/#{params[:path]}"
+        })
+      end
+
+      def authentication_method
+        if v2_authentication?
+          :authenticate_v2
+        else
+          Fog::Logger.deprecation "Authentication using a v1.0/v1.1 endpoint is deprecated. Please specify a v2.0 endpoint using :rackspace_auth_url.\
+          For a list of v2.0 endpoints refer to http://docs.rackspace.com/auth/api/v2.0/auth-client-devguide/content/Endpoints-d1e180.html"
+         :authenticate_v1
+        end
+      end
+
+      def v1_authentication?
+        !v2_authentication?
+      end
+
+      def v2_authentication?
+        @rackspace_auth_url.nil? || @rackspace_auth_url =~ /v2(\.\d)?[\w\/]*$/
+      end
+
+      def authenticate_v2(identity_options)
+        hash = {
+              :rackspace_api_key => identity_options[:rackspace_api_key],
+              :rackspace_username => identity_options[:rackspace_username],
+              :rackspace_auth_url => identity_options[:rackspace_auth_url],
+              :connection_options => identity_options[:connection_options] || {}
+        }
+
+        @identity_service = Fog::Rackspace::Identity.new(hash)
+        @auth_token = @identity_service.auth_token
+      end
+
+      def authenticate_v1(options)
+        raise Fog::Errors::NotImplemented.new("Authentication of legacy endpoints is not implemented for this service.")
+      end
+
+      def endpoint_uri_v2
+        @uri = @identity_service.service_catalog.get_endpoint(service_name, region, service_net?)
+      end
+
+      def auth_token
+        @auth_token || @identity_service.auth_token
+      end
+
+      def select_options(keys)
+        return nil unless @options && keys
+        selected = {}
+        keys.each do |k|
+          selected[k] = @options[k]
+        end
+
+        selected
+      end
+    end
+  end
+end