rest-man 1.0.0 → 1.1.0

data/lib/restman/request/init.rb

@@ -0,0 +1,106 @@
+require 'cgi'
+require 'netrc'
+
+module RestMan
+  class Request
+    module Init
+
+      autoload :Url, 'restman/request/init/url'
+      autoload :CookieJar, 'restman/request/init/cookie_jar'
+      autoload :SSLOpts, 'restman/request/init/ssl_opts'
+
+      include ActiveMethod
+
+      module_function
+
+      # :include: _doc/lib/restman/request/init/http_method.rdoc
+      def http_method(args)
+        method = args[:method]
+        raise ArgumentError.new('must pass :method') unless method
+
+        method.to_s.downcase
+      end
+
+      def headers(args)
+        (args[:headers] || {}).dup
+      end
+
+      active_method :url, module_function: true
+
+      def uri(url)
+        uri = URI.parse(url)
+
+        if uri.hostname.nil? || uri.hostname == ''
+          raise URI::InvalidURIError.new("bad URI(no host provided): #{url}")
+        end
+
+        uri
+      end
+
+      def auth(uri, args)
+        user = CGI.unescape(uri.user) if uri.user
+        password = CGI.unescape(uri.password) if uri.password
+
+        if !user && !password
+          user, password = Netrc.read[uri.hostname]
+        end
+
+        user = args[:user] if args.include?(:user)
+        password = args[:password] if args.include?(:password)
+
+        [user, password]
+      end
+
+      active_method :cookie_jar, module_function: true
+
+      def read_timeout(args)
+        if args.key?(:read_timeout)
+          yield args[:read_timeout] 
+        elsif args.key?(:timeout)
+          yield args[:timeout]
+        else
+          60
+        end
+      end
+
+      def write_timeout(args)
+        if args.key?(:write_timeout)
+          yield args[:write_timeout] 
+        elsif args.key?(:timeout)
+          yield args[:timeout]
+        else
+          60
+        end
+      end
+
+      def open_timeout(args)
+        if args.key?(:open_timeout)
+          yield args[:open_timeout] 
+        elsif args.key?(:timeout)
+          yield args[:timeout]
+        else
+          60
+        end
+      end
+
+      def keep_alive_timeout(args)
+        if args.key?(:keep_alive_timeout)
+          yield args[:keep_alive_timeout] 
+        else
+          2
+        end
+      end
+
+      def stream_log_percent(args)
+        percent = args[:stream_log_percent] || 10
+        if percent <= 0 || percent > 100
+          raise ArgumentError.new("Invalid :stream_log_percent #{@stream_log_percent.inspect}")
+        end
+        percent
+      end
+
+      active_method :ssl_opts, SSLOpts, module_function: true
+
+    end
+  end
+end

data/lib/restman/request/log_request.rb

@@ -0,0 +1,46 @@
+module RestMan
+  class Request
+    class LogRequest < ActiveMethod::Base
+
+      def call
+        return unless log
+
+        out = []
+
+        out << "RestMan.#{request.method} #{redacted_url.inspect}"
+        out << payload.short_inspect if payload
+        out << request.processed_headers.to_a.sort.map { |(k, v)| [k.inspect, v.inspect].join("=>") }.join(", ")
+        log << out.join(', ') + "\n"
+      end
+
+      private
+
+      def log
+        request.log
+      end
+
+      def redacted_uri
+        if uri.password
+          sanitized_uri = uri.dup
+          sanitized_uri.password = 'REDACTED'
+          sanitized_uri
+        else
+          uri
+        end
+      end
+
+      def redacted_url
+        redacted_uri.to_s
+      end
+
+      def payload
+        request.payload
+      end
+
+      def uri
+        request.uri
+      end
+
+    end
+  end
+end

data/lib/restman/request/make_cookie_header.rb

@@ -0,0 +1,16 @@
+module RestMan
+  class Request
+    class MakeCookieHeader < ActiveMethod::Base
+
+      def call
+        return nil if request.cookie_jar.nil?
+
+        arr = request.cookie_jar.cookies(request.url)
+        return nil if arr.empty?
+
+        return HTTP::Cookie.cookie_value(arr)
+      end
+
+    end
+  end
+end

data/lib/restman/request/make_headers.rb

@@ -0,0 +1,39 @@
+module RestMan
+  class Request
+    class MakeHeaders < ActiveMethod::Base
+
+      argument :user_headers
+
+      def call
+        headers = StringifyHeaders.call(default_headers).merge(StringifyHeaders.call(user_headers))
+
+        # override headers from the payload (e.g. Content-Type, Content-Length)
+        if payload
+          headers = payload.headers.merge(headers)
+        end
+
+        # merge in cookies
+        cookies = request.make_cookie_header
+        if cookies && !cookies.empty?
+          if headers['Cookie']
+            warn('warning: overriding "Cookie" header with :cookies option')
+          end
+          headers['Cookie'] = cookies
+        end
+
+        headers
+      end
+
+      private
+
+      def default_headers
+        request.default_headers
+      end
+
+      def payload
+        request.payload
+      end
+
+    end
+  end
+end

data/lib/restman/request/maybe_convert_extension.rb

@@ -0,0 +1,28 @@
+module RestMan
+  class Request
+    class MaybeConvertExtension < ActiveMethod::Base
+
+      argument :ext
+
+      def call
+        unless ext =~ /\A[a-zA-Z0-9_@-]+\z/
+          # Don't look up strings unless they look like they could be a file
+          # extension known to mime-types.
+          #
+          # There currently isn't any API public way to look up extensions
+          # directly out of MIME::Types, but the type_for() method only strips
+          # off after a period anyway.
+          return ext
+        end
+
+        types = MIME::Types.type_for(ext)
+        if types.empty?
+          ext
+        else
+          types.first.content_type
+        end
+      end
+
+    end
+  end
+end

data/lib/restman/request/net_http_object.rb

@@ -0,0 +1,25 @@
+module RestMan
+  class Request
+    class NetHTTPObject < ActiveMethod::Base
+
+      argument :hostname
+      argument :port
+
+      def call
+        p_uri = request.proxy_uri
+
+        if p_uri.nil?
+          # no proxy set
+          Net::HTTP.new(hostname, port)
+        elsif !p_uri
+          # proxy explicitly set to none
+          Net::HTTP.new(hostname, port, nil, nil, nil, nil)
+        else
+          Net::HTTP.new(hostname, port,
+                        p_uri.hostname, p_uri.port, p_uri.user, p_uri.password)
+        end
+      end
+
+    end
+  end
+end

data/lib/restman/request/process_result.rb

@@ -0,0 +1,36 @@
+module RestMan
+  class Request
+    class ProcessResult < ActiveMethod::Base
+
+      argument :res
+      argument :start_time 
+      argument :tempfile, default: nil
+
+      def call(&block)
+        if raw_response
+          unless tempfile
+            raise ArgumentError.new('tempfile is required')
+          end
+          response = RawResponse.new(tempfile, res, request, start_time)
+        else
+          response = Response.create(res.body, res, request, start_time)
+        end
+
+        response.log_response
+
+        if block_given?
+          block.call(response, request, res, & block)
+        else
+          response.return!(&block)
+        end
+      end
+
+      private
+
+      def raw_response
+        request.raw_response
+      end
+
+    end
+  end
+end

data/lib/restman/request/proxy_uri.rb

@@ -0,0 +1,31 @@
+module RestMan
+  class Request
+    class ProxyURI < ActiveMethod::Base
+
+      def call
+        if request.instance_variable_defined?(:@proxy)
+          if request.proxy
+            URI.parse(request.proxy)
+          else
+            false
+          end
+        elsif RestMan.proxy_set?
+          if RestMan.proxy
+            URI.parse(RestMan.proxy)
+          else
+            false
+          end
+        else
+          nil
+        end
+      end
+
+      private
+
+      def proxy
+        request.proxy
+      end
+
+    end
+  end
+end

data/lib/restman/request/stringify_headers.rb

@@ -0,0 +1,36 @@
+module RestMan
+  class Request
+    class StringifyHeaders < ActiveMethod::Base
+
+      argument :headers
+
+      def call
+        headers.inject({}) do |result, (key, value)|
+
+          if key.is_a? Symbol
+            key = key.to_s.split(/_/).map(&:capitalize).join('-')
+          end
+
+          if 'CONTENT-TYPE' == key.upcase
+            result[key] = MaybeConvertExtension.call(value.to_s)
+          elsif 'ACCEPT' == key.upcase
+            # Accept can be composed of several comma-separated values
+            if value.is_a? Array
+              target_values = value
+            else
+              target_values = value.to_s.split ','
+            end
+            result[key] = target_values.map { |ext|
+              MaybeConvertExtension.call(ext.to_s.strip)
+            }.join(', ')
+          else
+            result[key] = value.to_s
+          end
+
+          result
+        end
+      end
+
+    end
+  end
+end

data/lib/restman/request/transmit.rb

@@ -0,0 +1,152 @@
+module RestMan
+  class Request
+    class Transmit < ActiveMethod::Base
+
+      argument :uri
+      argument :req
+      argument :payload
+
+      def call
+        # We set this to true in the net/http block so that we can distinguish
+        # read_timeout from open_timeout. Now that we only support Ruby 2.0+,
+        # this is only needed for Timeout exceptions thrown outside of Net::HTTP.
+        established_connection = false
+
+        request.setup_credentials req
+
+        net = request.net_http_object(uri.hostname, uri.port)
+        net.use_ssl = uri.is_a?(URI::HTTPS)
+        net.ssl_version = request.ssl_version if request.ssl_version
+        net.min_version = request.ssl_min_version if request.ssl_min_version
+        net.max_version = request.ssl_max_version if request.ssl_max_version
+        net.ssl_timeout = request.ssl_timeout if request.ssl_timeout
+        net.ciphers = request.ssl_ciphers if request.ssl_ciphers
+
+        net.verify_mode = request.verify_ssl
+
+        net.cert = request.ssl_client_cert if request.ssl_client_cert
+        net.key = request.ssl_client_key if request.ssl_client_key
+        net.ca_file = request.ssl_ca_file if request.ssl_ca_file
+        net.ca_path = request.ssl_ca_path if request.ssl_ca_path
+        net.cert_store = request.ssl_cert_store if request.ssl_cert_store
+
+        net.max_retries = request.max_retries
+
+        net.keep_alive_timeout = request.keep_alive_timeout if request.keep_alive_timeout
+        net.close_on_empty_response = request.close_on_empty_response if request.close_on_empty_response
+        net.local_host = request.local_host if request.local_host
+        net.local_port = request.local_port if request.local_port
+
+        # We no longer rely on net.verify_callback for the main SSL verification
+        # because it's not well supported on all platforms (see comments below).
+        # But do allow users to set one if they want.
+        if request.ssl_verify_callback
+          net.verify_callback = request.ssl_verify_callback
+
+          # Hilariously, jruby only calls the callback when cert_store is set to
+          # something, so make sure to set one.
+          # https://github.com/jruby/jruby/issues/597
+          if RestMan::Platform.jruby?
+            net.cert_store ||= OpenSSL::X509::Store.new
+          end
+
+          if request.ssl_verify_callback_warnings != false
+            if print_verify_callback_warnings
+              warn('pass :ssl_verify_callback_warnings => false to silence this')
+            end
+          end
+        end
+
+        if OpenSSL::SSL::VERIFY_PEER == OpenSSL::SSL::VERIFY_NONE
+          warn('WARNING: OpenSSL::SSL::VERIFY_PEER == OpenSSL::SSL::VERIFY_NONE')
+          warn('This dangerous monkey patch leaves you open to MITM attacks!')
+          warn('Try passing :verify_ssl => false instead.')
+        end
+
+        net.read_timeout = request.read_timeout
+        net.open_timeout = request.open_timeout
+        net.write_timeout = request.write_timeout
+
+        RestMan.before_execution_procs.each do |before_proc|
+          before_proc.call(req, request.args)
+        end
+
+        if request.before_execution_proc
+          request.before_execution_proc.call(req, request.args)
+        end
+
+        request.log_request
+
+        start_time = Time.now
+        tempfile = nil
+
+        net.start do |http|
+          established_connection = true
+
+          if request.block_response
+            net_http_do_request(http, req, payload, &request.block_response)
+          else
+            res = net_http_do_request(http, req, payload) { |http_response|
+              if request.raw_response
+                # fetch body into tempfile
+                tempfile = request.fetch_body_to_tempfile(http_response)
+              else
+                # fetch body
+                http_response.read_body
+              end
+              http_response
+            }
+            if block_given?
+              request.process_result(res, start_time, tempfile) do
+                yield
+              end
+            else
+              request.process_result(res, start_time, tempfile)
+            end
+          end
+        end
+      rescue EOFError
+        raise RestMan::ServerBrokeConnection
+      rescue Net::OpenTimeout => err
+        raise RestMan::Exceptions::OpenTimeout.new(nil, err)
+      rescue Net::ReadTimeout => err
+        raise RestMan::Exceptions::ReadTimeout.new(nil, err)
+      rescue Net::WriteTimeout => err
+        raise RestMan::Exceptions::WriteTimeout.new(nil, err)
+      rescue Timeout::Error, Errno::ETIMEDOUT => err
+        # handling for non-Net::HTTP timeouts
+        if established_connection
+          raise RestMan::Exceptions::ReadTimeout.new(nil, err)
+        else
+          raise RestMan::Exceptions::OpenTimeout.new(nil, err)
+        end
+      end
+
+      private
+
+      def print_verify_callback_warnings
+        warned = false
+        if RestMan::Platform.mac_mri?
+          warn('warning: ssl_verify_callback return code is ignored on OS X')
+          warned = true
+        end
+        if RestMan::Platform.jruby?
+          warn('warning: SSL verify_callback may not work correctly in jruby')
+          warn('see https://github.com/jruby/jruby/issues/597')
+          warned = true
+        end
+        warned
+      end
+
+      def net_http_do_request(http, req, body=nil, &block)
+        if body && body.respond_to?(:read)
+          req.body_stream = body
+          return http.request(req, nil, &block)
+        else
+          return http.request(req, body, &block)
+        end
+      end
+
+    end
+  end
+end