fog-maestrodev 1.8.0.20130114204828 → 1.14.0.20130806165225

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

@@ -14,7 +14,10 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~String> - url 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]
         # ==== See Also
         # http://docs.rackspace.com/files/api/v1/cf-devguide/content/Create_TempURL-d1a444.html
         def get_object_https_url(container, object, expires, options = {})
@@ -24,14 +27,14 @@ module Fog
 
           method         = 'GET'
           expires        = expires.to_i
-          object_path_escaped   = "#{@path}/#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object,"/")}"
-          object_path_unescaped = "#{@path}/#{Fog::Rackspace.escape(container)}/#{object}"
+          object_path_escaped   = "#{@uri.path}/#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object,"/")}"
+          object_path_unescaped = "#{@uri.path}/#{Fog::Rackspace.escape(container)}/#{object}"
           string_to_sign = "#{method}\n#{expires}\n#{object_path_unescaped}"
 
           hmac = Fog::HMAC.new('sha1', @rackspace_temp_url_key)
           sig  = sig_to_hex(hmac.sign(string_to_sign))
 
-          "https://#{@host}#{object_path_escaped}?temp_url_sig=#{sig}&temp_url_expires=#{expires}"
+          "https://#{@uri.host}#{object_path_escaped}?temp_url_sig=#{sig}&temp_url_expires=#{expires}"
         end
 
         private

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

@@ -13,6 +13,10 @@ module Fog
         #   * headers<~Hash>:
         #     * 'X-Container-Object-Count'<~String> - Count of containers
         #     * 'X-Container-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_container(container)
           request(
             :expects  => 204,

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

@@ -10,6 +10,10 @@ module Fog
         #   * 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,

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

@@ -8,7 +8,10 @@ module Fog
         # ==== 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,

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

@@ -19,7 +19,10 @@ module Fog
         #
         # ==== 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)

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

@@ -7,11 +7,15 @@ module Fog
         #
         # ==== Parameters
         # * name<~String> - Name for container, should be < 256 bytes and must not contain '/'
-        #
-        def put_container(name)
+        # @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={})
           request(
             :expects  => [201, 202],
             :method   => 'PUT',
+            :headers => options,
             :path     => Fog::Rackspace.escape(name)
           )
         end

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

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

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

@@ -10,20 +10,26 @@ module Fog
         # * object<~String> - Name for object
         # * data<~String|File> - data to upload
         # * options<~Hash> - config headers for object. Defaults to {}.
-        #
-        def put_object(container, object, data, options = {})
+        # @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)
-          request(
-            :body       => data[:body],
+
+          params = block_given? ? { :request_block => block } : { :body => data[:body] }
+
+          params.merge!(
             :expects    => 201,
-            :idempotent => true,
+            :idempotent => !params[:request_block],
             :headers    => headers,
             :method     => 'PUT',
             :path       => "#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object)}"
           )
-        end
 
+          request(params)
+        end
       end
     end
   end

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

@@ -3,20 +3,11 @@ module Fog
     class Rackspace
       class Real
 
-        # Create a new object
+        # Create a new dynamic large object manifest
         #
-        # ==== Parameters
-        # * container<~String> - Name for container, should be < 256 bytes and must not contain '/'
-        # * object<~String> - Name for object
-        #
-        def put_object_manifest(container, object)
-          path = "#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object)}"
-          request(
-            :expects  => 201,
-            :headers  => {'X-Object-Manifest' => path},
-            :method   => 'PUT',
-            :path     => path
-          )
+        # 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

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

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

data/lib/fog/rackspace/service.rb

@@ -0,0 +1,121 @@
+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(params, parse_json = true, &block)
+        first_attempt = true
+        begin
+          response = @connection.request(request_params(params), &block)
+        rescue Excon::Errors::Unauthorized => error
+          raise error unless first_attempt
+          first_attempt = false
+          authenticate
+          retry
+        end
+
+        process_response(response) if parse_json
+        response
+      end
+
+      private
+
+      def process_response(response)
+        if response && response.body && response.body.is_a?(String) && Fog::Rackspace.json_response?(response)
+          begin
+            response.body = Fog::JSON.decode(response.body)
+          rescue MultiJson::DecodeError => e
+            Fog::Logger.warning("Error Parsing response json - #{e}")
+            response.body = {}
+          end
+        end
+      end
+
+      def headers(options={})
+        h = {
+          '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),
+          :host     => endpoint_uri.host,
+          :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 :rackpace_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)
+      end
+
+      def auth_token
+        @auth_token || @identity_service.auth_token
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/storage.rb

@@ -4,21 +4,29 @@ require 'fog/storage'
 module Fog
   module Storage
     class Rackspace < Fog::Service
+      include Fog::Rackspace::Errors
+
+      class ServiceError < Fog::Rackspace::Errors::ServiceError; end
+      class InternalServerError < Fog::Rackspace::Errors::InternalServerError; end
+      class BadRequest < Fog::Rackspace::Errors::BadRequest; end
 
       requires :rackspace_api_key, :rackspace_username
-      recognizes :rackspace_auth_url, :rackspace_servicenet, :rackspace_cdn_ssl, :persistent
-      recognizes :rackspace_temp_url_key
+      recognizes :rackspace_auth_url, :rackspace_servicenet, :rackspace_cdn_ssl, :persistent, :rackspace_region
+      recognizes :rackspace_temp_url_key, :rackspace_storage_url, :rackspace_cdn_url
 
       model_path 'fog/rackspace/models/storage'
       model       :directory
       collection  :directories
       model       :file
       collection  :files
+      model       :account
 
       request_path 'fog/rackspace/requests/storage'
       request :copy_object
       request :delete_container
       request :delete_object
+      request :delete_static_large_object
+      request :delete_multiple_objects
       request :get_container
       request :get_containers
       request :get_object
@@ -29,6 +37,8 @@ module Fog
       request :put_container
       request :put_object
       request :put_object_manifest
+      request :put_dynamic_obj_manifest
+      request :put_static_obj_manifest
       request :post_set_meta_temp_url_key
 
       module Utils
@@ -38,7 +48,10 @@ module Fog
             :provider           => 'Rackspace',
             :rackspace_api_key  => @rackspace_api_key,
             :rackspace_auth_url => @rackspace_auth_url,
-            :rackspace_username => @rackspace_username
+            :rackspace_cdn_url => @rackspace_cdn_url,
+            :rackspace_username => @rackspace_username,
+            :rackspace_region => @rackspace_region,
+            :rackspace_cdn_ssl => @rackspace_cdn_ssl
           )
           if @cdn.enabled?
             @cdn
@@ -47,7 +60,7 @@ module Fog
 
       end
 
-      class Mock
+      class Mock < Fog::Rackspace::Service
         include Utils
 
         def self.data
@@ -74,10 +87,19 @@ module Fog
           self.class.data.delete(@rackspace_username)
         end
 
+        def service_name
+          :cloudFiles
+        end
+
+        def region
+          @rackspace_region
+        end
+
       end
 
-      class Real
+      class Real < Fog::Rackspace::Service
         include Utils
+
         attr_reader :rackspace_cdn_ssl
 
         def initialize(options={})
@@ -89,71 +111,94 @@ module Fog
           @rackspace_servicenet = options[:rackspace_servicenet]
           @rackspace_auth_token = options[:rackspace_auth_token]
           @rackspace_storage_url = options[:rackspace_storage_url]
+          @rackspace_cdn_url = options[:rackspace_cdn_url]
+          @rackspace_region = options[:rackspace_region] || :dfw
           @rackspace_temp_url_key = options[:rackspace_temp_url_key]
           @rackspace_must_reauthenticate = false
           @connection_options     = options[:connection_options] || {}
+
           authenticate
           @persistent = options[:persistent] || false
-          Excon.ssl_verify_peer = false if options[:rackspace_servicenet] == true
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+          Excon.defaults[:ssl_verify_peer] = false if service_net?
+          @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
         end
 
+        # Return Account Details
+        # @return [Fog::Storage::Rackspace::Account] account details object
+        def account
+          account = Fog::Storage::Rackspace::Account.new(:service => self)
+          account.reload
+        end
+
+        # Using SSL?
+        # @return [Boolean] return true if service is returning SSL-Secured URLs in public_url methods
+        # @see Directory#public_url
+        def ssl?
+          !rackspace_cdn_ssl.nil?
+        end
+
+        # Resets presistent service connections
         def reload
           @connection.reset
         end
 
         def request(params, parse_json = true, &block)
-          begin
-            response = @connection.request(params.merge({
-              :headers  => {
-                'Content-Type' => 'application/json',
-                'X-Auth-Token' => @auth_token
-              }.merge!(params[:headers] || {}),
-              :host     => @host,
-              :path     => "#{@path}/#{params[:path]}",
-            }), &block)
-          rescue Excon::Errors::Unauthorized => error
-            if error.response.body != 'Bad username or password' # token expiration
-              @rackspace_must_reauthenticate = true
-              authenticate
-              retry
-            else # bad credentials
-              raise error
-            end
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-            when Excon::Errors::NotFound
-              Fog::Storage::Rackspace::NotFound.slurp(error)
-            else
-              error
-            end
-          end
-          if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
+          super(params, parse_json, &block)
+        rescue Excon::Errors::NotFound => error
+          raise NotFound.slurp(error, self)
+        rescue Excon::Errors::BadRequest => error
+          raise BadRequest.slurp(error, self)
+        rescue Excon::Errors::InternalServerError => error
+          raise InternalServerError.slurp(error, self)
+        rescue Excon::Errors::HTTPStatusError => error
+          raise ServiceError.slurp(error, self)
         end
 
-        private
+        def service_net?
+          @rackspace_servicenet == true
+        end
 
         def authenticate
           if @rackspace_must_reauthenticate || @rackspace_auth_token.nil?
             options = {
               :rackspace_api_key  => @rackspace_api_key,
               :rackspace_username => @rackspace_username,
-              :rackspace_auth_url => @rackspace_auth_url
+              :rackspace_auth_url => @rackspace_auth_url,
+              :connection_options => @connection_options
             }
-            credentials = Fog::Rackspace.authenticate(options, @connection_options)
-            @auth_token = credentials['X-Auth-Token']
-            uri = URI.parse(credentials['X-Storage-Url'])
+            super(options)
           else
             @auth_token = @rackspace_auth_token
-            uri = URI.parse(@rackspace_storage_url)
+            @uri = URI.parse(@rackspace_storage_url)
           end
-          @host   = @rackspace_servicenet == true ? "snet-#{uri.host}" : uri.host
-          @path   = uri.path
-          @port   = uri.port
-          @scheme = uri.scheme
+        end
+
+        def service_name
+          :cloudFiles
+        end
+
+        def request_id_header
+          "X-Trans-Id"
+        end
+
+        def region
+          @rackspace_region
+        end
+
+        def endpoint_uri(service_endpoint_url=nil)
+          return @uri if @uri
+
+          @uri = super(@rackspace_storage_url || service_endpoint_url, :rackspace_storage_url)
+          @uri.host = "snet-#{@uri.host}" if service_net?
+          @uri
+        end
+
+        private
+
+        def authenticate_v1(options)
+          credentials = Fog::Rackspace.authenticate(options, @connection_options)
+          endpoint_uri credentials['X-Storage-Url']
+          @auth_token = credentials['X-Auth-Token']
         end
 
       end