stella 0.8.2.003 → 0.8.3.001

data/lib/stella/engine/load.rb

@@ -5,22 +5,23 @@ module Stella::Engine
     @timers = [:response_time]
     @counts = [:response_content_size]
     
-    def run(plan)
-      opts = process_options! plan, @opts
+    def run(testrun)
       @threads, @max_clients, @real_reps = [], 0, 0
+      counts = calculate_usecase_clients testrun
+      packages = build_thread_package testrun, counts
       
-      @logdir = log_dir(plan)
-      latest = File.join(File.dirname(@logdir), 'latest')
-      Stella.stdout.info "Logging to #{@logdir}", $/
-      
-      if Stella.sysinfo.os == :unix
-        File.unlink latest if File.exists? latest
-        FileUtils.ln_sf File.basename(@logdir), latest
+      unless Stella::Logger.disabled?
+        Stella.stdout.info "Logging to #{testrun.log_dir}", $/
+
+        latest = File.join(File.dirname(testrun.log_dir), 'latest')
+        if Stella.sysinfo.os == :unix
+          File.unlink latest if File.exists? latest
+          FileUtils.ln_sf File.basename(testrun.log_dir), latest
+        end
       end
       
-      @statlog_path = log_path(plan, 'stats')
-      @sumlog = Stella::Logger.new log_path(plan, 'summary')
-      @failog = Stella::Logger.new log_path(plan, 'exceptions')
+      @sumlog = Stella::Logger.new testrun.log_path('summary')
+      @failog = Stella::Logger.new testrun.log_path('exceptions')
       
       Stella.stdout.add_template :head, '  %s: %s'
       Stella.stdout.add_template :status,  "#{$/}%s..."
@@ -32,41 +33,33 @@ module Stella::Engine
       end
       
       events = [Load.timers, Load.counts, :failed].flatten
-      @testrun = Stella::Testrun.new plan, events, opts
-      @testrun.mode = 'l'
-      
-      if Stella::Engine.service
-        Stella::Engine.service.testplan_sync plan
-        Stella::Engine.service.testrun_create @testrun
-        Stella.stdout.head 'Testrun', @testrun.remote_digest
-      end
-      
-      @testrun.save(@statlog_path)
+
+      testrun.save
       
-      @dumper = prepare_dumper(plan, opts)
+      @dumper = prepare_dumper(testrun)
       
-      counts = calculate_usecase_clients plan, opts
       
-      packages = build_thread_package plan, opts, counts
       
-      if opts[:duration] > 0
-        timing = "#{opts[:duration].seconds.to_i} seconds"
+      if testrun.duration > 0
+        timing = "#{testrun.duration.seconds.to_i} seconds"
       else
-        timing = "#{opts[:repetitions]} repetitions"
+        timing = "#{testrun.repetitions} repetitions"
       end
       
-      Stella.stdout.head 'Plan', "#{plan.desc} (#{plan.digest.shorter})"
-      Stella.stdout.head 'Hosts', opts[:hosts].join(', ')
+      Stella.stdout.head "Runid", "#{testrun.id.shorter}"
+      Stella.stdout.head 'Plan', "#{testrun.plan.desc} (#{testrun.plan.id.shorter})"
+      Stella.stdout.head 'Hosts', testrun.hosts.join(', ')
       Stella.stdout.head 'Clients', counts[:total]
       Stella.stdout.head 'Limit', timing
-      
-      Stella.stdout.head 'Arrival', opts[:arrival] if opts[:arrival]
+      Stella.stdout.head 'Arrival', testrun.arrival if testrun.arrival
       
       @dumper.start
       
       begin 
         Stella.stdout.status "Running" 
-        execute_test_plan packages, opts[:repetitions], opts[:duration], opts[:arrival]
+        testrun.status = "running"
+        testrun.start_time = Time.now.utc.to_i
+        execute_test_plan packages, testrun
       rescue Interrupt
         Stella.stdout.info $/, "Stopping test"
         Stella.abort!
@@ -85,18 +78,19 @@ module Stella::Engine
       
       # TODO: don't get test time from benelux. 
       test_time = tt.stats.group(:execute_test_plan).mean
-      generate_report @sumlog, plan, test_time
+      generate_report @sumlog, testrun, test_time
       #report_time = tt.stats.group(:generate_report).mean
       
-      Stella.stdout.info File.read(@sumlog.path)
-      
-      Stella.stdout.info $/, "Log dir: #{@logdir}"
+      unless Stella::Logger.disabled?
+        Stella.stdout.info File.read(@sumlog.path)
+        Stella.stdout.info $/, "Log dir: #{testrun.log_dir}"
+      end
       
-      @testrun
+      testrun
     end
     
     ROTATE_TIMELINE = 5
-    def execute_test_plan(packages, reps=1,duration=0,arrival=nil)
+    def execute_test_plan(packages, testrun)
       time_started = Time.now
       
       pqueue = Queue.new
@@ -111,25 +105,25 @@ module Stella::Engine
           Thread.current[:real_reps] = 0
           Thread.current[:real_uctime] = Benelux::Stats::Calculator.new
           c, uc = package.client, package.usecase
-          Stella.stdout.info4 $/, "======== THREAD %s: START" % [c.digest.short]  
+          Stella.stdout.info4 $/, "======== THREAD %s: START" % [c.id.short]  
 
           # This thread will stay on this one track. 
-          Benelux.current_track c.digest
+          Benelux.current_track c.id
           
-          Benelux.add_thread_tags :usecase => uc.digest_cache
+          Benelux.add_thread_tags :usecase => uc.id
           Thread.current[:real_uctime].first_tick
           prev_ptime ||= Time.now
-          reps.times { |rep| 
+          testrun.repetitions.times { |rep| 
             break if Stella.abort?
             Thread.current[:real_reps] += 1
             # NOTE: It's important to not call digest or gibbler methods
             # on client object b/c it is not frozen. Always use digest_cache.
-            args = [c.digest_cache.short, uc.desc, uc.digest.short, Thread.current[:real_reps]]
+            args = [c.id.short, uc.desc, uc.id.short, Thread.current[:real_reps]]
             Stella.stdout.info4 $/, "======== THREAD %s: %s:%s (rep: %d)" % args
             
             Benelux.add_thread_tags :rep =>  rep
             #Stella.stdout.info [package.client.gibbler.shorter, package.usecase.gibbler.shorter, rep].inspect
-            Stella::Engine::Load.rescue(c.digest_cache) {
+            Stella::Engine::Load.rescue(c.id) {
               break if Stella.abort?
               print '.' if Stella.stdout.lev == 2
               stats = c.execute uc
@@ -151,9 +145,9 @@ module Stella::Engine
             
             # If a duration was given, we make sure 
             # to run for only that amount of time.
-            if duration > 0
-              break if (time_elapsed+Thread.current[:real_uctime].mean) >= duration
-              redo if (time_elapsed+Thread.current[:real_uctime].mean) <= duration
+            if testrun.duration > 0
+              break if (time_elapsed+Thread.current[:real_uctime].mean) >= testrun.duration
+              redo if (time_elapsed+Thread.current[:real_uctime].mean) <= testrun.duration
             end
           }
           
@@ -162,12 +156,12 @@ module Stella::Engine
           pqueue << package  # return the package to the queue
         end
         
-        unless arrival.nil?
+        unless testrun.arrival.nil? || testrun.arrival.to_f <= 0
           # Create 1 second / users per second 
           args = [@threads.size, packages.size]
           Stella.stdout.print 2, '+'
           Stella.stdout.info3 $/, "-> NEW CLIENT: %s of %s" % args
-          sleep 1/arrival
+          sleep 1/testrun.arrival
         end
       }
       
@@ -192,25 +186,28 @@ module Stella::Engine
       end
     end
     
-    def prepare_dumper(plan, opts)
+    def prepare_dumper(testrun)
       hand = Stella::Hand.new(Load::ROTATE_TIMELINE, 2.seconds) do
         Benelux.update_global_timeline 
         # @threads contains only stella clients
         concurrency = @threads.select { |t| !t.status.nil? }.size
         batch, timeline = Benelux.timeline_updates, Benelux.timeline_chunk
-        @testrun.add_sample batch, concurrency, timeline
-        @testrun.save(@statlog_path)
+        testrun.add_sample batch, concurrency, timeline
+        if batch == 1 # only save the first batch
+          testrun.log = Benelux.timeline.messages.filter(:kind => :log)
+        end
+        testrun.save
         @failog.info Benelux.timeline.messages.filter(:kind => :exception)
         @failog.info Benelux.timeline.messages.filter(:kind => :timeout)
-        Benelux.timeline.clear if opts[:"no-stats"]
+        Benelux.timeline.clear if testrun.nostats
       end
       hand.finally do
-        @testrun.save(@statlog_path)
+        testrun.save
       end
       hand
     end
 
-    def generate_report(sumlog,plan,test_time)
+    def generate_report(sumlog,testrun,test_time)
       global_timeline = Benelux.timeline
       global_stats = global_timeline.stats.group(:response_time).merge
       if global_stats.n == 0
@@ -218,8 +215,8 @@ module Stella::Engine
         return
       end
       
-      @sumlog.info " %-72s  ".att(:reverse) % ["#{plan.desc}  (#{plan.digest_cache.shorter})"]
-      plan.usecases.uniq.each_with_index do |uc,i| 
+      @sumlog.info " %-72s  ".att(:reverse) % ["#{testrun.plan.desc}  (#{testrun.plan.id.shorter})"]
+      testrun.plan.usecases.uniq.each_with_index do |uc,i| 
         
         # TODO: Create Ranges object, like Stats object
         # global_timeline.ranges(:response_time)[:usecase => '1111']
@@ -227,13 +224,13 @@ module Stella::Engine
         requests = 0 #global_timeline.ranges(:response_time).size
         
         desc = uc.desc || "Usecase ##{i+1} "
-        desc << "  (#{uc.digest_cache.shorter}) "
+        desc << "  (#{uc.id.shorter}) "
         str = ' ' << " %-66s %s   %d%% ".bright.att(:reverse)
         @sumlog.info str % [desc, '', uc.ratio_pretty]        
         uc.requests.each do |req| 
-          filter = [uc.digest_cache, req.digest_cache]
+          filter = [uc.id, req.id]
           desc = req.desc 
-          @sumlog.info "   %-72s ".bright % ["#{req.desc}  (#{req.digest_cache.shorter})"]
+          @sumlog.info "   %-72s ".bright % ["#{req.desc}  (#{req.id.shorter})"]
           @sumlog.info "    %s" % [req.to_s]
 
           Load.timers.each do |sname|
@@ -249,19 +246,19 @@ module Stella::Engine
         
         @sumlog.info "   Sub Total:".bright
         
-        stats = global_timeline.stats.group(:response_time)[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]
+        stats = global_timeline.stats.group(:response_time)[uc.id].merge
+        failed = global_timeline.stats.group(:failed)[uc.id].merge
+        respgrp = global_timeline.stats.group(:execute_response_handler)[uc.id]
         resst = respgrp.tag_values(:status)
         
         Load.timers.each do |sname|
-          stats = global_timeline.stats.group(sname)[uc.digest_cache].merge
+          stats = global_timeline.stats.group(sname)[uc.id].merge
           @sumlog.info '      %-30s %.3fs %.3f(SD)' % [sname, stats.mean, stats.sd]
           @sumlog.flush
         end
         
         Load.counts.each do |sname|
-          stats = global_timeline.stats.group(sname)[uc.digest_cache].merge
+          stats = global_timeline.stats.group(sname)[uc.id].merge
           @sumlog.info '      %-30s %-12s (avg:%s)' % [sname, stats.sum.to_bytes, stats.mean.to_bytes]
           @sumlog.flush
         end
@@ -317,38 +314,37 @@ module Stella::Engine
     end
     
     
-    def calculate_usecase_clients(plan, opts)
+    def calculate_usecase_clients(testrun)
       counts = { :total => 0 }
-      plan.usecases.each_with_index do |usecase,i|
-        count = case opts[:clients]
+      testrun.plan.usecases.each_with_index do |usecase,i|
+        count = case testrun.clients
         when 0..9
-          if (opts[:clients] % plan.usecases.size > 0) 
-            msg = "Client count does not evenly match usecase count"
-            raise Stella::WackyRatio, msg
+          if (testrun.clients % testrun.plan.usecases.size > 0) 
+            msg = "Client count (%d) does not evenly match usecase count (%d)"
+            raise Stella::WackyRatio, (msg % [testrun.clients, testrun.plan.usecases.size])
           else
-            (opts[:clients] / plan.usecases.size)
+            (testrun.clients / testrun.plan.usecases.size)
           end
         else
-          (opts[:clients] * usecase.ratio).to_i
+          (testrun.clients * usecase.ratio).to_i
         end
-        counts[usecase.digest_cache] = count
+        counts[usecase.id] = count
         counts[:total] += count
       end
       counts
     end
 
     
-    def build_thread_package(plan, opts, counts)
+    def build_thread_package(testrun, counts)
       packages, pointer = Array.new(counts[:total]), 0
-      plan.usecases.each do |usecase|
-        count = counts[usecase.digest_cache]
+      testrun.plan.usecases.each do |usecase|
+        count = counts[usecase.id]
         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, opts
+          client = Stella::Client.new testrun.hosts.first, testrun.client_options
           client.add_observer(self)
-          client.enable_nowait_mode if opts[:nowait]
-          Stella.stdout.info4 "Created client #{client.digest.short}"
+          Stella.stdout.info4 "Created client #{client.id.short}"
           ThreadPackage.new(index+1, client, usecase)
         end
         pointer += count
@@ -364,13 +360,13 @@ module Stella::Engine
       @threads.select { |t| t.status }  # non-false status are still running
     end
     
-    def generate_runtime_report(plan)
+    def generate_runtime_report(testrun)
       gt = Benelux.timeline
       gstats = gt.stats.group(:response_time).merge
       
-      plan.usecases.uniq.each_with_index do |uc,i| 
+      testrun.plan.usecases.uniq.each_with_index do |uc,i| 
         uc.requests.each do |req| 
-          filter = [uc.digest_cache, req.digest_cache]
+          filter = [uc.id, req.id]
 
           Load.timers.each do |sname|
             stats = gt.stats.group(sname)[filter].merge
@@ -388,8 +384,20 @@ module Stella::Engine
     end
       
     def update_receive_response(client_id, usecase, uri, req, params, headers, counter, container)
+      if @opts[:with_content]
+        log = Stella::Engine::Log.new Time.now.to_f, container.unique_id, client_id,
+                                      'testplanid',
+                                      usecase.id, req.id,
+                                      req.http_method, container.status, uri,
+                                      params, container.response.request.header.dump, 
+                                      container.response.header.dump, 
+                                      container.response.body.dump
+
+        Benelux.thread_timeline.add_message log, :status => container.status, :kind => :log
+      end
+      
       args = [Time.now.to_f, Stella.sysinfo.hostname, client_id.short]
-      args.push usecase.digest.shorter, req.digest.shorter
+      args.push usecase.id.shorter, req.id.shorter
       args.push req.http_method, container.status, uri
       args << params.to_a.collect { |el| 
         next if el[0].to_s == '__stella'
@@ -471,7 +479,7 @@ module Stella::Engine
     
     def update_authenticate client_id, usecase, req, domain, user, pass
       args = [Time.now.to_f, Stella.sysinfo.hostname, client_id.short]
-      args.push usecase.digest.shorter, req.digest.shorter
+      args.push usecase.id.shorter, req.id.shorter
       args.push 'AUTH', domain, user, pass
       Benelux.thread_timeline.add_message args.join('; '), :kind => :authentication
     end