ridley 0.8.1 → 0.8.2

data/lib/ridley/connection.rb

@@ -60,7 +60,6 @@ module Ridley
       end
 
       uri_hash = Addressable::URI.parse(server_url).to_hash.slice(:scheme, :host, :port)
-
       unless uri_hash[:port]
         uri_hash[:port] = (uri_hash[:scheme] == "https" ? 443 : 80)
       end
@@ -69,13 +68,8 @@ module Ridley
         @organization = org_match[1]
       end
 
-      unless @organization.nil?
-        uri_hash[:path] = "/organizations/#{@organization}"
-      end
-
-      server_uri = Addressable::URI.new(uri_hash)
-
-      super(server_uri, options)
+      super(Addressable::URI.new(uri_hash), options)
+      @headers[:user_agent] = "Ridley v#{Ridley::VERSION}"
     end
 
     # @return [Symbol]

data/lib/ridley/errors.rb

@@ -39,6 +39,16 @@ module Ridley
     class ClientKeyFileNotFound < BootstrapError; end
     class EncryptedDataBagSecretNotFound < BootstrapError; end
 
+    # Exception thrown when the maximum amount of requests is exceeded.
+    class RedirectLimitReached < RidleyError
+      attr_reader :response
+
+      def initialize(response)
+        super "too many redirects; last one to: #{response['location']}"
+        @response = response
+      end
+    end
+
     class HTTPError < RidleyError
       class << self
         def fabricate(env)
@@ -87,9 +97,15 @@ module Ridley
       end
     end
 
+    class HTTP3XXError < HTTPError; end
     class HTTP4XXError < HTTPError; end
     class HTTP5XXError < HTTPError; end
 
+    # 3XX
+    class HTTPMovedPermanently < HTTP3XXError; register_error(301); end
+    class HTTPFound < HTTP3XXError; register_error(302); end
+
+    # 4XX
     class HTTPBadRequest < HTTP4XXError; register_error(400); end
     class HTTPUnauthorized < HTTP4XXError; register_error(401); end
     class HTTPForbidden < HTTP4XXError; register_error(403); end
@@ -97,7 +113,8 @@ module Ridley
     class HTTPMethodNotAllowed < HTTP4XXError; register_error(405); end
     class HTTPRequestTimeout < HTTP4XXError; register_error(408); end
     class HTTPConflict < HTTP4XXError; register_error(409); end
-    
+
+    # 5XX
     class HTTPInternalServerError < HTTP5XXError; register_error(500); end
     class HTTPNotImplemented < HTTP5XXError; register_error(501); end
     class HTTPBadGateway < HTTP5XXError; register_error(502); end

data/lib/ridley/middleware.rb

@@ -6,6 +6,7 @@ module Ridley
     require 'ridley/middleware/parse_json'
     require 'ridley/middleware/chef_response'
     require 'ridley/middleware/chef_auth'
+    require 'ridley/middleware/follow_redirects'
     require 'ridley/middleware/retry'
 
     Faraday.register_middleware :request,
@@ -17,6 +18,9 @@ module Ridley
     Faraday.register_middleware :response,
       json: -> { Ridley::Middleware::ParseJson }
 
+    Faraday.register_middleware :response,
+      follow_redirects: -> { Ridley::Middleware::FollowRedirects }
+
     Faraday.register_middleware :response,
       chef_response: -> { Ridley::Middleware::ChefResponse }
   end

data/lib/ridley/middleware/follow_redirects.rb

@@ -0,0 +1,133 @@
+require 'set'
+
+module Ridley
+  module Middleware
+    # Borrowed and modified from:
+    # {https://github.com/lostisland/faraday_middleware/blob/master/lib/faraday_middleware/response/follow_redirects.rb}
+    #
+    # Public: Follow HTTP 301, 302, 303, and 307 redirects for GET, PATCH, POST,
+    # PUT, and DELETE requests.
+    #
+    # This middleware does not follow the HTTP specification for HTTP 302, by
+    # default, in that it follows the improper implementation used by most major
+    # web browsers which forces the redirected request to become a GET request
+    # regardless of the original request method.
+    #
+    # For HTTP 301, 302, and 303, the original request is transformed into a
+    # GET request to the response Location, by default. However, with standards
+    # compliance enabled, a 302 will instead act in accordance with the HTTP
+    # specification, which will replay the original request to the received
+    # Location, just as with a 307.
+    #
+    # For HTTP 307, the original request is replayed to the response Location,
+    # including original HTTP request method (GET, POST, PUT, DELETE, PATCH),
+    # original headers, and original body.
+    #
+    # This middleware currently only works with synchronous requests; in other
+    # words, it doesn't support parallelism.
+    class FollowRedirects < Faraday::Middleware
+      include Ridley::Logging
+
+      # HTTP methods for which 30x redirects can be followed
+      ALLOWED_METHODS = Set.new [:head, :options, :get, :post, :put, :patch, :delete]
+      # HTTP redirect status codes that this middleware implements
+      REDIRECT_CODES  = Set.new [301, 302, 303, 307]
+      # Keys in env hash which will get cleared between requests
+      ENV_TO_CLEAR    = Set.new [:status, :response, :response_headers]
+
+      # Default value for max redirects followed
+      FOLLOW_LIMIT = 3
+
+      # Public: Initialize the middleware.
+      #
+      # options - An options Hash (default: {}):
+      #           limit - A Numeric redirect limit (default: 3)
+      #           standards_compliant - A Boolean indicating whether to respect
+      #                                 the HTTP spec when following 302
+      #                                 (default: false)
+      #          cookie - Use either an array of strings
+      #                  (e.g. ['cookie1', 'cookie2']) to choose kept cookies
+      #                  or :all to keep all cookies.
+      def initialize(app, options = {})
+        super(app)
+        @options = options
+
+        @replay_request_codes = Set.new [307]
+        @replay_request_codes << 302 if standards_compliant?
+      end
+
+      def call(env)
+        perform_with_redirection(env, follow_limit)
+      end
+
+      private
+
+        def perform_with_redirection(env, follows)
+          request_body = env[:body]
+          response = @app.call(env)
+
+          response.on_complete do |env|
+            if follow_redirect?(env, response)
+              log.debug { "==> request redirected to #{response['location']}" }
+              log.debug { "request env: #{env}" }
+              
+              if follows.zero?
+                log.debug { "==> too many redirects" }
+                raise Ridley::Errors::RedirectLimitReached, response
+              end
+
+              env = update_env(env, request_body, response)
+              response = perform_with_redirection(env, follows - 1)
+            end
+          end
+          response
+        end
+
+        def update_env(env, request_body, response)
+          env[:url] += response['location']
+          if @options[:cookies]
+            cookies = keep_cookies(env)
+            env[:request_headers][:cookies] = cookies unless cookies.nil?
+          end
+
+          env[:body] = request_body
+
+          ENV_TO_CLEAR.each {|key| env.delete key }
+
+          env
+        end
+
+        def follow_redirect?(env, response)
+          ALLOWED_METHODS.include? env[:method] and
+            REDIRECT_CODES.include? response.status
+        end
+
+        def follow_limit
+          @options.fetch(:limit, FOLLOW_LIMIT)
+        end
+
+        def keep_cookies(env)
+          cookies = @options.fetch(:cookies, [])
+          response_cookies = env[:response_headers][:cookies]
+          cookies == :all ? response_cookies : selected_request_cookies(response_cookies)
+        end
+
+        def selected_request_cookies(cookies)
+          selected_cookies(cookies)[0...-1]
+        end
+
+        def selected_cookies(cookies)
+          "".tap do |cookie_string|
+            @options[:cookies].each do |cookie|
+              string = /#{cookie}=?[^;]*/.match(cookies)[0] + ';'
+              cookie_string << string
+            end
+          end
+        end
+
+        def standards_compliant?
+          @options.fetch(:standards_compliant, false)
+        end
+    end
+  end
+end

data/lib/ridley/sandbox_uploader.rb

@@ -109,10 +109,16 @@ module Ridley
       upload_path = url.path
       url.path    = ""
 
-      Faraday.new(url, client.options.slice(*Connection::VALID_OPTIONS)) do |c|
-        c.request :chef_auth, client.client_name, client.client_key
-        c.adapter :net_http
-      end.put(upload_path, contents, headers)
+      begin
+        Faraday.new(url, client.options.slice(*Connection::VALID_OPTIONS)) do |c|
+          c.response :chef_response
+          c.response :follow_redirects
+          c.request :chef_auth, client.client_name, client.client_key
+          c.adapter :net_http
+        end.put(upload_path, contents, headers)
+      rescue Ridley::Errors::HTTPError => ex
+        abort(ex)
+      end
     end
   end
 end

data/lib/ridley/version.rb

@@ -1,3 +1,3 @@
 module Ridley
-  VERSION = "0.8.1"
+  VERSION = "0.8.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ridley
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-01 00:00:00.000000000 Z
+date: 2013-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -300,6 +300,7 @@ files:
 - lib/ridley/middleware.rb
 - lib/ridley/middleware/chef_auth.rb
 - lib/ridley/middleware/chef_response.rb
+- lib/ridley/middleware/follow_redirects.rb
 - lib/ridley/middleware/parse_json.rb
 - lib/ridley/middleware/retry.rb
 - lib/ridley/mixin.rb
@@ -400,7 +401,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2528594805736736498
+      hash: -4124005785219237787
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24