puffing-billy 0.2.3 → 0.3.0

data/lib/billy/handlers/request_handler.rb

@@ -0,0 +1,59 @@
+module Billy
+  class RequestHandler
+    extend Forwardable
+    include Handler
+
+    def_delegators :stub_handler, :stub
+
+    def handlers
+      @handlers ||= { :stubs => StubHandler.new,
+                      :cache => CacheHandler.new,
+                      :proxy => ProxyHandler.new }
+    end
+
+    def handle_request(method, url, headers, body)
+      # Process the handlers by order of importance
+      [:stubs, :cache, :proxy].each do |key|
+        if (response = handlers[key].handle_request(method, url, headers, body))
+          return response
+        end
+      end
+
+      body_msg = method == 'post' ? " with body '#{body}'" : ''
+      { :error => "Connection to #{url}#{body_msg} not cached and new http connections are disabled" }
+    end
+
+    def handles_request?(method, url, headers, body)
+      [:stubs, :cache, :proxy].each do |key|
+        return true if handlers[key].handles_request?(method, url, headers, body)
+      end
+
+      false
+    end
+
+    def reset
+      handlers.each_value do |handler|
+        handler.reset
+      end
+    end
+
+    def reset_stubs
+      handlers[:stubs].reset
+    end
+
+    def reset_cache
+      handlers[:cache].reset
+    end
+
+    def restore_cache
+      warn "[DEPRECATION] `restore_cache` is deprecated as cache files are dynamically checked. Use `reset_cache` if you just want to clear the cache."
+      reset_cache
+    end
+
+    private
+
+    def stub_handler
+      handlers[:stubs]
+    end
+  end
+end

data/lib/billy/handlers/stub_handler.rb

@@ -0,0 +1,48 @@
+require 'billy/handlers/handler'
+
+module Billy
+  class StubHandler
+    include Handler
+
+    def handle_request(method, url, headers, body)
+      if handles_request?(method, url, headers, body)
+        if (stub = find_stub(method, url))
+          query_string = URI.parse(url).query || ""
+          params = CGI.parse(query_string)
+          stub.call(params, headers, body).tap do |response|
+            Billy.log(:info, "puffing-billy: STUB #{method} for '#{url}'")
+            return { status: response[0], headers: response[1], content: response[2] }
+          end
+        end
+      end
+
+      nil
+    end
+
+    def handles_request?(method, url, headers, body)
+      !find_stub(method, url).nil?
+    end
+
+    def reset
+      self.stubs = []
+    end
+
+    def stub(url, options = {})
+      new_stub = ProxyRequestStub.new(url, options)
+      stubs.unshift new_stub
+      new_stub
+    end
+
+    private
+
+    attr_writer :stubs
+
+    def stubs
+      @stubs ||= []
+    end
+
+    def find_stub(method, url)
+      stubs.find { |stub| stub.matches?(method, url) }
+    end
+  end
+end

data/lib/billy/proxy.rb

@@ -4,11 +4,14 @@ require 'eventmachine'
 
 module Billy
   class Proxy
-    attr_reader :cache
+    extend Forwardable
+    attr_reader :request_handler
+
+    def_delegators :request_handler, :stub, :reset, :reset_cache, :restore_cache, :handle_request
 
     def initialize
+      @request_handler = Billy::RequestHandler.new
       reset
-      @cache = Billy::Cache.new
     end
 
     def start(threaded = true)
@@ -32,49 +35,21 @@ module Billy
       Socket.unpack_sockaddr_in(EM.get_sockname(@signature)).first
     end
 
-    def call(method, url, headers, body)
-      stub = find_stub(method, url)
-      unless stub.nil?
-        query_string = URI.parse(url).query || ""
-        params = CGI.parse(query_string)
-        stub.call(params, headers, body)
-      end
-    end
-
-    def stub(url, options = {})
-      ret = ProxyRequestStub.new(url, options)
-      @stubs.unshift ret
-      ret
-    end
-
-    def reset
-      @stubs = []
-    end
-
-    def reset_cache
-      @cache.reset
-    end
-
-    def restore_cache
-      warn "[DEPRECATION] `restore_cache` is deprecated as cache files are dynamincally checked. Use `reset_cache` if you just want to clear the cache."
-      @cache.reset
+    def cache
+      Billy::Cache.instance
     end
 
     protected
 
-    def find_stub(method, url)
-      @stubs.find {|stub| stub.matches?(method, url) }
-    end
-
     def main_loop
       EM.run do
         EM.error_handler do |e|
-          puts e.class.name, e
-          puts e.backtrace.join("\n")
+          Billy.log :error, "#{e.class} (#{e.message}):"
+          Billy.log :error, e.backtrace.join("\n")
         end
 
-        @signature = EM.start_server('127.0.0.1', 0, ProxyConnection) do |p|
-          p.handler = self
+        @signature = EM.start_server('127.0.0.1', Billy.config.proxy_port, ProxyConnection) do |p|
+          p.handler = request_handler
           p.cache = @cache
         end
 

data/lib/billy/proxy_connection.rb

@@ -3,6 +3,7 @@ require 'eventmachine'
 require 'http/parser'
 require 'em-http'
 require 'evma_httpserver'
+require 'em-synchrony'
 
 module Billy
   class ProxyConnection < EventMachine::Connection
@@ -11,23 +12,10 @@ module Billy
 
     def post_init
       @parser = Http::Parser.new(self)
-      @header_data = ""
     end
 
     def receive_data(data)
-      @header_data << data if @headers.nil?
-      begin
-        @parser << data
-      rescue HTTP::Parser::Error
-        if @parser.http_method == 'CONNECT'
-          # work-around for CONNECT requests until https://github.com/tmm1/http_parser.rb/pull/15 gets merged
-          if @header_data.end_with?("\r\n\r\n")
-            restart_with_ssl(@header_data.split("\r\n").first.split(/\s+/)[1])
-          end
-        else
-          close_connection
-        end
-      end
+      @parser << data
     end
 
     def on_message_begin
@@ -48,7 +36,8 @@ module Billy
         restart_with_ssl(@parser.request_url)
       else
         if @ssl
-          @url = "https://#{@ssl}#{@parser.request_url}"
+          uri = URI.parse(@parser.request_url)
+          @url = "https://#{@ssl}#{[uri.path,uri.query].compact.join('?')}"
         else
           @url = @parser.request_url
         end
@@ -69,137 +58,26 @@ module Billy
     end
 
     def handle_request
-      if handler && handler.respond_to?(:call)
-        result = handler.call(@parser.http_method, @url, @headers, @body)
-      end
-
-      if result
-        Billy.log(:info, "puffing-billy: STUB #{@parser.http_method} for '#{@url}'")
-        stub_request(result)
-      elsif cache.cached?(@parser.http_method.downcase, @url, @body)
-        Billy.log(:info, "puffing-billy: CACHE #{@parser.http_method} for '#{@url}'")
-        respond_from_cache
-      elsif !disabled_request?
-        Billy.log(:info, "puffing-billy: PROXY #{@parser.http_method} for '#{@url}'")
-        proxy_request
-      else
-        close_connection
-        body_msg = @parser.http_method == 'post' ? " with body '#{@body}'" : ''
-        raise "puffing-billy: Connection to #{@url}#{body_msg} not cached and new http connections are disabled"
+      EM.synchrony do
+        handler.handle_request(@parser.http_method, @url, @headers, @body).tap do |response|
+          if response.has_key?(:error)
+            close_connection
+            raise "puffing-billy: #{response[:error]}"
+          else
+            send_response(response)
+          end
+        end
       end
     end
 
-    def stub_request(result)
-      response = EM::DelegatedHttpResponse.new(self)
-      response.status  = result[0]
-      response.headers = result[1].merge('Connection' => 'close')
-      response.content = result[2]
-      response.send_response
-    end
+    private
 
-    def respond_from_cache
-      cached_res = cache.fetch(@parser.http_method.downcase, @url, @body)
+    def send_response(response)
       res = EM::DelegatedHttpResponse.new(self)
-      res.status = cached_res[:status]
-      res.headers = cached_res[:headers]
-      res.content = cached_res[:content]
+      res.status = response[:status]
+      res.headers = response[:headers]
+      res.content = response[:content]
       res.send_response
     end
-
-    def proxy_request
-      headers = Hash[@headers.map { |k,v| [k.downcase, v] }]
-      headers.delete('accept-encoding')
-
-      req = EventMachine::HttpRequest.new(@url)
-      req_opts = {
-        :redirects => 0,
-        :keepalive => false,
-        :head => headers,
-        :ssl => { :verify => false }
-      }
-      req_opts[:body] = @body if @body
-
-      req = req.send(@parser.http_method.downcase, req_opts)
-
-      req.errback do
-        Billy.log(:error, "puffing-billy: Request failed: #{@url}")
-        close_connection
-      end
-
-      req.callback do
-        res_status = req.response_header.status
-        res_headers = req.response_header.raw
-        res_headers = res_headers.merge('Connection' => 'close')
-        res_headers.delete('Transfer-Encoding')
-        res_content = req.response.force_encoding('BINARY')
-
-        handle_response_code(res_status)
-
-        if cacheable?(res_headers, res_status)
-          cache.store(@parser.http_method.downcase, @url, headers, @body, res_headers, res_status, res_content)
-        end
-
-        res = EM::DelegatedHttpResponse.new(self)
-        res.status = res_status
-        res.headers = res_headers
-        res.content = res_content
-        res.send_response
-      end
-    end
-
-    def disabled_request?
-      url = URI(@url)
-      # In isolated environments, you may want to stop the request from happening
-      # or else you get "getaddrinfo: Name or service not known" errors
-      if Billy.config.non_whitelisted_requests_disabled
-        blacklisted_path?(url.path) || !whitelisted_url?(url)
-      end
-    end
-
-    def handle_response_code(status)
-      log_level = successful_status?(status) ? :info : Billy.config.non_successful_error_level
-      log_message = "puffing-billy: Received response status code #{status} for #{@url}"
-      Billy.log(log_level, log_message)
-      if log_level == :error
-        close_connection
-        raise log_message
-      end
-    end
-
-    def cacheable?(headers, status)
-      if Billy.config.cache
-        url = URI(@url)
-        # Cache the responses if they aren't whitelisted host[:port]s but always cache blacklisted paths on any hosts
-        cacheable_headers?(headers) && cacheable_status?(status) && (!whitelisted_url?(url) || blacklisted_path?(url.path))
-      end
-    end
-
- private
-
-    def whitelisted_host?(host)
-      Billy.config.whitelist.include?(host)
-    end
-
-    def whitelisted_url?(url)
-      whitelisted_host?(url.host) || whitelisted_host?("#{url.host}:#{url.port}")
-    end
-
-    def blacklisted_path?(path)
-      Billy.config.path_blacklist.index{|bl| path.include?(bl)}
-    end
-
-    def successful_status?(status)
-      (200..299).include?(status) || status == 304
-    end
-
-    def cacheable_headers?(headers)
-      #TODO: test headers for cacheability (ie. Cache-Control: no-cache)
-      true
-    end
-
-    def cacheable_status?(status)
-      Billy.config.non_successful_cache_disabled ? successful_status?(status) : true
-    end
-
   end
 end

data/lib/billy/version.rb

@@ -1,3 +1,3 @@
 module Billy
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/puffing-billy.gemspec

@@ -27,9 +27,10 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "pry"
   gem.add_development_dependency "cucumber"
   gem.add_runtime_dependency "eventmachine"
+  gem.add_runtime_dependency "em-synchrony"
   gem.add_runtime_dependency "em-http-request"
   gem.add_runtime_dependency "eventmachine_httpserver"
-  gem.add_runtime_dependency "http_parser.rb"
+  gem.add_runtime_dependency "http_parser.rb", "~> 0.6.0"
   gem.add_runtime_dependency "multi_json"
   gem.add_runtime_dependency "capybara"
 end

data/spec/features/examples/facebook_api_spec.rb

@@ -7,15 +7,14 @@ describe 'Facebook API example', :type => :feature, :js => true do
       # mock a signed request from facebook.  the JS api never verifies the
       # signature, so all it needs is the base64-encoded payload
       signed_request = "xxxxxxxxxx.#{Base64.encode64('{"user_id":"1234567"}')}"
-      # redirect to the 'redirect_uri', with some extra crap in the query
-      # string
+      # redirect to the 'redirect_uri', with some extra crap in the query string
       {:redirect_to => "#{params['redirect_uri'][0]}&access_token=foobar&expires_in=600&base_domain=localhost&https=1&signed_request=#{signed_request}"}
     })
 
     proxy.stub('https://graph.facebook.com:443/me').and_return(:jsonp => {:name => 'Tester 1'})
   end
 
-  it 'should show me as logged-in', :js => true do
+  it 'should show me as logged-in' do
     visit '/facebook_api.html'
     click_on "Login"
     expect(page).to have_content "Hi, Tester 1"

data/spec/features/examples/tumblr_api_spec.rb

@@ -19,7 +19,7 @@ describe 'Tumblr API example', :type => :feature, :js => true do
     })
   end
 
-  it 'should show news stories', :js => true do
+  it 'should show news stories' do
     visit '/tumblr_api.html'
     expect(page).to have_link('News Item 1', :href => 'http://example.com/news/1')
     expect(page).to have_content('News item 1 content here')

data/spec/lib/billy/cache_spec.rb

@@ -2,12 +2,14 @@ require 'spec_helper'
 
 describe Billy::Cache do
   describe 'format_url' do
-    let(:cache) { Billy::Cache.new }
+    let(:cache) { Billy::Cache.instance }
     let(:params) { '?foo=bar' }
+    let(:callback) { '&callback=quux' }
     let(:fragment) { '#baz' }
     let(:base_url) { 'http://example.com' }
     let(:fragment_url) { "#{base_url}/#{fragment}" }
     let(:params_url) { "#{base_url}#{params}" }
+    let(:params_url_with_callback) { "#{base_url}#{params}#{callback}" }
     let(:params_fragment_url) { "#{base_url}#{params}#{fragment}" }
 
     context 'with ignore_params set to false' do
@@ -20,6 +22,21 @@ describe Billy::Cache do
       it 'appends params and fragment if both are present' do
         expect(cache.format_url(params_fragment_url)).to eq params_fragment_url
       end
+      context "when dynamic_jsonp is true" do
+        it 'omits the callback param by default' do
+          expect(cache.format_url(params_url_with_callback, false, true)).to eq params_url
+        end
+
+        it 'omits the params listed in Billy.config.dynamic_jsonp_keys' do
+          allow(Billy.config).to receive(:dynamic_jsonp_keys) { ["foo"] }
+
+          expect(cache.format_url(params_url_with_callback, false, true)).to eq "#{base_url}?callback=quux"
+        end
+      end
+
+      it 'retains the callback param is dynamic_jsonp is false' do
+        expect(cache.format_url(params_url_with_callback)).to eq params_url_with_callback
+      end
     end
 
     context 'with ignore_params set to true' do