bigbench 0.0.1

data/lib/bigbench/executor.rb

@@ -0,0 +1,131 @@
+module BigBench
+  
+  # Dispatches the command line commands to BigBench calls. Available commands are:
+  #
+  # :include: executor.txt
+  module Executor
+    
+    COMMANDS = [
+      "--help", "show help",
+      "run local PATH_TO_TEST",
+      "run bots PATH_TO_TEST [REDIS_URL_WITH_PORT REDIS_PASSWORD]",
+      "start bot [REDIS_URL_WITH_PORT REDIS_PASSWORD]",
+      "reset all [REDIS_URL_WITH_PORT REDIS_PASSWORD]"
+      ]
+    
+    # Is thrown when the command is not known
+    class InvalidCommand < StandardError
+      def message
+        puts "\n\n"
+        puts "Sorry, could not compile your command. Please enter one of the following commands:\n\n"
+        COMMANDS.each{ |command| puts command }
+        puts " "
+        
+        "Sorry, could not compile your command."
+      end
+    end
+    
+    # Parses and runs the BigBench funtion that is supplied via the commandline's ARGV. It
+    # throws an <tt>InvalidCommand</tt> exception if the command is unknown.
+    def self.run!(argv)
+      BigBench::Output.start
+      
+      check_arguments!(argv)
+      send to_executor_method(argv), argv
+      
+      BigBench::Output.done
+    end
+    
+    private
+    
+    # Maps the incoming ARGV to a method
+    def self.to_executor_method(argv)
+      return "show_help" if argv.first == "--help"
+      "#{argv[0]}_#{argv[1]}".to_sym
+    end
+    
+    # Checks if the supplied ARGV has a valid and useable form
+    def self.check_arguments!(argv)
+      raise InvalidCommand.new if argv.nil? or argv.empty?
+      raise InvalidCommand.new unless respond_to?(to_executor_method(argv))
+      true
+    end
+    
+    # Runs a local test with the specified test.rb. For this mode no redis is needed.
+    def self.run_local(argv)
+      BigBench.load_test! File.open(argv[2], "rb"){ |file| file.read }
+      BigBench.run!
+      BigBench.write_local_trackings_to_file!
+    end
+    
+    # Runs a test on all available bots with the specified test.rb
+    #
+    #    bigbench run bots test.rb http://localhost:6379 password
+    #
+    def self.run_bots(argv)
+      
+      # Load and validate tests
+      test = File.open(argv[2], "rb"){ |file| file.read }
+      BigBench.load_test!(test)
+      BigBench.config.mode = :bots
+      
+      # Initialize redis
+      argv.shift(3)
+      BigBench::Store.setup!(*argv)
+      
+      # Load current test to redis & start bots
+      BigBench::Store.test = test
+      BigBench::Store.start
+      BigBench::Output.deployed_test
+      
+      # Wait for bots to run the tests
+      @is_running = true
+      timer = Thread.new{
+        sleep(BigBench.duration.to_i)
+        BigBench::Store.stop
+        @is_running = false
+      }
+      
+      BigBench::Output.starting_bots_loop
+      loop{
+        bots = BigBench::Store.bots
+        BigBench::Output.running_bots_loop(bots)
+        sleep(1)
+        break if !@is_running and bots.size == 0
+      }
+      
+      # Gather trackings from redis and write them to the file
+      BigBench::Output.finished_bots_loop
+      BigBench.write_store_trackings_to_file!
+      BigBench::Store.reset!
+    end
+    
+    # Starts the bot that listens for tests on the redis
+    def self.start_bot(argv)
+      argv.shift(2)
+      BigBench::Store.setup!(*argv)
+      
+      loop {
+        BigBench::Output.bot_is_checking
+        BigBench::Bot.check_test!
+        sleep(BigBench.config.bot_checks_every.to_i)
+      }
+    end
+    
+    # Shows the command line help
+    def self.show_help(argv)
+      File.open("lib/bigbench/help/executor.txt", "rb"){ |file| file.read }
+    end
+    
+    # Resets everything
+    def self.reset_all(argv)
+      argv.shift(2)
+      BigBench::Store.setup!(*argv)
+      BigBench::Store.reset!
+      BigBench::Configuration.reset!
+      BigBench::Benchmark.reset!
+      BigBench::Output.reset
+    end
+    
+  end
+end

data/lib/bigbench/float_extensions.rb

@@ -0,0 +1,6 @@
+# Adds the <tt>to_milliseconds</tt> method to any float value
+class Float
+  def to_milliseconds
+    (1000 * self).to_i
+  end
+end

data/lib/bigbench/fragment.rb

@@ -0,0 +1,119 @@
+module BigBench
+  
+  # A fragment represents a single http request inside a benchmark. It is executed by the benchmark and resides inside the benchmark block in the test
+  # reciepts:
+  #
+  #   benchmark "index page" => "http://localhost:3000" do
+  #     # Fragments
+  #   end
+  #
+  # 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"
+  #
+  module Fragment
+    
+    @fragments = []
+    @benchmark = nil
+    
+    class Fragment
+      
+      attr_accessor :benchmark
+      attr_accessor :path
+      attr_accessor :method
+      attr_accessor :params
+      attr_accessor :uri
+      
+      def initialize benchmark, path, method, params = {}
+        @benchmark, @path, @method, @params = benchmark, path, method, params
+        @uri = URI(@benchmark.uri.to_s + @path)
+      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
+      end
+      
+      # Adds the current tracking result as a hash to the benchmark's tracker
+      def track!(start, stop, response)
+        @benchmark.tracker.track(
+          {
+            :elapsed    => (stop - benchmark.start).to_f,
+            :start      => start.to_f,
+            :stop       => stop.to_f,
+            :duration   => (stop - start).to_milliseconds,
+            :benchmark  => @benchmark.name,
+            :url        => @uri.to_s,
+            :path       => @uri.request_uri,
+            :method     => @method,
+            :status     => response.code
+          }
+        )
+      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, {})
+    end
+    
+    # Performs a POST request to the given url, e.g.
+    # 
+    #     post "/login", { :user => "some@sample.com", :password => "secret" }
+    #
+    def self.post(path, params = {})
+      @fragments << Fragment.new(@benchmark, path, :post, params)
+    end
+    
+    # Performs a PUT request to the given url, e.g.
+    # 
+    #     put "/books", { :book => "Some book content" }
+    #
+    def self.put(path, params = {})
+      @fragments << Fragment.new(@benchmark, path, :put, params)
+    end
+    
+    # Performs a DELETE request to the given url, e.g.
+    # 
+    #     delete "/books/5", { :user => "some@sample.com", :password => "secret" }
+    #
+    def self.delete(path, params = {})
+      @fragments << Fragment.new(@benchmark, path, :delete, params)
+    end
+    
+    # Evaluates a benchmark block full of puts and gets and returns an array of fully configured fragments for it
+    def self.parse(benchmark, &block)
+      reset!
+      return [] if block.nil?
+      @benchmark = benchmark
+      module_exec(&block)
+      @fragments
+    end
+    
+    # Reset all fragments
+    def self.reset!
+      @benchmark = nil
+      @fragments = []
+    end
+    
+  end
+end

data/lib/bigbench/help/executor.txt

@@ -0,0 +1,17 @@
+Usage:
+  # Local Testing
+  bigbench run local PATH_TO_TEST                                       # Runs a test from the local machine. No redis needed.
+
+  # Remote Testing
+  bigbench run bots PATH_TO_TEST [REDIS_URL_WITH_PORT REDIS_PASSWORD]   # Deploys and starts the test on all bots
+  bigbench start bot [REDIS_URL_WITH_PORT REDIS_PASSWORD]               # Starts a bot on a remote machine
+  
+  # Reseting
+  bigbench reset all                                                    # Resets everything
+
+  # Help
+  bigbench --help || show help                                          # Displays this help
+
+Options:
+  REDIS_URL_WITH_PORT   # Defaults to http://localhost:6379
+  REDIS_PASSWORD        # Defaults to no password

data/lib/bigbench/initializers.rb

@@ -0,0 +1,2 @@
+# ActiveSupport threading bug fix
+{ :unthreaded => :hash }.to_json

data/lib/bigbench/output.rb

@@ -0,0 +1,116 @@
+module BigBench
+  
+  # This module is used to keep all the command line outputs in a single place. The output module gets notified of the code and
+  # can then do what it want's with this information.
+  module Output
+    
+    mattr_accessor :start
+    mattr_accessor :trackings
+    
+    @start = Time.now
+    @trackings = 1
+    
+    def self.start
+      puts "-> Started BigBench at #{@start = Time.now}\n"
+      $stdout.flush
+    end
+    
+    def self.done
+      puts "\n-> Done. Took #{Time.now - @start} seconds."
+      $stdout.flush
+    end
+    
+    def self.reset
+      puts "-> Resetting everything."
+      $stdout.flush
+    end
+    
+    def self.loaded_tests
+      puts "\n-> Loading\n"
+      puts "Loaded #{BigBench.benchmarks.size} benchmarks. Benchmark will take #{BigBench.duration} seconds"
+      $stdout.flush
+    end
+    
+    def self.running_benchmarks
+      puts "\n-> Running\n"
+      puts "Running #{BigBench.benchmarks.size} benchmarks."
+      $stdout.flush
+      
+      Thread.new{
+        loop {
+          sleep(1)
+          progress = Time.now - @start
+          remaining = BigBench.duration.to_i - progress
+          percent = ((progress.to_f / BigBench.duration.to_f).to_f * 100).to_i
+          print "\r#{percent}% - #{progress.to_i} seconds elapsed. #{remaining.to_i} seconds remaining."
+          if percent > 99
+            print "\r100% Done                                                                                                        \n"
+            break
+          end
+        }
+      }
+    end
+    
+    def self.finished_running_benchmarks
+      puts "Finished #{BigBench.benchmarks.size} benchmarks."
+      $stdout.flush
+    end
+    
+    def self.writing_trackings(count)
+      target = BigBench.config.mode == :bot ? 'redis' : BigBench.config.output
+      puts "\n-> Writing\n"
+      puts "Writing #{@trackings = count} trackings to #{target}."
+      $stdout.flush
+    end
+    
+    def self.wrote_trackings(count)
+      percent = ((count.to_f / @trackings.to_f).to_f * 100).to_i
+      $stdout.flush
+      print "\r#{percent}%"
+    end
+    
+    def self.finished_writing_trackings(count)
+      print "\r100% Done                                                                                                              \n"
+      target = BigBench.config.mode == :bot ? 'redis' : BigBench.config.output
+      puts "\nWrote #{count} trackings to #{target}."
+      $stdout.flush
+    end
+    
+    def self.deployed_test
+      puts "Deployed test to the redis store."
+      $stdout.flush
+    end
+    
+    def self.starting_bots_loop
+      puts "\n-> Running\n"
+      puts "Running benchmarks on bots."
+    end
+    
+    def self.running_bots_loop(bots)
+      progress = Time.now - @start
+      remaining = BigBench.duration.to_i - progress
+      percent = ((progress.to_f / BigBench.duration.to_f).to_f * 100).to_i
+      info = " - Waiting for bots to finish" if percent > 100
+      $stdout.flush
+      print "\r#{percent}% - #{progress.to_i} seconds elapsed. #{remaining.to_i} seconds remaining. #{bots.size} Active Bots#{info}  "
+    end
+    
+    def self.finished_bots_loop
+      print "\r100% Done                                                                                                            \n"
+      puts "Finished bots test."
+      $stdout.flush
+    end
+    
+    def self.bot_is_checking
+      puts "Checking for new tests at #{Time.now}"
+      $stdout.flush
+    end
+    
+    def self.bot_received_test_instructions
+      puts "\n-> Received\n"
+      puts "Received test instructions\n"
+      $stdout.flush
+    end
+    
+  end
+end

data/lib/bigbench/runner.rb

@@ -0,0 +1,52 @@
+module BigBench
+  
+  # The runner runs all available benchmarks and returns as soon as all of them are finished. Additionally it allows the loading
+  # of reciepts from files or the redis storage.
+  module Runner
+    
+    # Is thrown when no benchmarks are defined
+    class NoBenchmarksDefined < StandardError
+      def message
+        "Sorry, I couldn't find any benchmarks!"
+      end
+    end
+    
+    # Runs all benchmarks
+    def self.run!
+      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 }
+    end
+    
+  end
+  
+  # Runs all initialized benchmarks
+  def self.run!
+    BigBench::Output.running_benchmarks
+    Runner.run!
+    BigBench::Output.finished_running_benchmarks
+  end
+  
+  # Loads a test from a string file that is either parsed from a local file or retreived from the key-value store.
+  #
+  #    benchmark_string = 'benchmark "index page" => "http://localhost:3000" do
+  #        get "/"
+  #    end'
+  #    
+  #    BigBench.load_test!(benchmark_string)
+  #
+  def self.load_test!(test)
+    BigBench::Benchmark.reset!
+    eval(test)
+    check_config!
+    BigBench::Output.loaded_tests
+  end
+  
+end