agile-proxy 0.1.0

data/lib/agile_proxy/model/recording.rb

@@ -0,0 +1,16 @@
+require_relative 'application'
+module AgileProxy
+  #
+  # = The recording model
+  #
+  # When an application is set to allow recording, every HTTP(s) request/response cycle coming through the proxy
+  # will create an instance of this model and persist it to the database.
+  #
+  # An API is then available to access this data via REST for the UI or test suite etc...
+  #
+  class Recording < ActiveRecord::Base
+    belongs_to :application
+    serialize :request_headers, JSON
+    serialize :response_headers, JSON
+  end
+end

data/lib/agile_proxy/model/request_spec.rb

@@ -0,0 +1,47 @@
+require_relative 'application'
+require_relative 'user'
+require_relative 'response'
+module AgileProxy
+  #
+  # = The Request Spec model
+  # The request spec is an input/output specification that incoming HTTP(s) requests are matched against.
+  #
+  # It uses the action dispatch router to do this matching,
+  # which is fed data from the database as it's input - i.e. its routing
+  # table is generated on the fly.
+  #
+  # This model is responsible not only for retrieving and persisting these
+  # request specifications, but also for creating the response
+  #
+  class RequestSpec < ActiveRecord::Base
+    belongs_to :application
+    belongs_to :user
+    belongs_to :response
+    accepts_nested_attributes_for :response
+    validates_inclusion_of :url_type, in: %w(url regex)
+    def initialize(attrs = {})
+      attrs[:http_method] = attrs.delete(:method) if attrs.key?(:method)
+      super
+    end
+    # The conditions are at present, stored as a JSON string.  This is editable as a string in the UI, and therefore
+    # accessible using 'conditions' as normal.
+    # This method returns a JSON decoded version of this as a HASH
+    # @return [Hash] decoded conditions
+    def conditions_json
+      ActiveSupport::JSON.decode(conditions)
+    end
+    # This method's output is a 'rack' response, but its input is not.
+    # When the router has determined that this request spec is the one that is going to be sent to the client,
+    # it will call this method with the request's parameters, headers and body.
+    #
+    # if no response has been specified, an empty body will be returned,
+    # otherwise a 'rack' version of the response is returned
+    # @param params [Hash] the request parameters
+    # @param headers [Hash] The request headers
+    # @param body [String] The request body
+    # @return [Array] The rack response
+    def call(params, headers, body)
+      response.nil? ? [204, { 'Content-Type' => 'text/plain' }, ''] : response.to_rack(params, headers, body)
+    end
+  end
+end

data/lib/agile_proxy/model/response.rb

@@ -0,0 +1,56 @@
+require 'flavour_saver'
+require 'flavour_saver/runtime'
+module AgileProxy
+  #
+  # = The associated response for the RequestSpec
+  #
+  # An instance of this class is expected to be stored alongside every RequestSpec.
+  #
+  # It is responsible for the following :-
+  #
+  # 1. Retrieving response
+  # 2. Persisting responses
+  # 3. Providing a 'rack' ouput of the response
+  # 4. Convenient setters for code, body and content_type
+  # 5. Template parsing
+  class Response < ActiveRecord::Base
+    PROTECTED_HEADERS = ['Content-Type']
+    has_many :request_specs
+    serialize :headers, JSON
+    # A convenient setter for the content_type within the header
+    # @param val [String] The content type
+    def content_type=(val)
+      write_attribute(:content_type, val)
+      headers.merge!('Content-Type' => val)
+      val
+    end
+    # Provides the response as a 'rack' response
+    #
+    # If the response is a template (by specifying is_template as true), the output will
+    # have its template values parsed and replaced with
+    # data from the input_params, input_headers and input_body
+    # Otherwise, the body of the output is sent as is.
+    # @param input_params [Hash] The input parameters as a hash
+    # @param _input_headers [Hash] The input headers as a hash
+    # @param _input_body [String] The input body
+    # @return [Array] A 'rack' response array (status, headers, body)
+    def to_rack(input_params, _input_headers, _input_body)
+      output_headers = headers.clone
+      output_content = content
+      output_status_code = status_code
+      if is_template
+        data = OpenStruct.new input_params
+        begin
+          template = Tilt['handlebars'].new { output_content }
+          output_content = template.render data
+        rescue ::FlavourSaver::UnknownHelperException => ex
+          method = ex.message.match(/Template context doesn't respond to method "(.*)"/)[1]
+          output_content = "Missing var or method '#{method}' in data."
+          output_status_code = 500
+        end
+      end
+      EventMachine::Synchrony.sleep(delay) if delay > 0
+      [output_status_code, output_headers, output_content]
+    end
+  end
+end

data/lib/agile_proxy/model/user.rb

@@ -0,0 +1,17 @@
+require_relative 'application'
+require 'active_record'
+module AgileProxy
+  #
+  # = An API User
+  #
+  # The API access to the system is multi user in that each user
+  # can have many applications and each application can have many stubs etc...
+  #
+  # This class is responsible for :-
+  # 1. Retrieving users from storage
+  # 2. Persisting users to storage
+  # 3. Providing a list of applications that the user owns
+  class User < ActiveRecord::Base
+    has_many :applications
+  end
+end

data/lib/agile_proxy/proxy_connection.rb

@@ -0,0 +1,113 @@
+require 'uri'
+require 'eventmachine'
+require 'http/parser'
+require 'em-http'
+require 'evma_httpserver'
+require 'em-synchrony'
+require 'stringio'
+require 'rack'
+
+module AgileProxy
+  #
+  # = The Proxy Connection
+  #
+  # This class is the event machine connection used by the proxy.  Every request creates a new instance of this
+  class ProxyConnection < EventMachine::Connection
+    attr_accessor :handler
+    def post_init
+      @parser = Http::Parser.new(self)
+    end
+
+    def receive_data(data)
+      @parser << data
+    end
+
+    def on_message_begin
+      @headers = nil
+      @body = ''
+    end
+
+    def on_headers_complete(headers)
+      @headers = headers
+    end
+
+    def on_body(chunk)
+      @body << chunk
+    end
+
+    def on_message_complete
+      if @parser.http_method == 'CONNECT'
+        restart_with_ssl(@parser.request_url)
+      else
+        if @ssl
+          uri = URI.parse(@parser.request_url)
+          @url = "https://#{@ssl}#{[uri.path, uri.query].compact.join('?')}"
+        else
+          @url = @parser.request_url
+        end
+        handle_request
+      end
+    end
+
+    protected
+
+    def restart_with_ssl(url)
+      @ssl = url
+      @parser = Http::Parser.new(self)
+      @original_headers = @headers.clone
+      send_data("HTTP/1.0 200 Connection established\r\nProxy-agent: Http-Flexible-Proxy/0.0.0\r\n\r\n")
+      start_tls(
+        private_key_file: File.expand_path('../mitm.key', __FILE__),
+        cert_chain_file: File.expand_path('../mitm.crt', __FILE__)
+      )
+    end
+
+    def handle_request
+      EM.synchrony do
+        request = ActionDispatch::Request.new(env)
+        request.params  # This will populate action_dispatch.request.parameters
+        handler.call(env).tap do |response|
+          send_response(response)
+        end
+      end
+    end
+
+    private
+
+    def env
+      return @__env if @__env
+      fake_input_buffer = StringIO.new(@body)
+      fake_error_buffer = StringIO.new
+      url_parsed = URI.parse(@url)
+      @__env = {
+        'rack.input' => Rack::Lint::InputWrapper.new(fake_input_buffer),
+        'rack.errors' => Rack::Lint::ErrorWrapper.new(fake_error_buffer),
+        'REQUEST_METHOD' => @parser.http_method,
+        'REQUEST_PATH' => url_parsed.path,
+        'PATH_INFO' => url_parsed.path,
+        'QUERY_STRING' => url_parsed.query || '',
+        'REQUEST_URI' => url_parsed.path + (url_parsed.query || ''),
+        'rack.url_scheme' => url_parsed.scheme,
+        'CONTENT_LENGTH' => @body.length,
+        'SERVER_NAME' => url_parsed.host,
+        'SERVER_PORT' => url_parsed.port
+
+      }
+      @headers.merge(@original_headers || {}).each do |name, value|
+        converted_name = "HTTP_#{name.gsub(/-/, '_').upcase}"
+        @__env[converted_name] = value
+      end
+      @__env['CONTENT_TYPE'] = @__env.delete('HTTP_CONTENT_TYPE') if @__env.key?('HTTP_CONTENT_TYPE')
+      @__env['CONTENT_LENGTH'] = @__env.delete('HTTP_CONTENT_LENGTH') if @__env.key?('HTTP_CONTENT_LENGTH')
+      @__env
+    end
+
+    def send_response(response)
+      res = EM::DelegatedHttpResponse.new(self)
+      res.status = response[0]
+      res.headers = response[1]
+      res.content = response[2]
+      res.send_response
+    end
+  end
+end

data/lib/agile_proxy/route.rb

@@ -0,0 +1,106 @@
+module AgileProxy
+  #
+  # An instance of this class represents a route within the system.
+  #
+  class Route
+    attr_accessor :request_method, :pattern, :app, :constraints, :name
+
+    PATH_INFO = 'PATH_INFO'.freeze
+    ROUTE_PARAMS = 'rack.route_params'.freeze
+    QUERY_STRING = 'QUERY_STRING'.freeze
+    FORM_HASH = 'rack.request.form_hash'.freeze
+    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    HEAD = 'HEAD'.freeze
+    GET = 'GET'.freeze
+    POST = 'POST'.freeze
+    PUT = 'PUT'.freeze
+    DELETE = 'DELETE'.freeze
+
+    DEFAULT_WILDCARD_NAME = :paths
+    WILDCARD_PATTERN = /\/\*(.*)/.freeze
+    NAMED_SEGMENTS_PATTERN = /\/:([^$\/]+)/.freeze
+    NAMED_SEGMENTS_REPLACEMENT_PATTERN = /\/:([^$\/]+)/.freeze
+    DOT = '.'.freeze
+
+    def initialize(request_method, pattern, app, options = {})
+      fail ArgumentError, 'pattern cannot be blank' if pattern.to_s.strip.empty?
+      fail ArgumentError, 'app must be callable' unless app.respond_to?(:call)
+      @request_method = request_method
+      @pattern = pattern
+      @app = app
+      @constraints = options && options[:constraints]
+      @name = options && options[:as]
+    end
+
+    def regexp
+      @regexp ||= compile
+    end
+
+    def compile
+      pattern_match = pattern.match(WILDCARD_PATTERN)
+      src = if pattern_match
+              @wildcard_name = if pattern_match[1].to_s.strip.empty?
+                                 DEFAULT_WILDCARD_NAME
+                               else
+                                 pattern_match[1].to_sym
+                               end
+              pattern.gsub(WILDCARD_PATTERN, '(?:/(.*)|)')
+            else
+              pattern_match = pattern.match(NAMED_SEGMENTS_PATTERN)
+              p = if pattern_match
+                    pattern.gsub(NAMED_SEGMENTS_REPLACEMENT_PATTERN, '/(?<\1>[^.$/]+)')
+                  else
+                    pattern
+                  end
+              p + '(?:\.(?<format>.*))?'
+            end
+      Regexp.new("\\A#{src}\\Z")
+    end
+
+    def match(env)
+      request_method = env[REQUEST_METHOD]
+      request_method = GET if request_method == HEAD
+      path = env[PATH_INFO]
+      qs = env[QUERY_STRING]
+      return nil unless request_method == self.request_method
+      fail ArgumentError, 'path is required' if path.to_s.strip.empty?
+      path_match = path.match(regexp)
+      return unless path_match
+      params = if @wildcard_name
+                 { @wildcard_name => path_match[1].to_s.split('/') }
+               else
+                 Hash[path_match.names.map(&:to_sym).zip(path_match.captures)]
+               end
+      params.merge!(::Rack::Utils.parse_nested_query(qs).symbolize_keys) unless qs.nil? || qs.empty?
+      params.merge! env[FORM_HASH] if env.key? FORM_HASH
+      params.delete(:format) if params.key?(:format) && params[:format].nil?
+
+      params if meets_constraints(params)
+    end
+
+    def meets_constraints(params)
+      if constraints
+        constraints.each do |param, constraint|
+          unless params.symbolize_keys[param.to_sym].to_s.match(constraint)
+            return false
+          end
+        end
+      end
+      true
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) &&
+        other.request_method == request_method &&
+        other.pattern == pattern &&
+        other.app == app &&
+        other.constraints == constraints
+    end
+
+    alias_method :==, :eql?
+
+    def hash
+      request_method.hash ^ pattern.hash ^ app.hash ^ constraints.hash
+    end
+  end
+end

data/lib/agile_proxy/router.rb

@@ -0,0 +1,99 @@
+require 'agile_proxy/route'
+
+module AgileProxy
+  #
+  # A rack router used for selecting a 'request spec' from a shortlist
+  #
+  class Router
+    VERSION = '0.4.0'
+
+    HEAD = 'HEAD'.freeze
+    GET = 'GET'.freeze
+    POST = 'POST'.freeze
+    PUT = 'PUT'.freeze
+    DELETE = 'DELETE'.freeze
+    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    PATH_INFO = 'PATH_INFO'.freeze
+    ROUTE_PARAMS = 'rack.route_params'.freeze
+    QUERY_STRING = 'QUERY_STRING'.freeze
+    FORM_HASH  = 'rack.request.form_hash'.freeze
+
+    def initialize(&block)
+      @named_routes = {}
+      routes(&block)
+    end
+
+    def [](route_name)
+      @named_routes[route_name]
+    end
+
+    def routes(&block)
+      instance_eval(&block) if block
+      @routes
+    end
+
+    def get(route_spec)
+      route(GET, route_spec)
+    end
+
+    def post(route_spec)
+      route(POST, route_spec)
+    end
+
+    def put(route_spec)
+      route(PUT, route_spec)
+    end
+
+    def delete(route_spec)
+      route(DELETE, route_spec)
+    end
+
+    def route(method, route_spec)
+      route = Route.new(
+          method,
+          route_spec.first.first,
+          route_spec.first.last,
+          route_spec.reject { |k, _| k == route_spec.first.first }
+      )
+      @routes ||= []
+      @routes << route
+      if route_spec && route_spec[:as]
+        # Using ||= so the first route with that name will be returned
+        @named_routes[route_spec[:as].to_sym] ||= route_spec.first.first
+      end
+      route
+    end
+
+    def call(env)
+      app = match(env)
+      if app
+        app.call(env)
+      else
+        not_found(env)
+      end
+    end
+
+    def match(env)
+      routes.each do |route|
+        params = route.match(env)
+        if params
+          env[ROUTE_PARAMS] = params
+          return route.app
+        end
+      end
+      nil
+    end
+
+    def not_found(env)
+      body = "<h1>Not Found</h1><p>No route matches #{env[REQUEST_METHOD]} #{env[PATH_INFO]}</p>"
+      [
+        404,
+        {
+          'Content-Type' => 'text/html',
+          'Content-Length' => body.length.to_s
+        },
+        [body]
+      ]
+    end
+  end
+end