agile-proxy-jruby 0.1.25-jruby

data/lib/agile_proxy/api/recordings.rb

@@ -0,0 +1,52 @@
+module AgileProxy
+  module Api
+    #
+    # = A grape API for recordings
+    #
+    # If the application is set to allow recordings, each HTTP request and response passing
+    # through the proxy server will be recorded.
+    #
+    # This API allows access to those recordings via REST
+    #
+    class Recordings < Grape::API
+      include Grape::Kaminari
+      helpers do
+        # Convenient access to the record specified in the id parameter
+        def record
+          current_application.recordings.where(id: params[:id]).first
+        end
+
+        def default_json_spec
+          {}
+        end
+      end
+
+      resource :recordings do
+        desc 'List all recordings made for the application'
+        paginate per_page: 20, max_per_page: 200
+        get do
+          authenticate!
+          scope = current_application.recordings
+          { recordings: paginate(scope).as_json(default_json_spec), total: scope.count }
+        end
+        desc 'Delete all rcordings for the application'
+        delete do
+          authenticate!
+          scope = current_application.recordings
+          scope.destroy_all
+          { recordings: [], total: 0 }
+        end
+        desc 'Get a recording by id'
+        get ':id' do
+          authenticate!
+          record.as_json(default_json_spec)
+        end
+        delete ':id' do
+          authenticate!
+          record.tap(&:destroy).as_json(default_json_spec)
+        end
+
+      end
+    end
+  end
+end

data/lib/agile_proxy/api/request_spec_recordings.rb

@@ -0,0 +1,52 @@
+module AgileProxy
+  module Api
+    #
+    # = A grape API for recordings
+    #
+    # If the application is set to allow recordings, each HTTP request and response passing
+    # through the proxy server will be recorded.
+    #
+    # This API allows access to those recordings via REST
+    #
+    class RequestSpecRecordings < Grape::API
+      include Grape::Kaminari
+      helpers do
+        # Convenient access to the record specified in the id parameter
+        def record
+          current_application.recordings.where(request_spec_id: params[:request_spec_id], id: params[:id]).first
+        end
+
+        def default_json_spec
+          {}
+        end
+      end
+
+      resource :recordings do
+        desc 'List all recordings made for the request spec'
+        paginate per_page: 20, max_per_page: 200
+        get do
+          authenticate!
+          scope = current_application.recordings.where({request_spec_id: params[:request_spec_id]})
+          { recordings: paginate(scope).as_json(default_json_spec), total: scope.count }
+        end
+        desc 'Delete all recordings for the application'
+        delete do
+          authenticate!
+          scope = current_application.recordings
+          scope.destroy_all request_spec_id: params[:request_spec_id]
+          { recordings: [], total: 0 }
+        end
+        desc 'Get a recording by id'
+        get ':id' do
+          authenticate!
+          record.as_json(default_json_spec)
+        end
+        delete ':id' do
+          authenticate!
+          record.tap(&:destroy).as_json(default_json_spec)
+        end
+
+      end
+    end
+  end
+end

data/lib/agile_proxy/api/request_specs.rb

@@ -0,0 +1,86 @@
+require 'agile_proxy/model/request_spec'
+require 'grape-kaminari'
+module AgileProxy
+  module Api
+    #
+    # = A grape API for request specifications
+    #
+    # A 'request specification' is what is known as a 'Stub' in the UI.
+    #
+    # It defines an input and output spec for a HTTP(s) request.
+    #
+    # For example, we could say
+    # 'When http://www.mybing.com/search.html is requested with some specific query parameters, then respond with this'
+    #
+    # This API allows full CRUD access to these request specifications, but only those belonging to the logged in user.
+    #
+    class RequestSpecs < Grape::API
+      include Grape::Kaminari
+      helpers do
+        # We only allow selected parameters through - spec and note
+        def permitted_params
+          @permitted_params ||= declared(
+              params,
+              { include_missing: false },
+              [:spec, :note, :response, :http_method, :url, :url_type, :conditions, :record_requests]
+          )
+        end
+
+        # Convenient access to the record specified in the id parameter
+        def record
+          current_application.request_specs.where(id: params[:id]).first
+        end
+
+        # Convenient access to the record parameters from a POST or a PUT, only permitted will be returned
+        # Note that for some reason, to do with rack or grape,
+        # when we send a large body, the request_spec does not come through
+        # so, to work around this, we inject the request spec in afterwards if it is missing.
+        def record_params
+          p = permitted_params.with_indifferent_access
+          p.merge!(user_id: current_user.id, application_id: current_application.id)
+          p[:response_attributes] = p.delete(:response) if p.key?(:response)
+          p
+        end
+
+        def default_json_spec
+          { include: { response: { except: [:created_at, :updated_at] } } }
+        end
+
+      end
+      resource :request_specs do
+        desc 'List all request specifications for the application'
+        paginate per_page: 50, max_per_page: 200
+        get do
+          authenticate!
+          scope = current_application.request_specs
+          { request_specs: paginate(scope).as_json(default_json_spec), total: scope.count }
+        end
+        delete do
+          authenticate!
+          scope = current_application.request_specs
+          scope.destroy_all
+          { request_specs: [], total: 0 }
+        end
+        desc 'Create a new request specification'
+        post do
+          authenticate!
+          current_application.request_specs.create(record_params).as_json(default_json_spec)
+        end
+        get ':id' do
+          authenticate!
+          record.as_json(default_json_spec)
+        end
+        desc 'Update a request specification'
+        put ':id' do
+          authenticate!
+          record.tap { |r| r.update_attributes(record_params) }.as_json(default_json_spec)
+        end
+        delete ':id' do
+          authenticate!
+          record.tap(&:destroy).as_json(default_json_spec)
+        end
+
+      end
+    end
+  end
+end

data/lib/agile_proxy/api/root.rb

@@ -0,0 +1,45 @@
+require_relative 'request_specs'
+require_relative 'request_spec_recordings'
+require_relative 'applications'
+require_relative 'recordings'
+module AgileProxy
+  module Api
+    #
+    # = The API Root
+    #
+    # This is the root of the entire API for use with REST.  It will not be accessed directly
+    #
+    class Root < Grape::API
+      version 'v1', vendor: 'agile-proxy'
+      format :json
+      helpers do
+        # Provides easy access to the current user.
+        # As we are currently only single user, then we just return the first user
+        def current_user
+          ::AgileProxy::User.first
+        end
+        # Secured methods must call this first
+        def authenticate!
+          # Do nothing yet
+        end
+        # Provides easy access to the current application whether
+        # specified in the URL or not (defaults to the first if not)
+        def current_application
+          fail 'Application ID is missing' unless params.key?(:application_id)
+          applications = current_user.applications
+          applications.where(id: params[:application_id]).first
+        end
+      end
+      namespace 'users/:user_id' do
+        mount Api::Applications
+        namespace '/applications/:application_id' do
+          mount Api::Recordings
+          mount Api::RequestSpecs
+          namespace '/request_specs/:request_spec_id' do
+            mount Api::RequestSpecRecordings
+          end
+        end
+      end
+    end
+  end
+end

data/lib/agile_proxy/cli.rb

@@ -0,0 +1,116 @@
+require 'agile_proxy'
+require 'thor'
+require 'active_record'
+require_relative '../../db/seed'
+
+module AgileProxy
+  include ActiveRecord::Tasks
+  class Cli < Thor
+    class << self
+      def data_dir_base
+        if RUBY_PLATFORM =~ /win32/
+          ENV['APPDATA']
+        elsif RUBY_PLATFORM =~ /linux/
+          ENV['HOME']
+        elsif RUBY_PLATFORM =~ /darwin/
+          ENV['HOME']
+        elsif RUBY_PLATFORM =~ /freebsd/
+          ENV['HOME']
+        else
+          ENV['HOME']
+        end
+      end
+
+      def data_dir
+        if Dir.pwd == File.expand_path('../..', File.dirname(__FILE__))
+          Dir.pwd
+        else
+          File.join data_dir_base, '.agile_proxy'
+        end
+      end
+
+      def environment
+        ENV['AGILE_PROXY_ENV'] || (Dir.pwd == File.expand_path('../..', File.dirname(__FILE__)) ? 'development' : 'production')
+      end
+    end
+    package_name 'Http Flexible Proxy'
+    desc 'start PROXY_PORT WEBSERVER_PORT', 'Runs the agile proxy'
+    method_options data_dir: data_dir, database_config_file: 'db.yml', env: environment
+    def start(proxy_port = nil, server_port = nil, webserver_port = nil)
+      ensure_database_config_file_exists database_config_file(options)
+      puts "Data dir is #{options.data_dir}, environment is #{options.env}"
+      setup_for_migrations(options)
+      ::AgileProxy.configure do |config|
+        config.proxy_port = proxy_port unless proxy_port.nil?
+        config.server_port = server_port unless server_port.nil?
+        config.webserver_port = webserver_port unless webserver_port.nil?
+        config.environment = options.env
+        config.database_config_file = database_config_file(options)
+      end
+      server = AgileProxy::Server.new
+      update_db
+      server.start
+    end
+
+    private
+
+    def setup_for_migrations(options)
+      ActiveRecord::Tasks::DatabaseTasks.db_dir = options.data_dir
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = [File.expand_path('../../db/migrations', File.dirname(__FILE__))]
+      ActiveRecord::Tasks::DatabaseTasks.env = options.env
+      ActiveRecord::Tasks::DatabaseTasks.root = File.expand_path('../..', __FILE__)
+      ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+    end
+    def run_migrations
+      ActiveRecord::Migration.verbose = true
+      ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, nil) do |migration|
+        ENV["SCOPE"].blank? || (ENV["SCOPE"] == migration.scope)
+      end
+    end
+
+    def seed_database
+      Seed.load_seed
+    end
+
+    def server
+      AgileProxy::Server.new
+    end
+
+    def update_db
+      ActiveRecord::Tasks::DatabaseTasks.create_current
+      run_migrations
+      seed_database
+      # Rake::Task['db:create'].invoke
+      # Rake::Task['db:migrate'].invoke
+
+
+    end
+
+    def ensure_database_config_file_exists(fn)
+      return if File.exist? fn
+      FileUtils.mkdir_p File.dirname fn
+      db = {
+          :development => {
+              adapter: 'sqlite3',
+              database: File.join(File.dirname(fn), 'db', 'development.db')
+          },
+          :test => {
+              adapter: 'sqlite3',
+              database: File.join(File.dirname(fn), 'db', 'test.db')
+          },
+          :production => {
+              adapter: 'sqlite3',
+              database: File.join(File.dirname(fn), 'db', 'production.db')
+          }
+      }
+      File.open(fn, 'w') {|f| f.write(db.to_yaml) }
+    end
+    def database_config_file(options)
+      if File.exist? options.database_config_file
+        options.database_config_file
+      else
+        File.join(options.data_dir, options.database_config_file)
+      end
+    end
+  end
+end

data/lib/agile_proxy/config.rb

@@ -0,0 +1,66 @@
+require 'logger'
+require 'tmpdir'
+# Agile Proxy
+module AgileProxy
+  #
+  # Configuration for the agile proxy
+  class Config
+    DEFAULT_WHITELIST = ['127.0.0.1', 'localhost']
+    RANDOM_AVAILABLE_PORT = 0 # https://github.com/eventmachine/eventmachine/wiki/FAQ#wiki-can-i-start-a-server-on-a-random-available-port
+
+    attr_accessor :logger, :cache, :cache_request_headers, :whitelist, :path_blacklist, :ignore_params,
+                  :persist_cache, :ignore_cache_port, :non_successful_cache_disabled, :non_successful_error_level,
+                  :non_whitelisted_requests_disabled, :cache_path, :proxy_port, :proxied_request_inactivity_timeout,
+                  :proxied_request_connect_timeout, :dynamic_jsonp, :dynamic_jsonp_keys,
+                  :webserver_host, :webserver_port, :server_host, :server_port, :database_config_file, :environment, :enable_cache
+
+    def initialize
+      @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+      reset
+    end
+
+    # Resets the configuration with the defaults
+    def reset
+      @cache = true
+      @cache_request_headers = false
+      @whitelist = DEFAULT_WHITELIST
+      @path_blacklist = []
+      @ignore_params = []
+      @persist_cache = false
+      @dynamic_jsonp = false
+      @dynamic_jsonp_keys = ['callback']
+      @ignore_cache_port = true
+      @non_successful_cache_disabled = false
+      @non_successful_error_level = :warn
+      @non_whitelisted_requests_disabled = false
+      @cache_path = File.join(Dir.tmpdir, 'agile-proxy')
+      @proxy_port = RANDOM_AVAILABLE_PORT
+      @proxied_request_inactivity_timeout = 10 # defaults from https://github.com/igrigorik/em-http-request/wiki/Redirects-and-Timeouts
+      @proxied_request_connect_timeout = 5
+      @webserver_port = 3020
+      @webserver_host = 'localhost'
+      @server_port = 3030
+      @server_host = 'localhost'
+      @database_config_file = File.join(File.dirname(__FILE__), '..', '..', 'config.yml')
+      @environment = ENV['AGILE_PROXY_ENV']
+      @enable_cache = false
+    end
+  end
+
+  # Configures the system using a block which has the global instance of this config yielded
+  def self.configure
+    yield config if block_given?
+    config
+  end
+
+  # Common log method - sends the log to the appropriate place
+  def self.log(*args)
+    config.logger.send(*args) unless config.logger.nil?
+  end
+
+  private
+
+  def self.config
+    @config ||= Config.new
+  end
+end

data/lib/agile_proxy/handlers/handler.rb

@@ -0,0 +1,43 @@
+require 'rack'
+module AgileProxy
+  # A mixin that all handlers must include
+  module Handler
+    ##
+    #
+    # Handles an incoming rack request and returns a rack response.
+    #
+    # This method accepts rack request parameters and must return
+    # a rack response array containing [status, headers, content]
+    # , or [404, {}, ''] if the request cannot be fulfilled.
+    #
+    # @param  _env [Hash] The rack environment
+    # @return [Array]               An array of [status, headers, content]
+    #                               Returns status of 404 if the request cannot be fulfilled.
+    def call(_env)
+      [500, {}, 'The handler has not overridden the handle_request method!']
+    end
+
+    private
+
+    def username_password(env)
+      Base64.decode64(env['HTTP_PROXY_AUTHORIZATION'].sub(/^Basic /, '')).split(':') if proxy_auth? env
+    end
+
+    def proxy_auth?(env)
+      env.key?('HTTP_PROXY_AUTHORIZATION') && env['HTTP_PROXY_AUTHORIZATION'] =~ /^Basic /
+    end
+
+    def downcase_header_name(name)
+      name.split(/_/).drop(1).map { |word| word.downcase.capitalize }.join('-')
+    end
+
+    def downcased_headers(env)
+      headers = {}
+      env.each do |name, value|
+        next unless name =~ /^HTTP_/
+        headers[downcase_header_name(name)] = value
+      end
+      headers
+    end
+  end
+end