stella 0.7.0.015 → 0.7.0.017

data/lib/stella/client.rb

@@ -1,6 +1,7 @@
 require "observer"
-require "tempfile"
-require 'nokogiri'
+require "nokogiri"
+
+Stella::Utils.require_vendor "httpclient", '2.1.5.2'
 
 module Stella
   class Client
@@ -21,7 +22,7 @@ module Stella
     end
     def execute(usecase, &stat_collector)
       # We need to make sure the gibbler cache has a value
-      self.gibbler if self.__gibbler_cache.nil?
+      self.gibbler if self.digest_cache.nil?
       
       http_client = create_http_client
       stats = {}
@@ -30,6 +31,8 @@ module Stella
       usecase.requests.each do |req|
         counter += 1
         
+        container.reset_temp_vars
+        
         stats ||= Benelux::Stats.new
         update(:prepare_request, usecase, req, counter)
         uri_obj = URI.parse(req.uri)
@@ -37,14 +40,13 @@ module Stella
         headers = prepare_headers(container, req.headers)
         uri = build_request_uri uri_obj, params, container
         raise NoHostDefined, uri_obj if uri.host.nil? || uri.host.empty?
-        stella_id = [Time.now, self.gibbler_cache, req.gibbler_cache, params, headers, counter].gibbler
+        stella_id = [Time.now, self.digest_cache, req.digest_cache, params, headers, counter].gibbler
         
-        Benelux.add_thread_tags :request => req.gibbler_cache
+        Benelux.add_thread_tags :request => req.digest_cache
         Benelux.add_thread_tags :retry => counter
         Benelux.add_thread_tags :stella_id => stella_id
         
-        params['__stella'] = stella_id.short
-        headers['X-Stella-ID'] = stella_id.short
+        params['__stella'] = headers['X-Stella-ID']= stella_id[0..10]
         
         meth = req.http_method.to_s.downcase
         Stella.ld "#{req.http_method}: " << "#{uri_obj.to_s} " << params.inspect
@@ -97,7 +99,7 @@ module Stella
     end
     
     def update(kind, *args)
-      changed and notify_observers(kind, self.__gibbler_cache, *args)
+      changed and notify_observers(kind, self.digest_cache, *args)
     end
   
     def run_sleeper(wait)
@@ -119,7 +121,6 @@ module Stella
       http_client = HTTPClient.new opts
       http_client.set_proxy_auth(@proxy.user, @proxy.pass) if @proxy.user
       http_client.debug_dev = STDOUT if Stella.debug? && Stella.loglev > 3
-      #http_client.set_cookie_store @cookie_file.path
       http_client.protocol_version = "HTTP/1.1"
       http_client
     end

data/lib/stella/client/container.rb

@@ -10,6 +10,7 @@ class Stella::Client
     def initialize(usecase)
       @usecase, @resources = usecase, {}
       @base_path = usecase.base_path
+      @random_value = {}
     end
     
     # This is used to handle custom exception in usecases.
@@ -30,12 +31,21 @@ class Stella::Client
         YAML.load(body)
       end
     end
-
+    
+    # Return a resource from the usecase or from this 
+    # container (in that order).
     def resource(n)
       return @usecase.resource(n) if @usecase.resources.has_key? n
       return @resources[n] if @resources.has_key? n
+      nil
     end
 
+    def reset_temp_vars
+      @random_value = {}
+      @sequential_value = {}
+      @rsequential_value = {}
+    end
+    
     def body; @response.body.content; end
     def headers; @response.header; end
       alias_method :header, :headers

data/lib/stella/data.rb

@@ -24,84 +24,137 @@ module Stella::Data
     end
     
     def random(*args)
-      input = args.size > 1 ? args : args.first
+      if Symbol === args.first
+        input, index = *args
+      elsif Array === args.first || args.size == 1
+        input = args.first
+      else
+        input = args
+      end
+        
       Proc.new do
-        value = case input.class.to_s
-        when "Symbol"
-          resource(input)
-        when "Array"
-          input
-        when "Range"
-          input.to_a
-        when "Proc"
-          input.call
-        when "Fixnum"
-          Stella::Utils.strand( input )
-        when "NilClass"
-          Stella::Utils.strand( rand(100) )
+        if @random_value[input]
+          value = @random_value[input]
+        else
+          value = case input.class.to_s
+          when "Symbol"
+            resource(input)
+          when "Array"
+            input
+          when "Range"
+            input.to_a
+          when "Proc"
+            input.call
+          when "Fixnum"
+            Stella::Utils.strand( input )
+          when "NilClass"
+            Stella::Utils.strand( rand(100) )
+          end
+          raise Stella::Testplan::Usecase::UnknownResource, input if value.nil?
+          Stella.ld "RANDVALUES: #{input} #{value.class} #{value.inspect}"
+          value = value[ rand(value.size) ] if value.is_a?(Array)
+          Stella.ld "SELECTED: #{value.class} #{value} "
+          @random_value[input] = value
         end
-        raise Stella::Testplan::Usecase::UnknownResource, input if value.nil?
-        Stella.ld "RANDVALUES: #{input} #{value.inspect}"
-        value = value[ rand(value.size) ] if value.is_a?(Array)
-        Stella.ld "SELECTED: #{value}"
+        
+        # The resource may be an Array of Arrays (e.g. a CSV file)
+        if value.is_a?(Array) && !index.nil?
+          value = value[ index ] 
+          Stella.ld "SELECTED INDEX: #{index} #{value.inspect} "
+        end
+        
         value
       end
     end
     
     def sequential(*args)
-      input = args.size > 1 ? args : args.first
+      if Symbol === args.first
+        input, index = *args
+      elsif Array === args.first || args.size == 1
+        input = args.first
+      else
+        input = args
+      end
       Proc.new do
-        value = case input.class.to_s
-        when "Symbol"
-          ret = resource(input)
-          ret
-        when "Array"
-          input
-        when "Range"
-          input.to_a
-        when "Proc"
-          input.call
+        if @sequential_value[input]
+          value = @sequential_value[input]
+        else
+          value = case input.class.to_s
+          when "Symbol"
+            ret = resource(input)
+            ret
+          when "Array"
+            input
+          when "Range"
+            input.to_a
+          when "Proc"
+            input.call
+          end
+          digest = value.gibbler
+          @sequential_offset ||= {}
+          @sequential_offset[digest] ||= 0
+          Stella.ld "SEQVALUES: #{input} #{value.inspect} #{@sequential_offset[digest]}"
+          if value.is_a?(Array)
+            size = value.size
+            @sequential_offset[digest] = 0 if @sequential_offset[digest] >= size
+            value = value[ @sequential_offset[digest] ] 
+            @sequential_offset[digest] += 1
+          end
+          Stella.ld "SELECTED: #{value}"
+          @sequential_value[input] = value
         end
-        digest = value.gibbler
-        @sequential_offset ||= {}
-        @sequential_offset[digest] ||= 0
-        Stella.ld "SEQVALUES: #{input} #{value.inspect} #{@sequential_offset[digest]}"
-        if value.is_a?(Array)
-          size = value.size
-          @sequential_offset[digest] = 0 if @sequential_offset[digest] >= size
-          value = value[ @sequential_offset[digest] ] 
-          @sequential_offset[digest] += 1
+        # The resource may be an Array of Arrays (e.g. a CSV file)
+        if value.is_a?(Array) && !index.nil?
+          value = value[ index ] 
+          Stella.ld "SELECTED INDEX: #{index} #{value.inspect} "
         end
-        Stella.ld "SELECTED: #{value}"
         value
       end
     end
     
     def rsequential(*args)
-      input = args.size > 1 ? args : args.first
+      if Symbol === args.first
+        input, index = *args
+      elsif Array === args.first || args.size == 1
+        input = args.first
+      else
+        input = args
+      end
       Proc.new do
-        value = case input.class.to_s
-        when "Symbol"
-          ret = resource(input)
-          ret
-        when "Array"
-          input
-        when "Range"
-          input.to_a
-        when "Proc"
-          input.call
+        if @rsequential_value[input.digest]
+          value = @rsequential_value[input.digest]
+        else
+          value = case input.class.to_s
+          when "Symbol"
+            ret = resource(input)
+            ret
+          when "Array"
+            input
+          when "Range"
+            input.to_a
+          when "Proc"
+            input.call
+          end
+          digest = value.gibbler
+          @rsequential_offset ||= {}
+          @rsequential_offset[digest] ||= value.size-1 rescue 1
+          Stella.ld "RSEQVALUES: #{input} #{value.inspect} #{@rsequential_offset[digest]}"
+          if value.is_a?(Array)
+            size = value.size
+            @rsequential_offset[digest] = size-1 if @rsequential_offset[digest] < 0
+            value = value[ @rsequential_offset[digest] ] 
+            @rsequential_offset[digest] -= 1
+          end
+          Stella.ld "SELECTED: #{value}"
+          @rsequential_value[input.digest] = value
         end
-        digest = value.gibbler
-        @rsequential_offset ||= {}
-        @rsequential_offset[digest] ||= value.size-1 rescue 1
-        Stella.ld "RSEQVALUES: #{input} #{value.inspect} #{@rsequential_offset[digest]}"
-        if value.is_a?(Array)
-          size = value.size
-          @rsequential_offset[digest] = size-1 if @rsequential_offset[digest] < 0
-          value = value[ @rsequential_offset[digest] ] 
-          @rsequential_offset[digest] -= 1
+        
+        # The resource may be an Array of Arrays (e.g. a CSV file)
+        if value.is_a?(Array) && !index.nil?
+          value = value[ index ] 
+          Stella.ld "SELECTED INDEX: #{index} #{value.inspect} "
         end
-        Stella.ld "SELECTED: #{value}"
+        
         value
       end
     end
@@ -110,4 +163,4 @@ module Stella::Data
       
 end
 
-Stella::Utils.require_glob(Stella::LIB_HOME, 'stella', 'data', '*.rb')
+Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'data', '*.rb')

data/lib/stella/data/http.rb

@@ -1,4 +1,4 @@
 
 module Stella::Data::HTTP; end
 
-Stella::Utils.require_glob(Stella::LIB_HOME, 'stella', 'data', 'http', '*.rb')
+Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'data', 'http', '*.rb')

data/lib/stella/data/http/request.rb

@@ -5,13 +5,13 @@ module Stella::Data::HTTP
     include Gibbler::Complex
     include Stella::Data::Helpers
     
-    # A hash containing blocks to be executed depending on the HTTP response status.
-    # The hash keys are numeric HTTP Status Codes. 
-    #
-    #     200 => { ... }
-    #     304 => { ... }
-    #     500 => { ... }
-    #
+      # A hash containing blocks to be executed depending on the HTTP response status.
+      # The hash keys are numeric HTTP Status Codes. 
+      #
+      #     200 => { ... }
+      #     304 => { ... }
+      #     500 => { ... }
+      #
     attr_accessor :response_handler
     
     field :desc

data/lib/stella/engine.rb

@@ -5,6 +5,8 @@ module Stella::Engine
   module Base
     extend self
     
+    @@client_limit = 200
+    
     def update(*args)
       what, *args = args
       if respond_to?("update_#{what}")
@@ -15,18 +17,41 @@ module Stella::Engine
       end
     end
 
-    def run; raise; end
-    
-    
-    def update_quit_usecase client_id, msg
-    end
-    
-    def update_repeat_request client_id, counter, total
-    end
-    
-    def update_stats client_id, http_client, usecase, req
+    def process_options!(plan, opts={})
+      opts = {
+        :hosts          => [],
+        :clients        => 1,
+        :duration       => 0,
+        :nowait         => false,
+        :arrival        => nil,
+        :repetitions    => 1
+      }.merge! opts
+      
+      Stella.li3 " Options: #{opts.inspect}"
+      Stella.lflush
+      
+      opts[:clients] = plan.usecases.size if opts[:clients] < plan.usecases.size
+      
+      if opts[:clients] > @@client_limit
+        Stella.li3 "Client limit is #{@@client_limit}"
+        opts[:clients] = @@client_limit
+      end
+      
+      # Parses 60m -> 3600. See mixins. 
+      if opts[:duration].in_seconds.nil?
+        raise Stella::WackyDuration, opts[:duration] 
+      end
+      
+      opts[:duration] = opts[:duration].in_seconds
+      
+      Stella.li3 " Hosts: " << opts[:hosts].join(', ')
+      opts
     end
     
+    def run; raise; end
+    def update_quit_usecase(client_id, msg) raise end
+    def update_repeat_request(client_id, counter, total) raise end
+    def update_stats(client_id, http_client, usecase, req) raise end
     def update_prepare_request(*args) raise end
     def update_send_request(*args) raise end
     def update_receive_response(*args) raise end
@@ -36,7 +61,7 @@ module Stella::Engine
     
   end
 
-  Stella::Utils.require_glob(Stella::LIB_HOME, 'stella', 'engine', '*.rb')
+  Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'engine', '*.rb')
 
 
   # These timers are interesting from a reporting perspective.

data/lib/stella/engine/functional.rb

@@ -5,11 +5,8 @@ module Stella::Engine
     extend self
     
     def run(plan, opts={})
-      opts = {
-        :hosts        => [],
-        :nowait    => false,
-        :repetitions  => 1
-      }.merge! opts
+      opts = process_options! plan, opts
+      
       Stella.ld "OPTIONS: #{opts.inspect}"
       Stella.li2 "Hosts: " << opts[:hosts].join(', ') if !opts[:hosts].empty?
       
@@ -18,13 +15,16 @@ module Stella::Engine
 
       client.enable_nowait_mode if opts[:nowait]
       
-      Stella.li $/, "Starting test...", $/
+      Stella.li2 $/, "Starting test...", $/
       Stella.lflush
       sleep 0.3
       
+      dig = Stella.loglev > 1 ? plan.digest_cache : plan.digest_cache.shorter
+      Stella.li " %-65s  ".att(:reverse) % ["#{plan.desc}  (#{dig})"]
       plan.usecases.each_with_index do |uc,i|
         desc = (uc.desc || "Usecase ##{i+1}")
-        Stella.li ' %-65s '.att(:reverse).bright % ["#{desc}  (#{uc.gibbler_cache.shorter}) "]
+        dig = Stella.loglev > 1 ? uc.digest_cache : uc.digest_cache.shorter
+        Stella.li ' %-65s '.att(:reverse).bright % ["#{desc}  (#{dig}) "]
         Stella.rescue { client.execute uc }
       end
       
@@ -38,7 +38,8 @@ module Stella::Engine
     
     def update_prepare_request(client_id, usecase, req, counter)
       notice = "repeat: #{counter-1}" if counter > 1
-      desc = "#{req.desc}  (#{req.gibbler_cache.shorter}) "
+      dig = Stella.loglev > 1 ? req.digest_cache : req.digest_cache.shorter
+      desc = "#{req.desc}  (#{dig}) "
       Stella.li2 "  %-46s %16s ".bright % [desc, notice]
     end
     

data/lib/stella/engine/load.rb

@@ -12,23 +12,59 @@ module Stella::Engine
     end
     
     def run(plan, opts={})
-      opts = {
-        :hosts          => [],
-        :clients        => 1,
-        :duration       => nil,
-        :nowait         => false,
-        :repetitions    => 1
-      }.merge! opts
-      opts[:clients] = plan.usecases.size if opts[:clients] < plan.usecases.size
-      opts[:clients] = 1000 if opts[:clients] > 1000
+      opts = process_options! plan, opts
       
-      Stella.li3 " Options: #{opts.inspect}"
-      Stella.li3 " Hosts: " << opts[:hosts].join(', ') 
+      if Stella.loglev > 1
+        Load.timers += [:connect, :create_socket, :query, :socket_gets_first_byte, :get_body]
+        Load.counts  = [:request_header_size, :request_content_size]
+        Load.counts += [:response_headers_size, :response_content_size]
+      end
       
-      #wait_for_reporter
+      counts = calculate_usecase_clients plan, opts
       
-      # errors?
+      Stella.li $/, "Preparing #{counts[:total]} virtual clients...", $/
+      Stella.lflush
+      packages = build_thread_package plan, opts, counts
+      
+      if opts[:duration] > 0
+        msg = "for #{opts[:duration].seconds}s"
+      else
+        msg = "for #{opts[:repetitions]} reps"
+      end
+      
+      Stella.li "Generating requests #{msg}...", $/
+      Stella.lflush
       
+      @mode = :rolling
+      
+      begin
+        execute_test_plan packages, opts[:repetitions], opts[:duration]
+      rescue Interrupt
+        Stella.li "Stopping test...", $/
+        Stella.abort!
+      ensure
+        Stella.li "Processing statistics...", $/
+        Stella.lflush
+        
+        wait_for_reporter
+        
+        tt = Benelux.thread_timeline
+        test_time = tt.stats.group(:execute_test_plan).mean
+        
+        generate_report plan, test_time
+        
+        #p Benelux.timeline
+        
+        Stella.li "Summary: "
+        Stella.li "  max clients: %d" % @max_clients
+        Stella.li "  repetitions: %d" % @real_reps
+        Stella.li "    test time: %10.2fs" % test_time
+        Stella.li "    wait time: %10.2fs" % tt.stats.group(:wait_for_reporter).mean
+        Stella.li "    post time: %10.2fs" % tt.stats.group(:generate_report).mean
+        Stella.li $/
+      end
+      
+      # errors?
     end
     
     def wait_for_reporter
@@ -36,8 +72,269 @@ module Stella::Engine
     end
     
   protected
+    class ThreadPackage
+      attr_accessor :index
+      attr_accessor :client
+      attr_accessor :usecase
+      def initialize(i, c, u)
+        @index, @client, @usecase = i, c, u
+      end
+    end
+    
+    def calculate_usecase_clients(plan, opts)
+      counts = { :total => 0 }
+      plan.usecases.each_with_index do |usecase,i|
+        count = case opts[:clients]
+        when 0..9
+          if (opts[:clients] % plan.usecases.size > 0) 
+            msg = "Client count does not evenly match usecase count"
+            raise Stella::WackyRatio, msg
+          else
+            (opts[:clients] / plan.usecases.size)
+          end
+        else
+          (opts[:clients] * usecase.ratio).to_i
+        end
+        counts[usecase.digest_cache] = count
+        counts[:total] += count
+      end
+      counts
+    end
+    
+    def build_thread_package(plan, opts, counts)
+      packages, pointer = Array.new(counts[:total]), 0
+      plan.usecases.each do |usecase|
+        count = counts[usecase.digest_cache]
+        Stella.ld "THREAD PACKAGE: #{usecase.desc} (#{pointer} + #{count})"
+        # Fill the thread_package with the contents of the block
+        packages.fill(pointer, count) do |index|
+          client = Stella::Client.new opts[:hosts].first, index+1
+          client.add_observer(self)
+          client.enable_nowait_mode if opts[:nowait]
+          Stella.li4 "Created client #{client.digest.short}"
+          ThreadPackage.new(index+1, client, usecase)
+        end
+        pointer += count
+      end
+      packages.compact # TODO: Why one nil element sometimes?
+    end
+    
+    def execute_test_plan(packages, reps=1, duration=0)
+      time_started = Time.now
+      
+      @threads, @max_clients, @real_reps = [], 0, 0
+      (1..reps).to_a.each { |rep|
+        @real_reps += 1  # Increments when duration is specified.
+        Stella.li3 "*** REPETITION #{@real_reps} of #{reps} ***"
+        packages.each { |package|
+          if running_threads.size <= packages.size
+            @threads << Thread.new do
+              c, uc = package.client, package.usecase
+              msg = "THREAD START: client %s: " % [c.digest.short] 
+              msg << "%s:%s (rep: %d)" % [uc.desc, uc.digest.short, @real_reps]
+              Stella.li4 $/, "======== " << msg
+              # This thread will stay on this one track. 
+              Benelux.current_track c.digest
+              Benelux.add_thread_tags :usecase => uc.digest_cache
+          
+              Benelux.add_thread_tags :rep =>  @real_reps
+              Stella::Engine::Load.rescue(c.digest_cache) {
+                break if Stella.abort?
+                print '.' if Stella.loglev == 2
+                stats = c.execute uc
+              }
+              Benelux.remove_thread_tags :rep
+              Benelux.remove_thread_tags :usecase
+            
+            end
+            Stella.sleep :create_thread
+          end
+          
+          if running_threads.size > @max_clients
+            @max_clients = running_threads.size
+          end
+          
+          if @mode == :rolling
+            tries = 0
+            while (reps > 1 || duration > 0) && running_threads.size >= packages.size
+              Stella.sleep :check_threads
+              msg = "#{running_threads.size} (max: #{@max_clients})"
+              Stella.li3 "*** RUNNING THREADS: #{msg} ***"
+              (tries += 1)
+            end
+          end
+        }
+        
+        if @mode != :rolling && running_threads.size > 0
+          args = [running_threads.size, @max_clients]
+          Stella.li3 "*** WAITING FOR %d THREADS TO FINISH (max: %d) ***" % args
+          @threads.each { |t| t.join } # wait
+        end
+        
+        # If a duration was given, we make sure 
+        # to run for only that amount of time.
+        # TODO: do not redo if 
+        # time_elapsed + usecase.mean > duration
+        if duration > 0
+          time_elapsed = (Time.now - time_started).to_i
+          msg = "#{time_elapsed} of #{duration} (threads: %d)" % running_threads.size
+          Stella.li3 "*** TIME ELAPSED: #{msg} ***"
+          sleep 0.5 and redo if time_elapsed <= duration 
+          break if time_elapsed >= duration
+        end
+
+      }
+      
+      if @mode == :rolling && running_threads.size > 0
+        Stella.li3 "*** WAITING FOR THREADS TO FINISH ***"
+        @threads.each { |t| t.join } # wait
+      end
+      Stella.li2 $/, $/
+    end
+    def running_threads
+      @threads.select { |t| t.status }  # non-false status are still running
+    end
+    def generate_report(plan,test_time)
+      #Benelux.update_all_track_timelines
+      global_timeline = Benelux.timeline
+      
+      Stella.li $/, " %-72s  ".att(:reverse) % ["#{plan.desc}  (#{plan.digest_cache.shorter})"]
+      plan.usecases.uniq.each_with_index do |uc,i| 
+        
+        # TODO: Create Ranges object, like Stats object
+        # global_timeline.ranges(:do_request)[:usecase => '1111']
+        # The following returns globl do_request ranges. 
+        requests = 0 #global_timeline.ranges(:do_request).size
+        
+        desc = uc.desc || "Usecase ##{i+1} "
+        desc << "  (#{uc.digest_cache.shorter}) "
+        str = ' ' << " %-66s %s   %d%% ".bright.att(:reverse)
+        Stella.li str % [desc, '', uc.ratio_pretty]
+        
+        uc.requests.each do |req| 
+          filter = [uc.digest_cache, req.digest_cache]
+          desc = req.desc 
+          Stella.li "   %-72s ".bright % ["#{req.desc}  (#{req.digest_cache.shorter})"]
+          Stella.li "    %s" % [req.to_s]
+          Load.timers.each do |sname|
+            stats = global_timeline.stats.group(sname)[filter].merge
+#            Stella.li stats.inspect
+            str = '      %-30s %.3f <= ' << '%.3fs' << ' >= %.3f; %.3f(SD) %d(N)'
+            Stella.li str % [sname, stats.min, stats.mean, stats.max, stats.sd, stats.n]
+            Stella.lflush
+          end
+          Stella.li $/
+        end
+        
+        Stella.li "   Sub Total:".bright
+        
+        stats = global_timeline.stats.group(:do_request)[uc.digest_cache].merge
+        failed = global_timeline.stats.group(:failed)[uc.digest_cache].merge
+        respgrp = global_timeline.stats.group(:execute_response_handler)[uc.digest_cache]
+        resst = respgrp.tag_values(:status)
+        statusi = []
+        resst.each do |status|
+          size = respgrp[:status => status].size
+          statusi << "#{status}: #{size}"
+        end
+        Stella.li '      %-30s %d (%s)' % ['Total requests', stats.n, statusi.join(', ')]
+        Stella.li '       %-29s %d' % [:success, stats.n - failed.n]
+        Stella.li '       %-29s %d' % [:failed, failed.n]
+        
+        Load.timers.each do |sname|
+          stats = global_timeline.stats.group(sname)[uc.digest_cache].merge
+          Stella.li '      %-30s %.3fs %.3f(SD)' % [sname, stats.mean, stats.sd]
+          Stella.lflush
+        end
+        
+        Load.counts.each do |sname|
+          stats = global_timeline.stats.group(sname)[uc.digest_cache].merge
+          Stella.li '      %-30s %-12s (avg:%s)' % [sname, stats.sum.to_bytes, stats.mean.to_bytes]
+          Stella.lflush
+        end
+        Stella.li $/
+      end
+      
+      Stella.li ' ' << " %-66s ".att(:reverse) % 'Total:'
+      stats = global_timeline.stats.group(:do_request).merge
+      failed = global_timeline.stats.group(:failed)
+      respgrp = global_timeline.stats.group(:execute_response_handler)
+      resst = respgrp.tag_values(:status)
+      statusi = []
+      resst.each do |status|
+        size = respgrp[:status => status].size
+        statusi << [status, size]
+      end
+      Stella.li  '      %-30s %d' % ['Total requests', stats.n]
+      success = stats.n - failed.n
+      Stella.li  '       %-29s %d (req/s: %.2f)' % [:success, success, success/test_time]
+      statusi.each do |pair|
+        Stella.li2 '        %-28s %s: %d' % ['', *pair]
+      end
+      Stella.li  '       %-29s %d' % [:failed, failed.n]
+      
+      Load.timers.each do |sname|
+        stats = global_timeline.stats.group(sname).merge
+        Stella.li '      %-30s %-.3fs     %-.3f(SD)' % [sname, stats.mean, stats.sd]
+        Stella.lflush
+      end
+      
+      Load.counts.each do |sname|
+        stats = global_timeline.stats.group(sname).merge
+        Stella.li '      %-30s %-12s (avg:%s)' % [sname, stats.sum.to_bytes, stats.mean.to_bytes]
+        Stella.lflush
+      end
+      Stella.li $/
+    end
+    
+    
+    def update_prepare_request(client_id, usecase, req, counter)
+      
+    end
+      
+    def update_receive_response(client_id, usecase, uri, req, counter, container)
+      desc = "#{usecase.desc} > #{req.desc}"
+      Stella.li3 '  Client-%s %3d %-6s %-45s' % [client_id.shorter, container.status, req.http_method, uri]
+    end
+    
+    def update_execute_response_handler(client_id, req, container)
+    end
+    
+    def update_error_execute_response_handler(client_id, ex, req, container)
+      desc = "#{container.usecase.desc} > #{req.desc}"
+      Stella.li $/ if Stella.loglev == 1
+      Stella.le '  Client-%s %-45s %s' % [client_id.shorter, desc, ex.message]
+      Stella.li3 ex.backtrace
+    end
+    
+    def update_request_error(client_id, usecase, uri, req, params, ex)
+      desc = "#{usecase.desc} > #{req.desc}"
+      Stella.li $/ if Stella.loglev == 1
+      Stella.le '  Client-%s %-45s %s' % [client_id.shorter, desc, ex.message]
+      Stella.li3 ex.backtrace
+    end
+
+    def update_quit_usecase client_id, msg
+      Stella.li3 "  Client-%s     QUIT   %s" % [client_id.shorter, msg]
+    end
+    
+    
+    def update_repeat_request client_id, counter, total
+      Stella.li3 "  Client-%s     REPEAT   %d of %d" % [client_id.shorter, counter, total]
+    end
+    
+    def self.rescue(client_id, &blk)
+      blk.call
+    rescue => ex
+      Stella.le '  Error in Client-%s: %s' % [client_id.shorter, ex.message]
+      Stella.li3 ex.backtrace
+    end
+    
     
-    #Benelux.add_timer Stella::Engine::Load, :build_thread_package
+    Benelux.add_timer Stella::Engine::Load, :build_thread_package
+    Benelux.add_timer Stella::Engine::Load, :execute_test_plan
+    Benelux.add_timer Stella::Engine::Load, :generate_report
+    Benelux.add_timer Stella::Engine::Load, :wait_for_reporter
     
   end
 end