hansel 0.1.7 → 0.2.0

data/README.md

@@ -0,0 +1,103 @@
+# hansel
+
+Hansel is a pure ruby driver for httperf for automated load and performance testing. It will load 
+a job queue file, in a yaml format, run httperf with each job
+
+# Installing Httperf and Hansel
+
+## Httperf
+
+  For Linux (Ubuntu):
+
+    apt-get update && apt-get -y install rubygems httperf
+
+  On MacOS X using homebrew:
+
+    brew install httperf
+
+  finally:
+  
+    gem install hansel
+
+## Optional -- Installing Octave using macports (warning: long!)
+
+    sudo port install octave
+
+# Example usage
+
+Create a job queue file in ~/.hansel/jobs.yml:
+
+    ---
+    - :server: www.example.com
+      :uri: /
+      :num_conns: 50
+      :low_rate: 10
+      :high_rate: 50
+      :rate_step: 10
+
+    - :server: www.apple.com
+      :uri: /
+      :num_conns: 50
+      :low_rate: 10
+      :high_rate: 50
+      :rate_step: 10
+
+and run Hansel
+
+      hansel --verbose --format=octave
+
+By default, the output is written into the ~/hansel_output directory. When the octave format is
+specified, it uses the default template octave.m.erb in the project templates. Here is a sample
+output from the previous job:
+
+    rate              = [5, 10, 15, 20];
+    request_rate      = [5.1, 9.3, 12.9, 15.8];
+    connection_rate   = [5.1, 9.3, 12.9, 15.8];
+    reply_rate_avg    = [0.0, 0.0, 0.0, 0.0];
+    reply_rate_max    = [0.0, 0.0, 0.0, 0.0];
+    reply_time        = [88.4, 93.4, 89.2, 89.1];
+    reply_rate_stddev = [0.0, 0.0, 0.0, 0.0];
+    errors            = [0, 0, 0, 0];
+
+    plot(rate, request_rate, '-k*');
+    hold on;
+    plot(rate, connection_rate, '-kd');
+    hold on;
+    plot(rate, reply_rate_max, '-kp');
+    hold on;
+    plot(rate, reply_rate_max, '-k+');
+    hold on;
+    plot(rate, reply_rate_stddev, '-kh');
+    hold on;
+    plot(rate, reply_time, '-g*');
+    hold on;
+    plot(rate, errors, '-r*');
+
+    grid on;
+
+    axis([0 20 0 20]);
+    title('Hansel report for www.example.com:80/ (10 connections per run)')
+    xlabel('Demanded Request Rate');
+    legend('Request Rate', 'Connection Rate', 'Avg. reply rate', 'Max. reply rate', 'Reply rate StdDev', 'Reply time', 'Errors');
+    print('/Users/paulm/hansel_output/hansel-10.m.png', '-dpng')
+    
+Run octave on it will produce graph as a png file.
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## References
+
+"HTTP Perforance Testing with httperf":http://agiletesting.blogspot.com/2005/04/http-performance-testing-with-httperf.html
+"Perforance vs Load Testing":http://agiletesting.blogspot.com/2005/04/more-on-performance-vs-load-testing.html
+
+## Copyright
+
+Copyright (c) 2010 Paul Mylchreest. See LICENSE for details.

data/Rakefile

@@ -1,6 +1,11 @@
 require 'rubygems'
 require 'rake'
-require "spec/rake/spectask"
+
+begin
+  require "spec/rake/spectask"
+rescue LoadError
+  puts "rspec (or a dependency) not available. Install it with: gem install rspec"
+end
 
 task :default => :spec
 
@@ -19,11 +24,14 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name        = "hansel"
+    gem.executables = "hansel"
     gem.summary     = %Q{Ruby driver for httperf - automated load and performance testing}
     gem.description = %Q{Ruby driver for httperf - automated load and performance testing}
     gem.email       = "paul.mylchreest@mac.com"
     gem.homepage    = "http://github.com/xlymian/hansel"
     gem.authors     = ["Paul Mylchreest"]
+    gem.add_dependency('rspec')
+    gem.add_dependency 'typhoeus'
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.7
+0.2.0

data/bin/hansel

@@ -10,10 +10,7 @@ class File
   end
 end
 
-require File.here '/../lib/arg_parser'
-require File.here '/../lib/config'
 require File.here '/../lib/hansel'
-
-options = Hansel::Config.new(ARGV).options
+options = HanselCore::ArgParser.new( ARGV ).parse
 exit if options.exit
-Hansel::Hansel.new(options).run
+HanselCore::Hansel.new( options ).load_job_queue.run

data/hansel.gemspec

@@ -5,38 +5,43 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hansel}
-  s.version = "0.1.7"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Paul Mylchreest"]
-  s.date = %q{2010-05-08}
+  s.date = %q{2010-06-13}
   s.default_executable = %q{hansel}
   s.description = %q{Ruby driver for httperf - automated load and performance testing}
   s.email = %q{paul.mylchreest@mac.com}
   s.executables = ["hansel"]
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+     "README.md"
   ]
   s.files = [
     ".document",
      ".gitignore",
      "LICENSE",
-     "README.rdoc",
+     "README.md",
      "Rakefile",
      "VERSION",
      "bin/hansel",
      "hansel.gemspec",
-     "lib/arg_parser.rb",
-     "lib/config.rb",
-     "lib/csv_formatter.rb",
      "lib/hansel.rb",
-     "lib/httperf_result.rb",
-     "lib/httperf_result_parser.rb",
-     "lib/octave_formatter.rb",
-     "lib/yaml_formatter.rb",
+     "lib/hansel/arg_parser.rb",
+     "lib/hansel/formatting/csv_formatter.rb",
+     "lib/hansel/formatting/formatting.rb",
+     "lib/hansel/formatting/octave_formatter.rb",
+     "lib/hansel/formatting/yaml_formatter.rb",
+     "lib/hansel/hansel.rb",
+     "lib/hansel/httperf/httperf.rb",
+     "lib/hansel/httperf_result.rb",
+     "lib/hansel/httperf_result_parser.rb",
+     "lib/hansel/job_queue/job_queue.rb",
      "spec/arg_parser_spec.rb",
+     "spec/hansel_spec.rb",
      "spec/httperf_result_parser_spec.rb",
+     "spec/jobs.yml",
      "spec/spec_helper.rb",
      "templates/octave.m.erb"
   ]
@@ -47,6 +52,7 @@ Gem::Specification.new do |s|
   s.summary = %q{Ruby driver for httperf - automated load and performance testing}
   s.test_files = [
     "spec/arg_parser_spec.rb",
+     "spec/hansel_spec.rb",
      "spec/httperf_result_parser_spec.rb",
      "spec/spec_helper.rb"
   ]
@@ -56,9 +62,15 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rspec>, [">= 0"])
+      s.add_runtime_dependency(%q<typhoeus>, [">= 0"])
     else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<typhoeus>, [">= 0"])
     end
   else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<typhoeus>, [">= 0"])
   end
 end
 

data/lib/hansel/arg_parser.rb

@@ -0,0 +1,84 @@
+module HanselCore
+  #
+  # Parse the command configuration file options and command line arguments.
+  # Command line arguments override those from the configuration file
+  # See http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/classes/OptionParser.html
+  #
+  class ArgParser
+    #
+    # Setup default values for the parsed options
+    #
+    def initialize args
+      @args     = args
+      @options  = OpenStruct.new(
+        :verbose        => false,
+        :output_format  => :yaml,
+        :output_dir     => File.join(ENV['HOME'], 'hansel_output'),
+        :template_path  => 'templates',
+        :template       => nil,
+        :exit           => false,
+        :master         => nil
+      )
+    end
+
+    #
+    # Uses OptionParser to return an OpenStruct object describing the options.
+    #
+    def parse
+      # The options specified on the command line will be collected in *options*.
+      # We set default values here.
+      OptionParser.new { |options| parse_options options}.parse!(@args)
+      @options
+    end
+
+  private
+
+    def output_options options
+      options.on("-f", "--format=format",
+          "Specify the ouptut format for the results.") do |format|
+        @options.format = format
+      end
+      options.on("-d", "--dir=output directory",
+          "Specify the ouptut directory for the results.") do |format|
+        @options.output_dir = format
+      end
+      options.on("-t", "--template=template",
+          "Specify the ouptut erb template.") do |template|
+        @options.template = template
+      end
+    end
+
+    def other_options options
+      options.on("-v", "--[no-]verbose", "Run verbosely") do |verbose|
+        @options.verbose = verbose
+      end
+
+      options.on_tail("-h", "--help", "Show this message") do
+        puts options
+        @options.exit = true
+      end
+    end
+
+    def distributed_mode_options options
+      options.on("-m", "--master=hostname[:port]",
+          "Specify the master command and control machine.") do |master|
+        @options.master = master
+      end
+    end
+
+    def version options
+      options.on_tail("--version", "Show version") do
+        puts "Hansel version #{IO.foreach('VERSION').first.strip}"
+        @options.exit = true
+      end
+    end
+
+    def parse_options options
+      options.banner = "Usage: hansel [options]"
+      options.separator "Options:"
+      %w( output_options other_options version distributed_mode_options ).map(&:to_sym).each do |method|
+          self.send method, options
+      end
+    end
+  end
+end

data/lib/{csv_formatter.rb → hansel/formatting/csv_formatter.rb}

@@ -1,31 +1,26 @@
 require 'csv'
 
-module Hansel
+module HanselCore
 
   # Output to csv format
   #
   class CsvFormatter
-    COLUMNS = %w(rate replies connection_rate request_rate reply_time net_io
-                  errors status reply_rate_min reply_rate_avg reply_rate_max
-                  reply_rate_stddev)
+    COLUMNS = %w(server port num_conns rate replies connection_rate request_rate reply_time net_io
+                  errors status reply_rate_min reply_rate_avg reply_rate_max reply_rate_stddev)
 
-    def initialize(data)
-      @data = data
-      @csv = ""
-    end
-
-    def line text
+    def self.line text
       @csv << text
       @csv << "\n"
     end
 
-    def format_line data
+    def self.format_line data
       line CSV.generate_line( COLUMNS.map { |column| data.send column.to_sym } )
     end
 
-    def format
+    def self.format results
+      @csv = ""
       line CSV.generate_line(COLUMNS)
-      @data.each { |data| format_line data } unless @data.empty?
+      results.each { |data| format_line data } unless results.empty?
       @csv
     end
   end

data/lib/hansel/formatting/formatting.rb

@@ -0,0 +1,51 @@
+module HanselCore
+  module Formatting
+    def yaml_formatter
+      load 'lib/hansel/formatting/yaml_formatter.rb'
+      File.open(output_filename, "w+") do |file|
+        file.puts YamlFormatter.format results
+      end
+    end
+
+    def csv_formatter
+      load 'lib/hansel/formatting/csv_formatter.rb'
+      File.open(output_filename, "w+") do |file|
+        file.puts CsvFormatter.format results
+      end
+    end
+
+    def octave_formatter
+      load 'lib/hansel/formatting/octave_formatter.rb'
+      num_conns = results.first.num_conns rescue nil
+      file_name = output_filename{ "-#{num_conns.to_s}" }
+      File.open(file_name, "w+") do |file|
+        file.puts OctaveFormatter.new(results, 
+          {
+            :output_file_name => file_name,
+            :template         => options.template ||
+                                  File.join( [ options.template_path, 'octave.m.erb' ] ),
+          }
+        ).format
+      end
+    end
+
+    def formatted_output
+      formatter = "#{options.format}_formatter".to_sym
+      unless self.respond_to? formatter
+        status "Using default octave_formatter"
+        octave_formatter
+      else
+        status "Using #{formatter}"
+        self.send formatter
+      end
+    end
+
+    def output_filename
+      part    = block_given? ? yield : ''
+      type    = { :yaml => 'yml', :csv => 'csv', :octave => 'm' }[options.format.to_sym]
+      server  = results.first.server
+      port    = results.first.port
+      [File.join([options.output_dir, ("#{server}:#{port}" + part)]), type].join('.')
+    end
+  end
+end

data/lib/{octave_formatter.rb → hansel/formatting/octave_formatter.rb}

@@ -1,6 +1,6 @@
 require 'erb'
 
-module Hansel
+module HanselCore
   #
   # Output to a Octave script.
   #

data/lib/hansel/formatting/yaml_formatter.rb

@@ -0,0 +1,10 @@
+module HanselCore
+  #
+  # Output to yaml format
+  #
+  class YamlFormatter
+    def self.format results
+      results.to_yaml
+    end
+  end
+end

data/lib/hansel/hansel.rb

@@ -0,0 +1,77 @@
+module HanselCore
+  #
+  # Class wrapper over httperf.
+  #
+  class Hansel
+    include Formatting
+    include Httperf
+    include JobQueue
+
+    attr_reader :results, :options
+
+    def initialize options = OpenStruct.new {}
+      @options = options
+      @results = []
+      @current_rate = nil
+      @jobs = []
+    end
+
+    def config_path
+      @config_path ||= File.join [ENV['HOME'], '.hansel']
+      FileUtils.mkdir_p @config_path unless File.exists? @config_path
+      @config_path
+    end
+
+    def output_dir
+      @output_dir ||= File.join [ENV['HOME'], 'hansel_output']
+      @output_dir
+    end
+
+    def register
+      response = Typhoeus::Request.get options.master
+      @token = JSON.parse(response.body)['token']
+    end
+
+    #
+    # Output the results based on the requested output format
+    #
+    def output
+      if options.format
+        FileUtils.mkdir_p options.output_dir
+        formatted_output
+      end
+    end
+
+    def status text
+      puts text if options.verbose
+    end
+
+    #
+    # Run httperf from low_rate to high_rate, stepping by rate_step
+    #
+    def run
+      status "starting run..."
+      while @jobs.length > 0 do
+        @current_job = @jobs.pop
+        (@current_job.low_rate.to_i..@current_job.high_rate.to_i).step(@current_job.rate_step.to_i) do |rate|
+          status "running httperf at rate: #{rate}"
+          @current_rate = rate
+          httperf
+        end
+        output
+        @results.clear
+      end
+      status "ending run..."
+    end
+
+    def run_server
+      HanselSlaveServer.hansel = self
+      HanselSlaveServer.run! :host => 'localhost', :port => 4000
+    end
+
+    trap("INT") {
+      puts "Terminating."
+      Process.exit
+    }
+  end
+end

data/lib/hansel/httperf/httperf.rb

@@ -0,0 +1,36 @@
+module HanselCore
+  module Httperf
+    def build_httperf_cmd
+      httperf_cmd = [
+        "httperf --hog",
+        "--server=#{@current_job.server}",
+        "--port=#{@current_job.port}",
+        "--uri=#{@current_job.uri}",
+        "--num-conns=#{@current_job.num_conns}",
+        "--rate=#{@current_rate}",
+        @current_job.cookie && "--add-header='Cookie: #{@current_job.cookie}\\n'"
+      ].compact.join ' '
+    end
+
+    #
+    # Runs httperf with a given request rate. Parses the output and returns
+    # a hash with the results.
+    #
+    def httperf
+      httperf_cmd = build_httperf_cmd
+      IO.popen("#{httperf_cmd} 2>&1") do |pipe|
+        status "\n#{httperf_cmd}"
+        @results << (httperf_result = HttperfResult.new({
+            :rate       => @current_rate,
+            :server     => @current_job.server,
+            :port       => @current_job.port,
+            :uri        => @current_job.uri,
+            :num_conns  => @current_job.num_conns
+          }))
+        HttperfResultParser.new(pipe).parse(httperf_result)
+      end
+      self
+    end
+
+  end
+end

data/lib/{httperf_result.rb → hansel/httperf_result.rb}

@@ -1,4 +1,4 @@
-module Hansel
+module HanselCore
   #
   # Wrapper for parsing of the httperf run result.
   #

data/lib/{httperf_result_parser.rb → hansel/httperf_result_parser.rb}

@@ -1,4 +1,4 @@
-module Hansel
+module HanselCore
   #
   # Parse httperf output.
   #

data/lib/hansel/job_queue/job_queue.rb

@@ -0,0 +1,27 @@
+module HanselCore
+  module JobQueue
+    def jobs
+      @jobs
+    end
+
+    def push_job job
+      job.port = 80 unless job.port
+      @jobs.push job
+    end
+
+    def pop_job job
+      @jobs.pop
+    end
+
+    #
+    # Load jobs from queue
+    #
+    def load_job_queue
+      (YAML.load_file File.join(config_path, 'jobs.yml')).map do |job|
+        self.push_job(OpenStruct.new job)
+      end
+      self
+    end
+
+  end
+end