fog 1.10.0 → 1.10.1

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::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::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::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::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::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::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::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::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,7 +7,10 @@ module Fog
         #
         # ==== Parameters
         # * name<~String> - Name for container, should be < 256 bytes and must not contain '/'
-        #
+        # @raise [Fog::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::ServiceError]
         def put_container(name, options={})
           request(
             :expects  => [201, 202],

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

@@ -10,7 +10,10 @@ module Fog
         # * object<~String> - Name for object
         # * data<~String|File> - data to upload
         # * options<~Hash> - config headers for object. Defaults to {}.
-        #
+        # @raise [Fog::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::ServiceError]
         def put_object(container, object, data, options = {})
           data = Fog::Storage.parse_data(data)
           headers = data[:headers].merge!(options)

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

@@ -8,7 +8,10 @@ module Fog
         # ==== Parameters
         # * container<~String> - Name for container, should be < 256 bytes and must not contain '/'
         # * object<~String> - Name for object
-        #
+        # @raise [Fog::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::ServiceError]
         def put_object_manifest(container, object)
           path = "#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object)}"
           request(

data/lib/fog/rackspace/service.rb

@@ -0,0 +1,78 @@
+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
+
+      private
+
+      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]
+        }
+
+        @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

@@ -6,8 +6,8 @@ module Fog
     class Rackspace < Fog::Service
 
       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
@@ -39,7 +39,9 @@ module Fog
             :provider           => 'Rackspace',
             :rackspace_api_key  => @rackspace_api_key,
             :rackspace_auth_url => @rackspace_auth_url,
+            :rackspace_cdn_url => @rackspace_cdn_url,
             :rackspace_username => @rackspace_username,
+            :rackspace_region => @rackspace_region,
             :rackspace_cdn_ssl => @rackspace_cdn_ssl
           )
           if @cdn.enabled?
@@ -47,9 +49,9 @@ module Fog
           end
         end
 
-      end
+      end      
 
-      class Mock
+      class Mock < Fog::Rackspace::Service
         include Utils
 
         def self.data
@@ -76,10 +78,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={})
@@ -91,24 +102,33 @@ 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.defaults[:ssl_verify_peer] = false if options[:rackspace_servicenet] == true
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
-        end
+          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
@@ -119,10 +139,10 @@ module Fog
               :headers  => {
                 'Content-Type' => 'application/json',
                 'Accept' => 'application/json',
-                'X-Auth-Token' => @auth_token
+                'X-Auth-Token' => auth_token
               }.merge!(params[:headers] || {}),
-              :host     => @host,
-              :path     => "#{@path}/#{params[:path]}",
+              :host     => endpoint_uri.host,
+              :path     => "#{endpoint_uri.path}/#{params[:path]}",
             }), &block)
           rescue Excon::Errors::Unauthorized => error
             if error.response.body != 'Bad username or password' # token expiration
@@ -146,28 +166,48 @@ module Fog
           response
         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
-            }
-            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 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
     end
   end

data/lib/fog/riakcs.rb

@@ -0,0 +1,122 @@
+require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+
+module Fog
+  module RiakCS
+
+    module MultipartUtils
+      require 'net/http'
+
+      class Headers
+        include Net::HTTPHeader
+
+        def initialize
+          initialize_http_header({})
+        end
+
+        # Parse a single header line into its key and value
+        # @param [String] chunk a single header line
+        def self.parse(chunk)
+          line = chunk.strip
+          # thanks Net::HTTPResponse
+          return [nil,nil] if chunk =~ /\AHTTP(?:\/(\d+\.\d+))?\s+(\d\d\d)\s*(.*)\z/in
+          m = /\A([^:]+):\s*/.match(line)
+          [m[1], m.post_match] rescue [nil, nil]
+        end
+
+        # Parses a header line and adds it to the header collection
+        # @param [String] chunk a single header line
+        def parse(chunk)
+          key, value = self.class.parse(chunk)
+          add_field(key, value) if key && value
+        end
+      end
+
+      def parse(data, boundary)
+        contents = data.match(end_boundary_regex(boundary)).pre_match rescue ""
+        contents.split(inner_boundary_regex(boundary)).reject(&:empty?).map do |part|
+          parse_multipart_section(part)
+        end.compact
+      end
+
+      def extract_boundary(header_string)
+        $1 if header_string =~ /boundary=([A-Za-z0-9\'()+_,-.\/:=?]+)/
+      end
+
+      private
+      def end_boundary_regex(boundary)
+        /\r?\n--#{Regexp.escape(boundary)}--\r?\n?/
+      end
+
+      def inner_boundary_regex(boundary)
+        /\r?\n--#{Regexp.escape(boundary)}\r?\n/
+      end
+
+      def parse_multipart_section(part)
+        headers = Headers.new
+        if md = part.match(/\r?\n\r?\n/)
+          body = md.post_match
+          md.pre_match.split(/\r?\n/).each do |line|
+            headers.parse(line)
+          end
+
+          if headers["content-type"] =~ /multipart\/mixed/
+            boundary = extract_boundary(headers.to_hash["content-type"].first)
+            parse(body, boundary)
+          else
+            {:headers => headers.to_hash, :body => body}
+          end
+        end
+      end
+    end
+
+    module UserUtils
+      def update_riakcs_user(key_id, user)
+        response = @s3_connection.put_object('riak-cs', "user/#{key_id}", MultiJson.encode(user), { 'Content-Type' => 'application/json' })
+        if !response.body.empty?
+          response.body = MultiJson.decode(response.body)
+        end
+        response
+      end
+
+      def update_mock_user(key_id, user)
+        if data[key_id]
+          if status = user[:status]
+            data[key_id][:status] = status
+          end
+
+          if regrant = user[:new_key_secret]
+            data[key_id][:key_secret] = rand(100).to_s
+          end
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body   = data[key_id]
+          end
+        else
+          Excon::Response.new.tap do |response|
+            response.status = 403
+          end
+        end
+      end
+    end
+
+    module Utils
+      def configure_uri_options(options = {})
+        @host       = options[:host]       || 'localhost'
+        @persistent = options[:persistent] || true
+        @port       = options[:port]       || 8080
+        @scheme     = options[:scheme]     || 'http'
+      end
+
+      def riakcs_uri
+        "#{@scheme}://#{@host}:#{@port}"
+      end
+    end
+
+    extend Fog::Provider
+
+    service(:provisioning, 'riakcs/provisioning', 'Provisioning')
+    service(:usage,        'riakcs/usage',        'Usage')
+
+  end
+end