front_end_loader 0.2.3

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011-2012 Brewster Inc., Aubrey Holland
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# Front End Loader
+
+Front End Loader is a Ruby DSL for declaring load tests. It works in the spirit of
+tools like JMeter, by simulating a number of users performing a scripted set of actions
+and displaying metrics about response times and error rates as the requests are performed.
+Unlike GUI tools like JMeter, however, front_end_loader makes it very simple to declare
+your requests and to pass data between requests, by looking at the responses to gather data.
+
+## Install
+    gem install front_end_loader
+
+## Creating an Experiment
+
+In order to create a test, just declare a FrontEndLoader::Experiment object:
+
+```ruby
+require 'front_end_loader'
+
+experiment = FrontEndLoader::Experiment.new.tap do |e|
+  e.user_count = 20
+  e.loop_count = 5
+  e.domain = 'https://www.google.com'
+  e.basic_auth('unreal_login', 'unreal_password')
+  e.default_parameters = { 'unnecessary' => 'true' }
+  e.debug = '/tmp/front_end_loader.txt'
+
+  e.requests do |r|
+    ...
+  end
+end
+
+experiment.run
+```
+
+This block declares an experiment that:
+
+* simulates 20 users simultaneously interacting with the system
+* executes the request script five times per user before exiting. You can specify infinite loops by either not calling loop_count or passing -1
+* will operate against the google.com domain
+* uses http basic auth
+* passes a default parameter of unnecessary to each request, and
+* writes debugging output to /tmp/front_end_loader.txt
+
+It then runs the experiment, which causes the requests to start flowing and output to be displayed
+on the screen. The requests method on the experiment is where you will define the script to be run
+loop_count times for each of the simulated users:
+
+```ruby
+  e.requests do |r|
+
+   word = nil
+
+    r.get('test_search', '/search', :q => 'test') do |response|
+      word = response.body.
+        split(/\s/).
+        reject { |i| i.length < 3 || i.length > 10 }.
+        sort_by { rand }.
+        first
+    end
+
+    e.write_debug(word)
+
+    r.get('random_word_search', '/search', :q => word)
+
+    r.get('privacy_policy', '/intl/en/policies')
+
+    # r.post(...)
+    # r.put(...)
+    # r.delete(...)
+  end
+```
+
+For each request, arguments are:
+
+* the label to use when tracking it in the display
+* the path
+* parameters, as a hash
+* for post and put requests, a data object to use as the request body
+
+All request declarations can take a block that will be passed the response from that request. The response
+is a Patron::Response object and can be used to access data and pass it into further requests. Each iteration
+of the script will be run in order and will not affect other iterations that may be running.
+
+## Running the experiment
+
+Excuting an experiment will produce output like this:
+
+```
+------------------------------------------------------------------------------------------------------
+| call                           | count    | avg time | max time | errors   | error %  | throughput  |
+------------------------------------------------------------------------------------------------------
+| profile                        | 40       | 0.252    | 0.731    | 0        | 0.0      | 140         |
+| random search                  | 40       | 0.275    | 0.491    | 0        | 0.0      | 140         |
+| filtered_search                | 40       | 0.28     | 0.67     | 0        | 0.0      | 140         |
+| suggestions                    | 40       | 0.264    | 0.624    | 0        | 0.0      | 140         |
+| autocomplete                   | 38       | 0.234    | 0.456    | 0        | 0.0      | 133         |
+| filtered autocomplete          | 37       | 0.204    | 0.323    | 0        | 0.0      | 130         |
+| services                       | 37       | 0.203    | 0.476    | 0        | 0.0      | 130         |
+| service types                  | 37       | 0.185    | 0.456    | 0        | 0.0      | 130         |
+| me                             | 36       | 0.25     | 0.555    | 0        | 0.0      | 126         |
+|                                |          |          |          |          |          |             |
+| TOTAL                          | 345      | 0.238    | 0.731    | 0        | 0.0      | 1209        |
+------------------------------------------------------------------------------------------------------
+run time: 0:00:17
+```
+
+Throughput is measured in requests per minute and note that because each "user" is running though the script
+in series, the throughput for an individual request is not as high as you would expect by running only that request
+over and over again.
+
+This display accepts the following keyboard controls:
+
+* c - reset the data
+* d - write the contents of the screen to the debug file
+* p - pause the scripts, so the data will remain static and no requests will be made
+* q - quit
+* s - start the scripts again when paused
+
+## <a name="copyright"></a>Copyright
+Copyright (c) 2011-2012 Brewster Inc., Aubrey Holland
+See [LICENSE](https://github.com/brewster/front_end_loader/blob/master/LICENSE) for details.

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rspec/core/rake_task'
+
+task :default => :test
+
+## helper functions
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+## standard tasks
+
+RSpec::Core::RakeTask.new(:test)
+
+desc "Generate #{gemspec_file}"
+task :gemspec do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end

data/front_end_loader.gemspec

@@ -0,0 +1,36 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.3.5") if s.respond_to? :required_rubygems_version=
+
+  s.name    = 'front_end_loader'
+  s.version = '0.2.3'
+
+  s.summary     = 'A framework for doing declarative load testing in ruby'
+  s.description = <<-EOF
+Front End Loader allows clients to declare load tests using a pure-Ruby DSL.
+This means that it is very simple to pass data between requests or to interact
+with your systems in dynamic, complex ways.
+EOF
+  s.authors  = ['Aubrey Holland']
+  s.email    = 'aubreyholland@gmail.com'
+  s.homepage = 'https://github.com/brewster/front_end_loader'
+
+  s.add_dependency 'patron'
+
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    LICENSE
+    README.md
+    Rakefile
+    front_end_loader.gemspec
+    lib/front_end_loader.rb
+    lib/front_end_loader/experiment.rb
+    lib/front_end_loader/request.rb
+    lib/front_end_loader/request_manager.rb
+    lib/front_end_loader/screen.rb
+  ]
+  # = MANIFEST =
+
+  s.test_files = s.files.select { |path| path =~ %r{^spec/*/.+\.rb} }
+end

data/lib/front_end_loader/experiment.rb

@@ -0,0 +1,277 @@
+module FrontEndLoader
+  class Experiment
+    attr_accessor :domain
+    attr_accessor :user_count
+    attr_accessor :loop_count
+    attr_accessor :default_parameters
+    attr_reader :basic_auth_enabled
+    attr_reader :basic_auth_user
+    attr_reader :basic_auth_password
+    attr_reader :screen
+
+    attr_reader :run_start_time
+    attr_reader :run_completed_time
+    attr_reader :running
+    attr_reader :call_times
+    attr_reader :call_error_counts
+    attr_reader :call_max_times
+
+    def initialize
+      @screen = Screen.new(self)
+      @running = false
+      @mutex = Mutex.new
+      @debug_mutex = Mutex.new
+      @loop_count = -1
+      @paused = false
+      @run_completed_time = nil
+      clear_data
+    end
+
+    def synchronize(&block)
+      @mutex.synchronize do
+        block.call
+      end
+    end
+
+    def debug=(file)
+      @debug_file = File.open(file, 'a')
+    end
+
+    def write_debug(data)
+      if @debug_file
+        @debug_mutex.synchronize do
+          @debug_file.puts(data)
+          @debug_file.flush
+        end
+      end
+    end
+
+    def write_screen_to_debug
+      if @debug_file
+        @debug_mutex.synchronize do
+          @screen.write_debug(@debug_file)
+        end
+      end
+    end
+
+    def clear_data
+      @mutex.synchronize do
+        @call_counts ||= Hash.new { |h,k| h[k] = 0 }
+        @call_counts.keys.each { |k| @call_counts[k] = 0 }
+
+        @call_times ||= Hash.new { |h,k| h[k] = 0.0 }
+        @call_times.keys.each { |k| @call_times[k] = 0.0 }
+
+        @call_max_times ||= Hash.new { |h,k| h[k] = 0.0 }
+        @call_max_times.keys.each { |k| @call_max_times[k] = 0.0 }
+
+        @call_error_counts ||= Hash.new { |h,k| h[k] = 0 }
+        @call_error_counts .keys.each { |k| @call_error_counts[k] = 0 }
+
+        @call_times_last_25 ||= Hash.new { |h,k| h[k] = [] }
+        @call_times_last_25.keys.each { |k| @call_times_last_25[k] = [] }
+
+        @error_counts_by_type ||= Hash.new { |h,k| h[k] = 0 }
+        @error_counts_by_type.keys.each { |k| @error_counts_by_type[k] = 0 }
+
+        if @run_start_time
+          @run_start_time = Time.now
+        else
+          @run_start_time = nil
+        end
+      end
+    end
+
+    def basic_auth(user, password)
+      @basic_auth_enabled = true
+      @basic_auth_user = user
+      @basic_auth_password = password
+    end
+
+    def requests(&block)
+      @request_block = block
+    end
+
+    def run_completed!
+      @run_completed_time = Time.now
+    end
+
+    def run
+      @running = true
+      @run_start_time = Time.now
+
+      threads = (1..user_count).to_a.map do
+        Thread.new(self, @request_block) do |experiment, request_block|
+          loops_left = experiment.loop_count
+          while(loops_left != 0)
+            if experiment.paused?
+              sleep(0.25)
+            elsif experiment.quitting?
+              loops_left = 0
+            else
+              request_manager = RequestManager.new(experiment, experiment.http_session)
+              request_block.call(request_manager)
+              loops_left -= 1
+            end
+          end
+          experiment.run_completed!
+        end
+      end
+
+      threads << Thread.new(self) do |experiment|
+        while (!experiment.quitting?)
+          if experiment.paused?
+            sleep(0.25)
+          else
+            experiment.screen.refresh
+            sleep(0.1)
+          end
+        end
+      end
+
+      threads << Thread.new(self) do |experiment|
+        while (!experiment.quitting?)
+          ch = Curses.getch
+          if ch == 'c'
+            experiment.clear_data
+          elsif ch == 'd'
+            experiment.write_screen_to_debug
+          elsif ch == 'p'
+            experiment.pause
+          elsif ch == 'q'
+            experiment.quit
+          elsif ch == 's'
+            experiment.clear_data
+            experiment.go
+          end
+        end
+      end
+
+      begin
+        threads.each(&:run)
+        threads.each(&:join)
+      rescue Interrupt
+        @screen.close
+      end
+
+      @screen.close
+    end
+    
+    def http_session
+      Patron::Session.new.tap do |session|
+        session.base_url = domain
+        session.insecure = true
+        session.max_redirects = 0
+        if basic_auth_enabled
+          session.auth_type = :basic
+          session.username = basic_auth_user
+          session.password = basic_auth_password
+          session.connect_timeout = 10
+          session.timeout = 500
+        end
+      end
+    end
+
+    def paused?
+      @paused
+    end
+
+    def pause
+      @paused = true
+    end
+
+    def go
+      @paused = false
+    end
+
+    def quitting?
+      @quitting
+    end
+
+    def quit
+      @quitting = true
+    end
+
+    def time_call(name, &block)
+      begin
+        start = Time.now
+        response = block.call
+        time = Time.now - start
+        @mutex.synchronize do
+          @call_times[name] += time
+          @call_max_times[name] = time if time > @call_max_times[name]
+          unless response.status >= 200 && response.status < 400
+            write_debug(response.body)
+            @call_error_counts[name] += 1
+            @error_counts_by_type[response.status] += 1
+          end
+          @call_counts[name] += 1
+          @call_times_last_25[name].unshift(time)
+          @call_times_last_25[name] = @call_times_last_25[name].slice(0, 25)
+        end
+        response
+      rescue Patron::TimeoutError
+        add_timeout(name)
+      end
+    end
+
+    def add_timeout(name)
+      @mutex.synchronize do
+        @call_counts[name] += 1
+        @call_times[name] += 0
+        @call_error_counts[name] += 1
+        @error_counts_by_type['Timeout'] += 1
+      end
+    end
+
+    def call_counts
+      @call_counts.dup
+    end
+
+    def total_times
+      @call_times.dup
+    end
+
+    def average_times
+      @call_times.keys.inject({}) do |hash, name|
+        if @call_counts[name] == 0
+          hash[name] = 0.0
+        else
+          hash[name] = @call_times[name] / @call_counts[name].to_f
+        end
+        hash
+      end
+    end
+
+    def max_times
+      @call_max_times.dup
+    end
+
+    def error_counts
+      @call_error_counts.dup
+    end
+
+    def error_types
+      @error_counts_by_type.dup
+    end
+
+    def error_percents
+      @call_counts.keys.inject({}) do |hash, name|
+        if @call_counts[name] && @call_counts[name] > 0 && @call_error_counts[name] && @call_error_counts[name] > 0
+          hash[name] = (@call_error_counts[name].to_f / @call_counts[name].to_f) * 100.0
+        else
+          hash[name] = 0.0
+        end
+        hash
+      end
+    end
+
+    def throughput
+      delta = ((@run_completed_time || Time.now) - @run_start_time) / 60.0
+      @call_counts.keys.inject({}) do |hash, name|
+        hash[name] = @call_counts[name].to_f / delta
+        hash
+      end
+    end
+  end
+end

data/lib/front_end_loader/request.rb

@@ -0,0 +1,30 @@
+module FrontEndLoader
+  class Request
+    def initialize(experiment, session, method, name, path, params, data, response_block)
+      @experiment = experiment
+      @session = session
+      @method = method
+      @name = name
+      @path = path
+      @params = URI.encode(@experiment.default_parameters.merge(params).map { |k,v| "#{k}=#{v}" }.join('&'))
+      @data = data
+      @response_block = response_block
+    end
+
+    def run
+      response = nil
+      if [:get, :delete].include?(@method)
+        response = @experiment.time_call(@name) do
+          @session.__send__(@method, "#{@path}?#{@params}")
+        end
+      else
+        response = @experiment.time_call(@name) do
+          @session.__send__(@method, "#{@path}?#{@params}", @data, {'Content-Type' => 'application/json'})
+        end
+      end
+      if @response_block && response.is_a?(Patron::Response)
+        @response_block.call(response)
+      end
+    end
+  end
+end

data/lib/front_end_loader/request_manager.rb

@@ -0,0 +1,28 @@
+module FrontEndLoader
+  class RequestManager
+    def initialize(experiment, session)
+      @experiment = experiment
+      @session = session
+    end
+
+    def get(name, path, params={}, &block)
+      Request.new(@experiment, @session, :get, name, path, params, nil, block).run
+    end
+
+    def post(name, path, params={}, data="{}", &block)
+      Request.new(@experiment, @session, :post, name, path, params, data, block).run
+    end
+
+    def put(name, path, params={}, data="{}", &block)
+      Request.new(@experiment, @session, :put, name, path, params, data, block).run
+    end
+
+    def delete(name, path, params={}, &block)
+      Request.new(@experiment, @session, :delete, name, path, params, nil, block).run
+    end
+
+    def debug(data)
+      @experiment.write_debug(data)
+    end
+  end
+end

data/lib/front_end_loader/screen.rb

@@ -0,0 +1,226 @@
+require 'curses'
+
+module FrontEndLoader
+  class Screen
+
+    POSITIONS = {
+      :count => 0,
+      :average_time => 11,
+      :max_time => 22,
+      :errors => 33,
+      :error_percent => 44,
+      :throughput => 55
+    }
+
+    LENGTHS = {
+      :count => 9,
+      :average_time => 9,
+      :max_time => 9,
+      :errors => 9,
+      :error_percent => 9,
+      :throughput => 12
+    }
+
+    TOTAL_LENGTH = 66
+
+    def initialize(experiment)
+      @experiment = experiment
+      @entry_count = nil
+      @longest_name = 0
+      Curses.init_screen
+      Curses.nonl
+      Curses.cbreak
+      Curses.noecho
+    end
+
+    def refresh
+      run_start_time = nil
+      names = nil
+      counts_by_name = {}
+      times_by_name = {}
+      average_times_by_name = {}
+      max_times_by_name = {}
+      error_counts_by_name = {}
+      error_counts_by_type = {}
+      error_percents_by_name = {}
+      throughput_by_name = {}
+      total_calls = nil
+      total_time = nil
+      total_errors = nil
+      delta = nil
+      max_max_time = nil
+
+      @experiment.synchronize do
+        return if !@experiment.running || @experiment.call_counts.empty?
+
+        run_start_time = @experiment.run_start_time.dup
+        names = @experiment.call_counts.keys.dup
+
+        counts_by_name = @experiment.call_counts
+        times_by_name = @experiment.total_times
+        average_times_by_name = @experiment.average_times
+        max_times_by_name = @experiment.max_times
+        error_counts_by_name = @experiment.error_counts
+        error_counts_by_type = @experiment.error_types
+        error_percents_by_name = @experiment.error_percents
+        throughput_by_name = @experiment.throughput
+
+        total_calls = @experiment.call_counts.values.inject(0) { |s,i| s + i }
+        total_time = @experiment.call_times.values.inject(0) { |s,i| s + i }
+        total_errors = @experiment.call_error_counts.values.inject(0) { |s,i| s + i }
+        max_max_time = @experiment.call_max_times.values.max.round(3).to_s
+        delta = ((@experiment.run_completed_time || Time.now) - @experiment.run_start_time) / 60.0
+      end
+
+      if names.count != @entry_count
+        @entry_count = names.length
+        @longest_name = names.map(&:length).max
+        draw_outlines(names)
+      end
+
+      first_position = @longest_name + 6
+      line = 3
+      names.each do |name|
+        clear_line(line, first_position)
+        Curses.setpos(line, first_position + POSITIONS[:count])
+        Curses.addstr(counts_by_name[name].to_s)
+        Curses.setpos(line, first_position + POSITIONS[:average_time])
+        Curses.addstr(average_times_by_name[name].round(3).to_s)
+        Curses.setpos(line, first_position + POSITIONS[:max_time])
+        Curses.addstr(max_times_by_name[name].round(3).to_s)
+        Curses.setpos(line, first_position + POSITIONS[:errors])
+        Curses.addstr(error_counts_by_name[name].to_s)
+        Curses.setpos(line, first_position + POSITIONS[:error_percent])
+        Curses.addstr(error_percents_by_name[name].round(3).to_s)
+        Curses.setpos(line, first_position + POSITIONS[:throughput])
+        Curses.addstr(throughput_by_name[name].to_i.to_s)
+        line += 1
+      end
+      line += 1
+      clear_line(line, first_position)
+      Curses.setpos(line, first_position + POSITIONS[:count])
+      Curses.addstr(total_calls.to_s)
+      Curses.setpos(line, first_position + POSITIONS[:average_time])
+      Curses.addstr((total_time / total_calls.to_f).round(3).to_s)
+      Curses.setpos(line, first_position + POSITIONS[:max_time])
+      Curses.addstr(max_max_time.to_s)
+      Curses.setpos(line, first_position + POSITIONS[:errors])
+      Curses.addstr(total_errors.to_s)
+      Curses.setpos(line, first_position + POSITIONS[:error_percent])
+      Curses.addstr(((total_errors.to_f / total_calls.to_f) * 100.0).round(1).to_s)
+      Curses.setpos(line, first_position + POSITIONS[:throughput])
+      Curses.addstr((total_calls.to_f / delta).to_i.to_s)
+
+      line += 3
+      time = Time.now - run_start_time
+      hours = (time / 3600).to_i
+      minutes = (time / 60 - (hours * 60)).to_i
+      seconds = (time - (minutes * 60 + hours * 3600)).to_i
+      Curses.setpos(line, 3)
+      Curses.addstr("run time: #{hours}:#{'%02d' % minutes}:#{'%02d' % seconds}")
+
+      line += 2
+      error_counts_by_type.each do |type, count|
+        erase_line(line)
+        Curses.setpos(line, 3)
+        Curses.addstr("#{type}: #{count}") 
+        line += 1
+      end
+
+      Curses.curs_set(0)
+      Curses.refresh
+    rescue StandardError => e
+      puts e.message
+      puts e.backtrace.first
+    end
+
+    def clear_line(line, first_position)
+      Curses.setpos(line, first_position + POSITIONS[:count])
+      Curses.addstr(' ' * LENGTHS[:count])
+      Curses.setpos(line, first_position + POSITIONS[:average_time])
+      Curses.addstr(' ' * LENGTHS[:average_time])
+      Curses.setpos(line, first_position + POSITIONS[:max_time])
+      Curses.addstr(' ' * LENGTHS[:max_time])
+      Curses.setpos(line, first_position + POSITIONS[:errors])
+      Curses.addstr(' ' * LENGTHS[:error_percent])
+      Curses.setpos(line, first_position + POSITIONS[:error_percent])
+      Curses.addstr(' ' * LENGTHS[:error_percent])
+      Curses.setpos(line, first_position + POSITIONS[:throughput])
+      Curses.addstr(' ' * LENGTHS[:throughput])
+    end
+
+    def erase_line(line)
+      Curses.setpos(line, 0)
+      Curses.addstr(' ' * TOTAL_LENGTH)
+    end
+
+    def draw_outlines(names)
+      first_position = @longest_name + 6
+      Curses.clear
+      Curses.setpos(0, 2)
+      Curses.addstr('-' * (first_position + TOTAL_LENGTH))
+      Curses.setpos(1, 1)
+      Curses.addstr(divider_string)
+      Curses.setpos(1, 3)
+      Curses.addstr('call')
+      Curses.setpos(1, first_position + POSITIONS[:count])
+      Curses.addstr('count')
+      Curses.setpos(1, first_position + POSITIONS[:average_time])
+      Curses.addstr('avg time')
+      Curses.setpos(1, first_position + POSITIONS[:max_time])
+      Curses.addstr('max time')
+      Curses.setpos(1, first_position + POSITIONS[:errors])
+      Curses.addstr('errors')
+      Curses.setpos(1, first_position + POSITIONS[:error_percent])
+      Curses.addstr('error %')
+      Curses.setpos(1, first_position + POSITIONS[:throughput])
+      Curses.addstr('throughput')
+      Curses.setpos(2, 2)
+      Curses.addstr('-' * (first_position + TOTAL_LENGTH))
+      line = 3
+      names.each do |name|
+        Curses.setpos(line, 1)
+        Curses.addstr(divider_string)
+        Curses.setpos(line, 3)
+        Curses.addstr(name)
+        line += 1
+      end
+      Curses.setpos(line, 1)
+      Curses.addstr(divider_string)
+      line += 1
+      Curses.setpos(line, 1)
+      Curses.addstr(divider_string)
+
+      Curses.setpos(line, 3)
+      Curses.addstr('TOTAL')
+      line += 1
+      Curses.setpos(line, 2)
+      Curses.addstr('-' * (first_position + TOTAL_LENGTH))
+    end
+
+    def divider_string
+      first_position = '|' + (' ' * (@longest_name + 2))
+      first_position + '|          |          |          |          |          |             |'
+    end
+
+    def close
+      Curses.curs_set(1)
+      Curses::close_screen
+    end
+
+    def write_debug(file)
+      (0..Curses.lines).each do |line|
+        line_string = ''
+        (0..Curses.cols).each do |col|
+          Curses.setpos(line, col)
+          line_string << Curses.inch.chr
+        end
+        line_string.strip!
+        unless line_string.empty?
+          file.puts(line_string)
+        end
+      end
+      file.flush
+    end
+  end
+end

data/lib/front_end_loader.rb

@@ -0,0 +1,10 @@
+require 'patron'
+require 'uri'
+
+%w(experiment request request_manager screen).each do |file|
+  require_relative "front_end_loader/#{file}"
+end
+
+module FrontEndLoader
+  VERSION = '0.2.2'
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: front_end_loader
+version: !ruby/object:Gem::Version
+  version: 0.2.3
+  prerelease: 
+platform: ruby
+authors:
+- Aubrey Holland
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: patron
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'Front End Loader allows clients to declare load tests using a pure-Ruby
+  DSL.
+
+  This means that it is very simple to pass data between requests or to interact
+
+  with your systems in dynamic, complex ways.
+
+'
+email: aubreyholland@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- front_end_loader.gemspec
+- lib/front_end_loader.rb
+- lib/front_end_loader/experiment.rb
+- lib/front_end_loader/request.rb
+- lib/front_end_loader/request_manager.rb
+- lib/front_end_loader/screen.rb
+homepage: https://github.com/brewster/front_end_loader
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.5
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 2
+summary: A framework for doing declarative load testing in ruby
+test_files: []