bigbench 0.0.1 → 0.0.2

data/lib/bigbench.rb

@@ -1,5 +1,7 @@
 require 'redis'
 require 'net/http'
+require 'eventmachine'
+require 'em-http'
 require 'active_support/secure_random'
 require 'active_support/all'
 
@@ -7,6 +9,7 @@ require "bigbench/float_extensions"
 require "bigbench/version"
 require "bigbench/configuration"
 require "bigbench/benchmark"
+require 'bigbench/benchmark/looper'
 require "bigbench/fragment"
 require "bigbench/tracker"
 require "bigbench/runner"

data/lib/bigbench/benchmark.rb

@@ -7,11 +7,12 @@ module BigBench
   #       get "/"
   #       get "/blog"
   #       get "/imprint"
+  #       get "/admin", :basic_auth => ['admin', 'secret']
   #    end
   #
   #    benchmark "login and logout" => "http://localhost:3000" do
-  #       post "/login", { :name => "test@user.com", :password => "secret" }
-  #       post "/logout"
+  #       post "/login", :params => { :name => "test@user.com", :password => "secret" }
+  #       post "/logout", :params => { :name => "test@user.com" }
   #    end
   #
   # Those benchmarks automatically get added to the modules benchmark array and can be retrieved with the BigBench#benchmarks method.
@@ -23,7 +24,7 @@ module BigBench
     
       attr_accessor :name
       attr_accessor :uri
-      attr_accessor :threads
+      attr_accessor :users
       attr_accessor :duration
       attr_accessor :fragments
       attr_accessor :tracker
@@ -34,7 +35,7 @@ module BigBench
       # Initizalizes a new benchmark
       def initialize(name, url, options, &block)
         @name, @uri, @tracker, @is_running, @runs = name, URI(url), Tracker::Tracker.new, false, 0
-        @threads  = options[:threads]   || BigBench.config.threads
+        @users  = options[:users]   || BigBench.config.users
         @duration = options[:duration]  || BigBench.config.duration
         @fragments = BigBench::Fragment.parse(self, &block)
       end
@@ -42,24 +43,12 @@ module BigBench
       # Execute this benchmark
       def run!
         
-        # Setup timer
+        # Setup Timer
         timer = Thread.new{ sleep(@duration); @is_running = false }
         @start, @is_running = Time.now, true
         
-        # Benchmark loop
-        @running_threads = []
-        @threads.times do
-          @running_threads << Thread.new do
-            while is_running? do
-              Net::HTTP.start(uri.host, uri.port) do |http|
-                @fragments.each{ |fragment| fragment.run!(http) }
-              end
-            end
-          end
-        end
-        
-        # Stop execution
-        @running_threads.each { |thread| thread.join }
+        # Loop Requests
+        @users.times { Looper.new(self).loop! }
         @runs += 1
       end
       
@@ -101,11 +90,12 @@ module BigBench
   #       get "/"
   #       get "/blog"
   #       get "/imprint"
+  #       get "/admin", :basic_auth => ['admin', 'secret']
   #    end
   #
   #    benchmark "login and logout" => "http://localhost:3000" do
-  #       post "/login", { :name => "test@user.com", :password => "secret" }
-  #       post "http://localhost:3000/logout"
+  #       post "/login",  :params => { :name => "test@user.com", :password => "secret" }
+  #       post "/logout", :params => { :name => "test@user.com" }
   #    end
   #
   def self.benchmark(options)

data/lib/bigbench/benchmark/looper.rb

@@ -0,0 +1,43 @@
+module BigBench
+  module Benchmark
+    
+    class Looper
+      
+      attr_accessor :benchmark
+      attr_accessor :loops
+      
+      def initialize(benchmark)
+        @benchmark, @loops = benchmark, 0
+        @fragments = Fiber.new { @benchmark.fragments.cycle{ |fragment| Fiber.yield(fragment) } }
+      end
+      
+      def loop!
+        return unless @benchmark.is_running?
+        @loops += 1
+        
+        # Start next fragment
+        fragment = next_fragment
+        start = Time.now
+        http = fragment.run!
+        
+        # Success
+        http.callback do |http|
+          fragment.track!(start, Time.now, http)
+          loop!
+        end
+        
+        # Error
+        http.errback do |http|
+          fragment.track!(start, Time.now, http)
+          loop!
+        end
+        
+      end
+      
+      def next_fragment
+        @fragments.resume
+      end
+      
+    end
+  end
+end

data/lib/bigbench/configuration.rb

@@ -3,9 +3,10 @@ module BigBench
   # The configuration is configured in the test reciepts and looks like this:
   #
   #    BigBench.configure = {
-  #      :duration => 10.seconds,
-  #      :output   => "test.ljson",
-  #      :threads  => 20
+  #      :duration    => 10.seconds,
+  #      :output      => "test.ljson",
+  #      :users       => 20,
+  #      :basic_auth  => ['username', 'secret']
   #    }
   # 
   # Single values can be set and retrieved like this:
@@ -19,7 +20,11 @@ module BigBench
   # [output*]     The file where the results should be written to. Usually one takes the <tt>*.ljson</tt> format which is simply a file
   #               that contains a fully valid JSON object on every line. This makes it easy to process the results later on, because there's
   #               no need to parse the whole results JSON, which can get huge, at once.
-  # [threads]     How many threads execute the benchmarks. This can be overridden by every benchmark and defaults to <tt>1</tt>.
+  # [users]       How many users execute the benchmarks concurrently. This can be overridden by every benchmark and defaults to <tt>1</tt>.
+  # [basic_auth]  A basic authentication that is used by ALL requests. This can be overridden per fragment in every benchmark.
+  #
+  #                 BigBench.config.basic_auth = ['username', 'password']
+  #
   module Configuration
     
     # The main config object for BigBench. It allows config options to
@@ -27,14 +32,15 @@ module BigBench
     class Config
       attr_accessor :duration
       attr_accessor :output
-      attr_accessor :threads
+      attr_accessor :users
       attr_accessor :mode
       attr_accessor :bot_checks_every
+      attr_accessor :basic_auth
       
-      VALIDATE_OPTIONS = [:duration, :output, :threads]
+      VALIDATE_OPTIONS = [:duration, :output, :users]
       
       def initialize
-        @threads, @duration, @mode, @bot_checks_every = 1, 1.second, :local, 1.minute
+        @users, @duration, @mode, @bot_checks_every = 1, 1.second, :local, 1.minute
       end
       
       def self.add_option(name)
@@ -81,9 +87,10 @@ module BigBench
   # Configure the benchmark by supplying a hash of options like this:
   # 
   #    BigBench.configure = {
-  #      :duration => 10.seconds,
-  #      :output   => "test.ljson",
-  #      :threads  => 20
+  #      :duration    => 10.seconds,
+  #      :output      => "test.ljson",
+  #      :users       => 20,
+  #      :basic_auth  => ['username', 'secret']
   #    }
   #
   # Those values can then be set and retreived with <tt>BigBench.config.duration</tt>, ...

data/lib/bigbench/fragment.rb

@@ -10,10 +10,22 @@ module BigBench
   # Possible fragment types are the HTTP verbs, like GET, POST, PUT and DELETE. They look like this:
   #
   #   get     "/"
-  #   post    "/login/new", { :name => "a name", :password => "secret" }
-  #   put     "/books",     { :name => "A Book title", :rating => 30.4 }
-  #   delete  "/books/5"
+  #   post    "/login/new"
+  #   put     "/books"
+  #   delete  "/books/5", :params => { :token => '87bas67dfjgbrjbbgbi6ica7s0b3t0' }
+  #   get     "/admin", :basic_auth => ['username', 'password']
   #
+  # After any fragment an options hash can be appended. Possible options are:
+  #
+  # [:basic_auth]   Supply a basic auth user and password for the request. The request then looks like this:
+  #                   
+  #                   get "/", :basic_auth => ['username', 'password']
+  #
+  # [:params]       Supply params for the request body, like e.g. form data:
+  #       
+  #                   post "/books/new", :params => { :book => { :title => "Metaprogramming Ruby", :publisher => "O'Reilly" } }
+  #                   post "/trackings/add", :params => { :name => "Tommy" }
+  #         
   module Fragment
     
     @fragments = []
@@ -24,34 +36,22 @@ module BigBench
       attr_accessor :benchmark
       attr_accessor :path
       attr_accessor :method
-      attr_accessor :params
+      attr_accessor :options
       attr_accessor :uri
       
-      def initialize benchmark, path, method, params = {}
-        @benchmark, @path, @method, @params = benchmark, path, method, params
+      def initialize benchmark, path, method, options = {}
+        @benchmark, @path, @method, @options, @request_options = benchmark, path, method, options, {}
         @uri = URI(@benchmark.uri.to_s + @path)
+        configure_options
       end
       
       # Initiates the request in the context of a <tt>Net::HTTP.start</tt> block
-      def run!(http)
-        request = case @method
-          when :get     then Net::HTTP::Get.new(@uri.request_uri)
-          when :post    then Net::HTTP::Post.new(@uri.request_uri)
-          when :put     then Net::HTTP::Put.new(@uri.request_uri)
-          when :delete  then Net::HTTP::Delete.new(@uri.request_uri)
-          else nil
-        end
-        
-        start = Time.now
-        response = http.request(request)
-        stop = Time.now
-        
-        track!(start, stop, response)
-        response
+      def run!
+        EventMachine::HttpRequest.new(@uri.to_s).send(@method, @request_options)
       end
       
       # Adds the current tracking result as a hash to the benchmark's tracker
-      def track!(start, stop, response)
+      def track!(start, stop, http)
         @benchmark.tracker.track(
           {
             :elapsed    => (stop - benchmark.start).to_f,
@@ -62,42 +62,55 @@ module BigBench
             :url        => @uri.to_s,
             :path       => @uri.request_uri,
             :method     => @method,
-            :status     => response.code
+            :status     => http.response_header.status
           }
         )
       end
+      
+      private
+      
+      def configure_options
+        
+        # Basic Auth
+        @request_options[:head] = { 'authorization' => BigBench.config.basic_auth } unless BigBench.config.basic_auth.nil?
+        @request_options[:head] = { 'authorization' => @options[:basic_auth] }      unless @options[:basic_auth].nil?
+        
+        # Body
+        @request_options[:body] = @options[:params] unless @options[:params].nil?
+        
+      end
     end
     
     # Performs a GET request to the given url, e.g.
     # 
     #     get "/some/page"
     #
-    def self.get(path)
-      @fragments << Fragment.new(@benchmark, path, :get, {})
+    def self.get(path, options = {})
+      @fragments << Fragment.new(@benchmark, path, :get, options)
     end
     
     # Performs a POST request to the given url, e.g.
     # 
-    #     post "/login", { :user => "some@sample.com", :password => "secret" }
+    #     post "/login"
     #
-    def self.post(path, params = {})
-      @fragments << Fragment.new(@benchmark, path, :post, params)
+    def self.post(path, options = {})
+      @fragments << Fragment.new(@benchmark, path, :post, options)
     end
     
     # Performs a PUT request to the given url, e.g.
     # 
-    #     put "/books", { :book => "Some book content" }
+    #     put "/books"
     #
-    def self.put(path, params = {})
-      @fragments << Fragment.new(@benchmark, path, :put, params)
+    def self.put(path, options = {})
+      @fragments << Fragment.new(@benchmark, path, :put, options)
     end
     
     # Performs a DELETE request to the given url, e.g.
     # 
-    #     delete "/books/5", { :user => "some@sample.com", :password => "secret" }
+    #     delete "/books/5"
     #
-    def self.delete(path, params = {})
-      @fragments << Fragment.new(@benchmark, path, :delete, params)
+    def self.delete(path, options = {})
+      @fragments << Fragment.new(@benchmark, path, :delete, options)
     end
     
     # Evaluates a benchmark block full of puts and gets and returns an array of fully configured fragments for it

data/lib/bigbench/runner.rb

@@ -16,13 +16,14 @@ module BigBench
       raise NoBenchmarksDefined.new if BigBench.benchmarks.empty?
       
       # Run all benchmarks
-      @running_threads = []
-      BigBench.benchmarks.each do |benchmark|
-        @running_threads << Thread.new{ benchmark.run! }
-      end
-      
-      # Wait for them to finish
-      @running_threads.each{ |thread| thread.join }
+      EventMachine.run {
+        
+        # Start Timer
+        Thread.new { sleep(BigBench.duration.to_i); EventMachine.stop }
+        
+        # Start Benchmarks
+        BigBench.benchmarks.each{ |benchmark| benchmark.run! }
+      }
     end
     
   end

data/lib/bigbench/tracker.rb

@@ -18,7 +18,7 @@ module BigBench
       end
       
       def track object
-        @trackings << object.to_json
+        @trackings << object
       end
     end
     
@@ -33,7 +33,7 @@ module BigBench
     BigBench.benchmarks.each do |benchmark|
       benchmark.tracker.trackings.each do |tracking|
         BigBench::Output.wrote_trackings(counter) if counter % 100 == 0
-        BigBench::Store.add_tracking(tracking)
+        BigBench::Store.add_tracking(tracking.to_json)
         counter += 1
       end
     end
@@ -51,7 +51,7 @@ module BigBench
       BigBench.benchmarks.each do |benchmark|
         benchmark.tracker.trackings.each do |tracking|
           BigBench::Output.wrote_trackings(counter) if counter % 100 == 0
-          file.write tracking + "\n"
+          file.write tracking.to_json + "\n"
           counter += 1
         end
       end

data/lib/bigbench/version.rb

@@ -1,3 +1,3 @@
 module BigBench
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/benchmark_spec.rb

@@ -15,18 +15,18 @@ describe BigBench::Benchmark do
     
     BigBench.benchmarks.size.should == 1
     BigBench.benchmarks.first.fragments.size.should == 1
-    BigBench.benchmarks.first.threads.should == 1
+    BigBench.benchmarks.first.users.should == 1
     BigBench.benchmarks.first.fragments.first.uri.to_s.should == "http://localhost:3001/"
   end
   
-  it "should add a benchmark with custom threads" do    
-    BigBench.benchmark "a test page" => "http://localhost:3001", :threads => 20 do
+  it "should add a benchmark with custom users" do    
+    BigBench.benchmark "a test page" => "http://localhost:3001", :users => 20 do
       get "/"
     end
     
     BigBench.benchmarks.size.should == 1
     BigBench.benchmarks.first.fragments.size.should == 1
-    BigBench.benchmarks.first.threads.should == 20
+    BigBench.benchmarks.first.users.should == 20
   end
   
   it "should return the longest duration of all benchmarks" do
@@ -49,17 +49,24 @@ describe BigBench::Benchmark do
     
     it "make 3 GETs" do
       
-      benchmark = BigBench.benchmark "a test page" => "http://localhost:3001" do
+      benchmark = BigBench.benchmark "a test page" => "http://localhost:3001", :users => 5 do
         get "/"
         get "/index"
         get "/blog"
       end
       
-      benchmark.run!
+      EventMachine.run{
+        Thread.new{ sleep(2); EventMachine.stop }
+        benchmark.run!
+      }
+      
       benchmark.tracker.trackings.size.should > 100
       benchmark.runs.should == 1
       
-      benchmark.run!
+      EventMachine.run{
+        Thread.new{ sleep(2); EventMachine.stop }
+        benchmark.run!
+      }
       benchmark.tracker.trackings.size.should > 100
       benchmark.runs.should == 2
     end

data/spec/configure_spec.rb

@@ -7,12 +7,12 @@ describe BigBench::Configuration do
     BigBench.configure = {
       :duration => 10.seconds,
       :output   => "test.ljson",
-      :threads  => 20
+      :users    => 20
     }
     
     BigBench.config.duration.should == 10.seconds
     BigBench.config.output.should == "test.ljson"
-    BigBench.config.threads.should == 20
+    BigBench.config.users.should == 20
     
   end
   
@@ -27,7 +27,7 @@ describe BigBench::Configuration do
     BigBench.configure = {
       :duration => 10.seconds,
       :output   => "test.ljson",
-      :threads  => 20
+      :users    => 20
     }
     BigBench.config.should be_valid
   end