agile-proxy-jruby 0.1.25-jruby

data/lib/agile_proxy/model/response.rb

@@ -0,0 +1,51 @@
+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_headers.merge! 'Cache-Control' => 'no-store'
+      output_content = content
+      output_status_code = status_code
+      if is_template
+        data = OpenStruct.new input_params
+        template = Tilt['handlebars'].new { output_content }
+        output_content = template.render data
+      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,112 @@
+require 'uri'
+require 'eventmachine'
+require 'stringio'
+require 'rack'
+require 'goliath/request'
+require 'goliath/env'
+
+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 < Goliath::Connection
+    def logger
+      ::AgileProxy.config.logger
+    end
+    def post_init
+      super
+      #@proxy_parser = Http::Parser.new(self)
+      @proxy_parser = Http::Parser.new
+    end
+
+    def receive_data(data)
+      #@proxy_parser << 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 @proxy_parser.http_method == 'CONNECT'
+        restart_with_ssl(@proxy_parser.request_url)
+      else
+        if @ssl
+          uri = URI.parse(@proxy_parser.request_url)
+          @url = "https://#{@ssl}#{[uri.path, uri.query].compact.join('?')}"
+        else
+          @url = @proxy_parser.request_url
+        end
+        handle_request
+      end
+    end
+
+
+    protected
+
+    def restart_with_ssl(url)
+      @ssl = url
+      @proxy_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 = ::Goliath::Request.new(handler, self, env)
+        request.set_deferred_status :succeeded
+        request.process
+      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 = ::Goliath::Env.new
+      @__env.merge!({
+        'rack.input' => Rack::Lint::InputWrapper.new(fake_input_buffer),
+        'rack.errors' => Rack::Lint::ErrorWrapper.new(fake_error_buffer),
+        'REQUEST_METHOD' => @proxy_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,
+        'rack.logger' => logger
+
+
+                    })
+      @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
+
+
+  end
+end

data/lib/agile_proxy/rack/get_only_cache.rb

@@ -0,0 +1,30 @@
+require 'rack-cache'
+require 'action_dispatch/http/request'
+module AgileProxy
+  module Rack
+    class GetOnlyCache
+      def initialize(app)
+        @app = app
+      end
+      def call(env)
+        force_caching(env)
+        request = ::ActionDispatch::Request.new(env)
+        if request.request_method_symbol == :get
+          cache_app.call(env)
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+      def force_caching(env)
+        env.delete 'HTTP_PRAGMA' if env['HTTP_PRAGMA'] == 'no-cache'
+        env.delete 'HTTP_CACHE_CONTROL' if env['HTTP_CACHE_CONTROL'] == 'no-cache'
+      end
+      def cache_app
+        @cache_app ||= ::Rack::Cache.new(@app)
+      end
+
+    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

data/lib/agile_proxy/server.rb

@@ -0,0 +1,119 @@
+require 'active_record'
+require 'yaml'
+require 'cgi'
+require 'uri'
+require 'eventmachine'
+require 'grape'
+require 'agile_proxy/api/root'
+require 'agile_proxy/servers/api'
+require 'agile_proxy/servers/request_spec'
+require 'agile_proxy/servers/request_spec_direct'
+require 'forwardable'
+
+require 'goliath/api'
+require 'goliath/runner'
+
+# Example demonstrating how to use a custom Goliath runner
+#
+
+class Custom < Goliath::API
+  def response(env)
+    [200, {}, "hello!"]
+  end
+end
+
+
+
+module AgileProxy
+  #
+  # This class is responsible for controlling the underlying proxy and web servers
+  #
+  class Server
+    ROOT = File.expand_path '../../', File.dirname(__FILE__)
+    extend Forwardable
+    attr_reader :request_handler
+
+    def_delegators :request_handler, :reset_cache, :restore_cache, :handle_request
+
+    def initialize
+      environment = AgileProxy.config.environment
+      dbconfig    = YAML.load(File.read(AgileProxy.config.database_config_file)).with_indifferent_access
+      ActiveRecord::Base.configurations = dbconfig
+      ActiveRecord::Base.establish_connection dbconfig[environment.to_s]
+    end
+
+    # Starts the proxy and web servers
+    def start
+      main_loop
+    end
+
+    # The url that the proxy server is running on
+    # @return [String] The URL
+    def url
+      "http://#{host}:#{port}"
+    end
+
+    # The url that the web server can be accessed from
+    # @return [String] The URL
+    def webserver_url
+      "http://#{webserver_host}:#{webserver_port}"
+    end
+
+    # The url that the direct web server can be accessed from
+    # @return [String] The URL
+    def server_url
+      "http://#{server_host}:#{server_port}"
+    end
+
+    # The host that the proxy server is running on
+    # @return [String] The host
+    def host
+      'localhost'
+    end
+
+    # The port that the proxy server is running on
+    # @return [String] The port
+    def port
+      @request_spec_server.port
+    end
+
+    # The host that the webserver is running on
+    # @return [String] The host
+    def webserver_host
+      AgileProxy.config.webserver_host
+    end
+
+    # The port that the webserver is running on
+    # @return [String] The port
+    def webserver_port
+      AgileProxy.config.webserver_port
+    end
+
+    # The host that the direct server is running on
+    # @return [String] The host
+    def server_host
+      AgileProxy.config.server_host
+    end
+
+    # The port that the direct server is running on
+    # @return [String] The port
+    def server_port
+      AgileProxy.config.server_port
+    end
+
+    protected
+
+    def main_loop
+      EM.run do
+        EM.error_handler do |e|
+          puts e.class.name, e
+          puts e.backtrace.join("\n")
+        end
+        AgileProxy::Servers::Api.start(webserver_host, webserver_port)
+        AgileProxy::Servers::RequestSpecDirect.start(server_host, server_port)
+        @request_spec_server = AgileProxy::Servers::RequestSpec.start enable_cache: AgileProxy.config.enable_cache
+        AgileProxy.log(:info, "agile-proxy: Proxy listening on #{url}, API webserver listening on #{webserver_url} and Direct webserver listening on #{server_url}")
+      end
+    end
+  end
+end