songkick-transport 0.1.0

data/lib/songkick/transport.rb

@@ -0,0 +1,83 @@
+require 'forwardable'
+require 'net/http'
+require 'net/http/post/multipart'
+require 'uri'
+require 'yajl'
+
+module Songkick
+  module Transport
+    DEFAULT_TIMEOUT = 5
+    DEFAULT_FORMAT  = :json
+    
+    HTTP_VERBS = %w[get post put delete head]
+    USE_BODY   = %w[post put]
+    
+    ROOT = File.expand_path('..', __FILE__)
+    
+    autoload :Serialization,    ROOT + '/transport/serialization'
+    autoload :Base,             ROOT + '/transport/base'
+    autoload :Curb,             ROOT + '/transport/curb'
+    autoload :Headers,          ROOT + '/transport/headers'
+    autoload :HeaderDecorator,  ROOT + '/transport/header_decorator'
+    autoload :HttParty,         ROOT + '/transport/httparty'
+    autoload :RackTest,         ROOT + '/transport/rack_test'
+    autoload :Reporting,        ROOT + '/transport/reporting'
+    autoload :Request,          ROOT + '/transport/request'
+    autoload :Response,         ROOT + '/transport/response'
+    autoload :TimeoutDecorator, ROOT + '/transport/timeout_decorator'
+
+    autoload :UpstreamError,        ROOT + '/transport/upstream_error'
+    autoload :HostResolutionError,  ROOT + '/transport/upstream_error'
+    autoload :TimeoutError,         ROOT + '/transport/upstream_error'
+    autoload :ConnectionFailedError,ROOT + '/transport/upstream_error'
+    autoload :InvalidJSONError,     ROOT + '/transport/upstream_error'
+    autoload :HttpError,            ROOT + '/transport/http_error'
+    
+    IO = UploadIO
+    
+    def self.io(object)
+      if Hash === object and [:tempfile, :type, :filename].all? { |k| object.has_key? k } # Rack upload
+        Transport::IO.new(object[:tempfile], object[:type], object[:filename])
+        
+      elsif object.respond_to?(:content_type) and object.respond_to?(:original_filename) # Rails upload
+        Transport::IO.new(object, object.content_type, object.original_filename)
+        
+      else
+        raise ArgumentError, "Could not generate a Transport::IO from #{object.inspect}"
+      end
+    end
+    
+    def self.logger
+      @logger ||= begin
+                    require 'logger'
+                    Logger.new(STDOUT)
+                  end
+    end
+    
+    def self.logger=(logger)
+      @logger = logger
+    end
+    
+    def self.verbose=(verbose)
+      @verbose = verbose
+    end
+    
+    def self.verbose?
+      @verbose
+    end
+    
+    def self.report
+      Reporting.report
+    end
+    
+    def self.sanitize(*params)
+      sanitized_params.concat(params)
+    end
+    
+    def self.sanitized_params
+      @sanitized_params ||= []
+    end
+    
+  end
+end
+

data/lib/songkick/transport/base.rb

@@ -0,0 +1,53 @@
+module Songkick
+  module Transport
+    
+    class Base
+      attr_accessor :user_agent
+      
+      HTTP_VERBS.each do |verb|
+        class_eval %{
+          def #{verb}(path, params = {}, head = {}, timeout = nil)
+            req = Request.new(endpoint, '#{verb}', path, params, headers.merge(head), timeout)
+            Reporting.log_request(req)
+            
+            response = execute_request(req)
+            
+            Reporting.log_response(response, req)
+            Reporting.record(req, response)
+            response
+          rescue => error
+            Reporting.record(req, nil, error)
+            raise error
+          end
+        }
+      end
+      
+      def with_headers(headers = {})
+        HeaderDecorator.new(self, headers)
+      end
+      
+      def with_timeout(timeout = DEFAULT_TIMEOUT)
+        TimeoutDecorator.new(self, timeout)
+      end
+      
+    private
+      
+      def process(url, status, headers, body)
+        Response.process(url, status, headers, body)
+      end
+      
+      def headers
+        {
+          'Connection' => 'close',
+          'User-Agent' => user_agent || ''
+        }
+      end
+      
+      def logger
+        Transport.logger
+      end
+    end
+    
+  end
+end
+

data/lib/songkick/transport/curb.rb

@@ -0,0 +1,76 @@
+require 'cgi'
+require 'curb'
+
+module Songkick
+  module Transport
+
+    class Curb < Base
+      def self.clear_thread_connection
+         Thread.current[:transport_curb_easy] = nil
+      end
+      
+      def initialize(host, options = {})
+        @host       = host
+        @timeout    = options[:timeout] || DEFAULT_TIMEOUT
+        @user_agent = options[:user_agent]
+        if c = options[:connection]
+          Thread.current[:transport_curb_easy] = c
+        end
+      end
+      
+      def connection
+        Thread.current[:transport_curb_easy] ||= Curl::Easy.new
+      end
+      
+      def endpoint
+        @host
+      end
+      
+      def execute_request(req)
+        connection.reset
+        
+        connection.url = req.url
+        connection.timeout = req.timeout || @timeout
+        connection.headers.update(req.headers)
+        
+        response_headers = {}
+        
+        connection.on_header do |header_line|
+          line = header_line.sub(/\r\n$/, '')
+          parts = line.split(/:\s*/)
+          if parts.size >= 2
+            response_headers[parts.shift] = parts * ':'
+          end
+          header_line.bytesize
+        end
+        
+        if req.use_body?
+          connection.headers['Content-Type'] = req.content_type
+          connection.__send__("http_#{req.verb}", req.body)
+        else
+          connection.__send__("http_#{req.verb}")
+        end
+
+        process(req, connection.response_code, response_headers, connection.body_str)
+
+      rescue Curl::Err::HostResolutionError => error
+        logger.warn "Could not resolve host: #{@host}"
+        raise Transport::HostResolutionError, req
+
+      rescue Curl::Err::ConnectionFailedError => error
+        logger.warn "Could not connect to host: #{@host}"
+        raise Transport::ConnectionFailedError, req
+
+      rescue Curl::Err::TimeoutError => error
+        logger.warn "Request timed out after #{@timeout}s : #{req}"
+        raise Transport::TimeoutError, req
+
+      rescue Curl::Err::GotNothingError => error
+        logger.warn "Got nothing: #{req}"
+        raise Transport::UpstreamError, req
+      end
+    end
+
+  end
+end
+

data/lib/songkick/transport/header_decorator.rb

@@ -0,0 +1,27 @@
+module Songkick
+  module Transport
+    
+    class HeaderDecorator
+      def initialize(client, headers)
+        @client  = client
+        @headers = Headers.new(headers)
+      end
+      
+      HTTP_VERBS.each do |verb|
+        class_eval %{
+          def #{verb}(path, params = {}, headers = {}, timeout = nil)
+            @client.__send__(:#{verb}, path, params, @headers.merge(headers), timeout)
+          end
+        }
+      end
+    
+    private
+      
+      def method_missing(*args, &block)
+        @client.__send__(*args, &block)
+      end
+    end
+    
+  end
+end
+

data/lib/songkick/transport/headers.rb

@@ -0,0 +1,36 @@
+module Songkick
+  module Transport
+    
+    class Headers
+      include Enumerable
+      
+      def initialize(hash = {})
+        @hash = {}
+        hash.each do |key, value|
+          @hash[self.class.normalize(key)] = value
+        end
+      end
+      
+      def each(&block)
+        @hash.each(&block)
+      end
+      
+      def [](header_name)
+        @hash[self.class.normalize(header_name)]
+      end
+      
+      def merge(hash)
+        @hash.merge(hash)
+      end
+      
+      def self.normalize(header_name)
+        header_name.
+            gsub(/^HTTP_/, '').gsub('_', '-').
+            downcase.
+            gsub(/(^|-)([a-z])/) { $1 + $2.upcase }
+      end
+    end
+    
+  end
+end
+

data/lib/songkick/transport/http_error.rb

@@ -0,0 +1,24 @@
+module Songkick
+  module Transport
+    class HttpError < UpstreamError
+      attr_reader :request, :data, :headers, :status
+      
+      def initialize(request, status, headers, body)
+        @request = request
+
+        @data = if body.is_a?(String)
+                  body.strip == '' ? nil : (Yajl::Parser.parse(body) rescue body)
+                else
+                  body
+                end
+
+        @headers = Headers.new(headers)
+        @status  = status.to_i
+      end
+
+      def message
+       "#{self.class}: status code: #{@status} from: #{@request}"
+      end
+    end
+  end
+end

data/lib/songkick/transport/httparty.rb

@@ -0,0 +1,66 @@
+require 'httparty'
+
+module Songkick
+  module Transport
+    
+    class HttParty
+      def self.new(host, options = {})
+        klass = options[:adapter] || Class.new(Adapter)
+        klass.base_uri(host)
+        klass.default_timeout(options[:timeout] || DEFAULT_TIMEOUT)
+        klass.format(options[:format] || DEFAULT_FORMAT)
+        
+        transport = klass.new
+        transport.user_agent = options[:user_agent]
+        transport
+      end
+      
+      class Adapter < Base
+        include HTTParty
+        
+        def endpoint
+          self.class.base_uri
+        end
+        
+        def execute_request(req)
+          timeout = req.timeout || self.class.default_options[:timeout]
+          
+          response = if req.use_body?
+            if req.multipart?
+              head = req.headers.merge('Content-Type' => req.content_type)
+              self.class.__send__(req.verb, req.path, :body => req.body, :headers => head, :timeout => timeout)
+            else
+              self.class.__send__(req.verb, req.path, :body => req.body, :headers => req.headers, :timeout => timeout)
+            end
+          else
+            self.class.__send__(req.verb, req.url, :headers => req.headers, :timeout => timeout)
+          end
+          
+          process(req, response.code, response.headers, response.parsed_response)
+        
+        rescue SocketError => error
+          logger.warn "Could not connect to host: #{self.class.base_uri}"
+          raise ConnectionFailedError, req
+        
+        rescue Timeout::Error => error
+          logger.warn "Request timed out: #{req}"
+          raise Transport::TimeoutError, req
+
+        rescue UpstreamError => error
+          raise error
+        
+        rescue Object => error
+          if error.class.name =~ /json/i or error.message =~ /json/i
+            logger.warn("Request returned invalid JSON: #{req}")
+            raise Transport::InvalidJSONError, req
+          else
+            logger.warn("Error trying to call #{req}: #{error.class}: #{error.message}")
+            raise UpstreamError, req
+          end
+        end
+      end
+    end
+    
+  end
+end
+

data/lib/songkick/transport/rack_test.rb

@@ -0,0 +1,52 @@
+require 'rack/test'
+require 'timeout'
+
+module Songkick
+  module Transport
+    
+    class RackTest < Base
+      class Client
+        attr_reader :app
+        include Rack::Test::Methods
+        
+        def initialize(app)
+          @app = app
+        end
+      end
+      
+      def initialize(app, options = {})
+        @app     = app
+        @timeout = options[:timeout] || DEFAULT_TIMEOUT
+      end
+      
+      HTTP_VERBS.each do |verb|
+        class_eval %{
+          def #{verb}(path, params = {}, head = {}, timeout = nil)
+            client  = Client.new(@app)
+            start   = Time.now
+            request = Request.new(@app, '#{verb}', path, params, headers.merge(head), timeout, start)
+            result  = nil
+            
+            Timeout.timeout(timeout || @timeout) do
+              request.headers.each { |key, value| client.header(key, value) }
+              response = client.#{verb}(path, params)
+              result = process("\#{path}, \#{params.inspect}", response.status, response.headers, response.body)
+              Reporting.record(request, result)
+              result
+            end
+
+          rescue UpstreamError => error
+            Reporting.record(request, nil, error)
+            raise error
+          
+          rescue Object => error
+            logger.warn(error.message)
+            raise UpstreamError, request
+          end
+        }
+      end
+    end
+    
+  end
+end
+

data/lib/songkick/transport/reporting.rb

@@ -0,0 +1,60 @@
+module Songkick
+  module Transport
+    
+    module Reporting
+      def self.report
+        Report.new
+      end
+      
+      def self.record(request, response, error = nil)
+        return unless report = Thread.current[:songkick_transport_report]
+        report.record(request, response, error)
+      end
+      
+      def self.log_request(request)
+        return unless Transport.verbose?
+        logger.info(request.to_s)
+      end
+      
+      def self.log_response(response, request)
+        return unless Transport.verbose?
+        duration = (Time.now.to_f - request.start_time.to_f) * 1000
+        logger.info "Response status: #{response.status}, duration: #{duration.ceil}ms"
+        logger.debug "Response data: #{response.data.inspect}"
+      end
+      
+      def self.logger
+        Transport.logger
+      end
+      
+      class Report
+        include Enumerable
+        extend Forwardable
+        def_delegators :@requests, :each, :first, :last, :length, :size, :[]
+        
+        def initialize
+          @requests = []
+        end
+        
+        def execute
+          Thread.current[:songkick_transport_report] = self
+          yield
+        ensure
+          Thread.current[:songkick_transport_report] = nil
+        end
+        
+        def record(request, response, error)
+          request.response = response
+          request.error = error
+          @requests << request
+        end
+        
+        def total_duration
+          inject(0) { |s,r| s + r.duration }
+        end
+      end
+    end
+    
+  end
+end
+