stella 0.8.0.001 → 0.8.1.001

data/CHANGES.txt

@@ -5,11 +5,23 @@ STELLA, CHANGES
 * TODO: Force response block content type. 
 * TODO: Add assert methods to response blocks (reconsider)
 * TODO: Add option to dump full request/response output to a file by client
-* TODO: review cooking handling. Not always sent automatically. 
+* TODO: review cookie handling. Not always sent automatically. 
 * TODO: review :variables in URI elements
-* TODO: Stella::Testrun (no local analog for runid so it's set by the service)
 * TODO: global responses
 * TODO: request block conditions. 
+* TODO: process templates for calls to set in get blocks
+
+
+#### 0.8.1 (2010-02-10) ###############################
+
+* FIXED: Handling of non ASCII characters with Nokogiri parsing in Ruby 1.9
+* FIXED:  warning in Ruby 1.9
+* FIXED: Setting of domain for HTTP authentication when the request URI 
+  is a fully qualified URI. 
+* CHANGE: Don't attempt to convert parameters or headers to ERB templates.
+* CHANGE: Randomize order of usecase when generating load
+* CHANGE: noparams and noheader now default to off. Must use with-param and with-header.
+* ADDED: Stella.get
 
 
 #### 0.8.0 (2010-01-16) ###############################

data/bin/stella

@@ -43,12 +43,8 @@ class Stella::CLI::Definition
     Stella.enable_debug
   end
   global :W, :wait, Integer, "Seconds to wait before starting test"
-  global :'no-header', "Do not include X-Stella-ID request header" do
-    true  # params starting with 'no-' return false??
-  end
-  global :'no-param', "Do not include __stella query parameter header" do
-    true
-  end
+  global :'with-header', "Include X-Stella-ID request header" 
+  global :'with-param', "Include __stella query parameter header"
   global :R, :remote
   global :E, :engine, String, "Specify a load engine (experimental)"
   global :o, :output, String, "Write output to the given file" do |v|

data/examples/essentials/plan.rb

@@ -156,7 +156,7 @@ usecase 65, "Simple search" do
       set :lid, listing['id'].match(/(\d+)/)[0]
     end
     response 404 do 
-      fail "No results"
+      quit "No results"
     end
   end
   

data/examples/variables/plan.rb

@@ -28,6 +28,9 @@ usecase "Form Example" do
   get "$uri/search" do
     param :what => resource(:globalvar)
     response do
+      if resource(:globalvar).nil?
+        abort "Usage: stella --var globalvar=smoked verify -p examples/variables/plan.rb"
+      end
       puts "  Global variable: " << resource(:globalvar)
       puts "  Usecase variable: " << resource(:uri)
       puts "  Usecase copy of global: " << resource(:apple)

data/lib/stella/cli.rb

@@ -20,13 +20,9 @@ class Stella::CLI < Drydock::Command
     opts[:hosts] = @hosts
     opts[:nowait] = true if @option.nowait
     
-    if @global.remote
-      require 'bone'
-      s = Stella::Service.new Bone['STELLA_SOURCE'], Bone['STELLA_TOKEN']
-      Stella::Engine.service = s
-    end
+    connect_service if @global.remote
     
-    [:'no-templates', :'no-stats', :'no-header', :'no-param'].each do |opt|
+    [:'no-templates', :'no-stats', :'with-header', :'with-param'].each do |opt|
       opts[opt] = @global.send(opt) unless @global.send(opt).nil?
     end
     
@@ -49,6 +45,8 @@ class Stella::CLI < Drydock::Command
       opts[opt] = @global.send(opt) unless @global.send(opt).nil?
     end
     
+    connect_service if @global.remote
+    
     case @global.engine
     when "package"
       ret = Stella::Engine::LoadPackage.run @testplan, opts
@@ -99,6 +97,13 @@ class Stella::CLI < Drydock::Command
   end
   
   private
+  def connect_service
+    if @global.remote
+      s = Stella::Service.new 
+      Stella::Engine.service = s
+    end
+  end
+  
   def create_testplan
     unless @option.testplan.nil? || File.exists?(@option.testplan)
       raise Stella::InvalidOption, "Bad path: #{@option.testplan}" 

data/lib/stella/client/container.rb

@@ -95,18 +95,19 @@ class Stella::Client
     def doc
       return @doc unless @doc.nil?
       return nil if body.nil? || body.empty?
+      str = RUBY_VERSION >= "1.9.0" ? body.force_encoding("UTF-8") : body
       # NOTE: It's important to parse the document on every 
       # request because this container is available for the
       # entire life of a usecase. 
       @doc = case (@response.header['Content-Type'] || []).first
       when /text\/html/
-        Nokogiri::HTML(body)
+        Nokogiri::HTML(str)
       when /text\/xml/
-        Nokogiri::XML(body)
+        Nokogiri::XML(str)
       when /text\/yaml/
-        YAML.load(body)
+        YAML.load(str)
       when /application\/json/
-        JSON.load(body)
+        JSON.load(str)
       end
     end
     

data/lib/stella/client.rb

@@ -63,7 +63,11 @@ module Stella
             # TODO: The first arg is domain and can include a URI path. 
             #       Are there cases where this is important?
             domain = http_auth.domain
-            domain ||= '%s://%s:%d%s' % [uri.scheme, uri.host, uri.port, req.uri] 
+            # When req.uri is a fully qualified URI, domain will be
+            # set to an incorrect value like, http://domain1/http://domain2. 
+            # So we parse it and if that fails we'll set it to the value given.
+            uri_tmp = URI.parse(req.uri).uri rescue req.uri
+            domain ||= '%s://%s:%d%s' % [uri.scheme, uri.host, uri.port, uri_tmp] 
             domain = container.instance_eval &domain if Proc === domain
             Stella.ld "DOMAIN " << domain
             user, pass = http_auth.user, http_auth.pass
@@ -87,8 +91,8 @@ module Stella
           
           container.unique_id = stella_id
           
-          params['__stella'] = container.unique_id unless @opts[:'no-param']
-          headers['X-Stella-ID'] = container.unique_id unless @opts[:'no-header']
+          params['__stella'] = container.unique_id.short if @opts[:'with-param']
+          headers['X-Stella-ID'] = container.unique_id.short if @opts[:'with-header']
           
           meth = req.http_method.to_s.downcase
           Stella.ld "#{req.http_method}: " << "#{req.uri} " << params.inspect

data/lib/stella/common.rb

@@ -250,15 +250,18 @@ module Stella
       @force_stop = true  
       @dthread.join
       @routine.call
+      @finally.call unless @finally.nil?
     end
     def stop?() @force_stop == true end
-  
+    
+    def stopped?() @stopped end
+      
     # Execute yield every FREQUENCY seconds.
     def start
       @dthread ||= Thread.new do
         prev_ptime = Time.now
         loop do
-          break if Stella.abort? || stop?
+          @stopped = true and break if Stella.abort? || stop?
           if (Time.now - prev_ptime).to_i >= @freq
             @routine.call
             prev_ptime = Time.now
@@ -268,7 +271,13 @@ module Stella
       end
       @dthread.abort_on_exception = true
     end
+  
+    def finally(&blk)
+      @finally = blk
+    end
   end
+  
+  
 end
 
 

data/lib/stella/data.rb

@@ -49,7 +49,7 @@ module Stella::Data
     end
     
     def to_templ(meth, *args)
-      Stella::Template.to_templ("#{meth}(#{args_to_str(*args)})")
+      "<%= #{meth}(#{args_to_str(*args)}) %>"
     end
     
   end

data/lib/stella/engine/functional.rb

@@ -15,46 +15,51 @@ module Stella::Engine
             
       client.enable_nowait_mode if opts[:nowait]
       
+      @testrun = Stella::Testrun.new plan, [:do_request, :failed], opts
+      @testrun.mode = 'f'      
+      
       if Stella::Engine.service
         Stella::Engine.service.testplan_sync plan
-        Stella::Engine.service.testrun_create opts
+        Stella::Engine.service.testrun_create @testrun
         Stella::Engine.service.client_create client.digest, :index => client.index
       end
       
       Stella.stdout.info2 $/, "Starting test...", $/
       
-      # Identify this thread to Benelux
-      Benelux.current_track :functional 
-      
       start_time = Time.now.utc
       
-      dig = Stella.stdout.lev > 1 ? plan.digest_cache : plan.digest_cache.shorter
-      Stella.stdout.info " %-65s  ".att(:reverse) % ["#{plan.desc}  (#{dig})"]
-      plan.usecases.each_with_index do |uc,i|
-        desc = (uc.desc || "Usecase ##{i+1}")
-        dig = Stella.stdout.lev > 1 ? uc.digest_cache : uc.digest_cache.shorter
-        Stella.stdout.info ' %-65s '.att(:reverse).bright % ["#{desc}  (#{dig}) "]
-        Stella.rescue { client.execute uc }
+      thread = Thread.new do
+        # Identify this thread to Benelux
+        Benelux.current_track :functional
+        
+        dig = Stella.stdout.lev > 1 ? plan.digest_cache : plan.digest_cache.shorter
+        Stella.stdout.info " %-65s  ".att(:reverse) % ["#{plan.desc}  (#{dig})"]
+        plan.usecases.each_with_index do |uc,i|
+          desc = (uc.desc || "Usecase ##{i+1}")
+          Benelux.add_thread_tags :usecase => uc.digest_cache
+          dig = Stella.stdout.lev > 1 ? uc.digest_cache : uc.digest_cache.shorter
+          Stella.stdout.info ' %-65s '.att(:reverse).bright % ["#{desc}  (#{dig}) "]
+          Stella.rescue { client.execute uc }
+        end
       end
       
+      thread.join
+      
       test_time = Time.now.utc - start_time
       
+      #Benelux.update_global_timeline
+      
       # Need to use thread timeline b/c the clients are running in the
       # main thread which Benelux.update_global_timeline does not touch.
-      tt = Benelux.thread_timeline
-      
-      failed = tt.stats.group(:failed).merge
-      total = tt.stats.group(:do_request).merge
+      tt = thread.timeline
       
       if Stella::Engine.service
         data = tt.messages.filter(:kind => :log).to_json
         Stella::Engine.service.client_log client.digest, data
-        Stella::Engine.service.testrun_summary :successful => (total.n-failed.n),
-                                               :failed => failed.n,
-                                               :duration => test_time
+        @testrun.add_sample 1, 1, tt
       end
       
-      failed == 0
+      @testrun.summary[:summary][:failed].n == 0 
     end
     
     
@@ -78,7 +83,7 @@ module Stella::Engine
       Benelux.thread_timeline.add_message log, :status => container.status, :kind => :log
       
       msg = '  %-6s %-53s ' % [req.http_method, uri]
-      msg << container.status.to_s if Stella.stdout.lev == 1
+      msg << container.status.to_s if Stella.stdout.lev <= 2
       Stella.stdout.info msg
       
       Stella.stdout.info2 $/, "   Params:"
@@ -143,6 +148,7 @@ module Stella::Engine
     end
     
     def update_usecase_quit client_id, msg, req, container
+      Benelux.thread_timeline.add_count :failed, 1
       Stella.stdout.info "  QUIT   %s" % [msg]
     end
     
@@ -152,6 +158,7 @@ module Stella::Engine
     end
     
     def update_request_error client_id, msg, req, container
+      Benelux.thread_timeline.add_count :failed, 1
       Stella.stdout.info "  ERROR   %s" % [msg]
     end
     
@@ -164,6 +171,7 @@ module Stella::Engine
     end
     
     def update_request_timeout(client_id, usecase, uri, req, params, headers, counter, container)
+      Benelux.thread_timeline.add_count :failed, 1
       Stella.stdout.info "  TIMEOUT   %-53s" % [uri]
     end
     

data/lib/stella/engine/load_create.rb

@@ -13,11 +13,13 @@ module Stella::Engine
       
       time_started = Time.now
 
+      
       (1..reps).to_a.each { |rep|
         @real_reps += 1  # Increments when duration is specified.
         Stella.stdout.info3 "*** REPETITION #{@real_reps} of #{reps} ***"
         packages.each { |package|
           if running_threads.size <= packages.size
+            Stella::Engine.service.client_create package.client.digest, :index => package.client.index
             @threads << Thread.new do
               c, uc = package.client, package.usecase
               msg = "THREAD START: client %s: " % [c.digest.short] 
@@ -40,6 +42,7 @@ module Stella::Engine
             Stella.sleep CREATE_THREAD_SLEEPx
           end
           
+          @current_clients = running_threads.size
           if running_threads.size > @max_clients
             @max_clients = running_threads.size
           end

data/lib/stella/engine/load_queue.rb

@@ -73,8 +73,9 @@ module Stella::Engine
         
         unless arrival.nil?
           # Create 1 second / users per second 
-          args = [1/arrival, @threads.size, packages.size]
-          Stella.stdout.info2 $/, "======== ARRIVAL (%s): %s of %s" % args
+          args = [@threads.size, packages.size]
+          Stella.stdout.print 2, '+'
+          Stella.stdout.info3 $/, "-> NEW CLIENT: %s of %s" % args
           sleep 1/arrival
         end
       }

data/lib/stella/engine/loadbase.rb

@@ -26,7 +26,7 @@ module Stella::Engine
         File.unlink latest if File.exists? latest
         FileUtils.ln_sf File.basename(@logdir), latest
       end
-
+        
       @reqlog = Stella::Logger.new log_path(plan, 'requests')
       @failog = Stella::Logger.new log_path(plan, 'requests-exceptions')
       @sumlog = Stella::Logger.new log_path(plan, 'summary')
@@ -48,14 +48,23 @@ module Stella::Engine
       @optlog.add_template :head, '%10s: %s'
       @failog.add_template :request, '%s %s'
       
-      @dumper = prepare_dumper(plan, opts)
-      
       if Stella.stdout.lev > 2
         Load.timers += [:query, :connect, :socket_gets_first_byte, :get_body]
         Load.counts  = [:request_header_size, :request_content_size]
         Load.counts += [:response_headers_size, :response_content_size]
       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
+      end
+      
+      @dumper = prepare_dumper(plan, opts)
+      
       counts = calculate_usecase_clients plan, opts
       
       @optlog.head 'RUNID', runid(plan)
@@ -79,7 +88,6 @@ module Stella::Engine
         @optlog.head "START", Time.now.to_s
         Stella.stdout.status "Running" 
         execute_test_plan packages, opts[:repetitions], opts[:duration], opts[:arrival]
-        Stella.stdout.info $/, "Done" 
       rescue Interrupt
         Stella.stdout.info $/, "Stopping test"
         Stella.abort!
@@ -89,47 +97,27 @@ module Stella::Engine
         STDERR.puts ex.backtrace if Stella.debug? || Stella.stdout.lev >= 3
       end
       
+      Stella.stdout.status "Processing"
+      
       @optlog.head "END", Time.now.to_s
       @optlog.flush
       
       @dumper.stop
       
-      Stella.stdout.status "Processing" 
-      
-      Benelux.update_global_timeline
-      
       bt = Benelux.timeline
       tt = Benelux.thread_timeline
       
+      
+      # TODO: don't get test time from benelux. 
       test_time = tt.stats.group(:execute_test_plan).mean
       generate_report @sumlog, plan, test_time
-      report_time = tt.stats.group(:generate_report).mean
-      
-      # Here is the calcualtion for the number of
-      # Benelux assets created for each request:
-      # 
-      #     [5*2*REQ+6, 5*1*REQ+3, 13*REQ]
-      # 
-      
-      failed = bt.stats.group(:failed).merge
-      total = bt.stats.group(:do_request).merge
-      
-      @sumlog.info $/, "Summary: "
-      @sumlog.dsummary 'successful req', total.n
-      @sumlog.dsummary "failed req", failed.n
-      @sumlog.dsummary "max clients", @max_clients
-      @sumlog.dsummary "repetitions", @real_reps
-      @sumlog.fsummary "test time", test_time
-      @sumlog.fsummary "reporting time", report_time
-      @sumlog.flush
+      #report_time = tt.stats.group(:generate_report).mean
       
       Stella.stdout.info File.read(@sumlog.path)
-      # DNE:
-      #p [@real_reps, total.n]
       
       Stella.stdout.info $/, "Log dir: #{@logdir}"
       
-      failed.n == 0
+      @testrun.summary[:summary][:failed].n == 0 
     end
     
   protected
@@ -143,84 +131,38 @@ module Stella::Engine
     end
     
     def prepare_dumper(plan, opts)
-      Stella::Hand.new(15.seconds, 2.seconds) do
+      hand = Stella::Hand.new(LoadQueue::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
+        
         #reqlog.info [Time.now, Benelux.timeline.size].inspect
         @reqlog.info Benelux.timeline.messages.filter(:kind => :request)
         @failog.info Benelux.timeline.messages.filter(:kind => :exception)
         @failog.info Benelux.timeline.messages.filter(:kind => :timeout)
         @authlog.info Benelux.timeline.messages.filter(:kind => :authentication)
         @reqlog.clear and @failog.clear and @authlog.clear
+        
         Benelux.timeline.clear if opts[:"no-stats"]
+        
       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, opts
-          client.add_observer(self)
-          client.enable_nowait_mode if opts[:nowait]
-          Stella.stdout.info4 "Created client #{client.digest.short}"
-          ThreadPackage.new(index+1, client, usecase)
-        end
-        pointer += count
+      hand.finally do
+        #total = @testrun.stats[:summary][:do_request].n 
+        #failed = @testrun.stats[:summary][:failed].n 
+        #@sumlog.info $/, "Summary: "
+        #@sumlog.dsummary 'successful req', total-failed
+        #@sumlog.dsummary "failed req", failed
+        #@sumlog.dsummary "max clients", @max_clients
+        #@sumlog.dsummary "repetitions", @real_reps
+        ##@sumlog.fsummary "test time", test_time
+        ##@sumlog.fsummary "reporting time", report_time
+        #@sumlog.flush
       end
-      packages.compact # TODO: Why one nil element sometimes?
+      hand
     end
-    
-    def execute_test_plan(*args)
-      raise "Override execute_test_plan method in #{self}"
-    end
-    
-    def running_threads
-      @threads.select { |t| t.status }  # non-false status are still running
-    end
-    
-    def generate_runtime_report(plan)
-      gt = Benelux.timeline
-      gstats = gt.stats.group(:do_request).merge
-      
-      plan.usecases.uniq.each_with_index do |uc,i| 
-        uc.requests.each do |req| 
-          filter = [uc.digest_cache, req.digest_cache]
 
-          Load.timers.each do |sname|
-            stats = gt.stats.group(sname)[filter].merge
-            #Stella.stdout.info stats.inspect
-            puts [sname, stats.min, stats.mean, stats.max, stats.sd, stats.n].join('; ')
-          end
-          
-        end
-      end
-      
-    end
-        
     def generate_report(sumlog,plan,test_time)
       global_timeline = Benelux.timeline
       global_stats = global_timeline.stats.group(:do_request).merge
@@ -229,8 +171,6 @@ 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| 
         
@@ -242,18 +182,19 @@ module Stella::Engine
         desc = uc.desc || "Usecase ##{i+1} "
         desc << "  (#{uc.digest_cache.shorter}) "
         str = ' ' << " %-66s %s   %d%% ".bright.att(:reverse)
-        @sumlog.info str % [desc, '', uc.ratio_pretty]
-        
+        @sumlog.info str % [desc, '', uc.ratio_pretty]        
         uc.requests.each do |req| 
           filter = [uc.digest_cache, req.digest_cache]
           desc = req.desc 
           @sumlog.info "   %-72s ".bright % ["#{req.desc}  (#{req.digest_cache.shorter})"]
           @sumlog.info "    %s" % [req.to_s]
+
           Load.timers.each do |sname|
             stats = global_timeline.stats.group(sname)[filter].merge
 #            Stella.stdout.info stats.inspect
             str = '      %-30s %.3f <= ' << '%.3fs' << ' >= %.3f; %.3f(SD) %d(N)'
-            @sumlog.info str % [sname, stats.min, stats.mean, stats.max, stats.sd, stats.n]
+            msg = str % [sname, stats.min, stats.mean, stats.max, stats.sd, stats.n]
+            @sumlog.info msg
             @sumlog.flush
           end
           @sumlog.info $/
@@ -320,6 +261,75 @@ module Stella::Engine
     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, opts
+          client.add_observer(self)
+          client.enable_nowait_mode if opts[:nowait]
+          Stella.stdout.info4 "Created client #{client.digest.short}"
+          ThreadPackage.new(index+1, client, usecase)
+        end
+        pointer += count
+      end
+      packages.compact # TODO: Why one nil element sometimes?
+      # Randomize so when ramping up load
+      # we get a mix of usecases. 
+      packages.sort_by {rand}
+    end
+    
+    def execute_test_plan(*args)
+      raise "Override execute_test_plan method in #{self}"
+    end
+    
+    def running_threads
+      @threads.select { |t| t.status }  # non-false status are still running
+    end
+    
+    def generate_runtime_report(plan)
+      gt = Benelux.timeline
+      gstats = gt.stats.group(:do_request).merge
+      
+      plan.usecases.uniq.each_with_index do |uc,i| 
+        uc.requests.each do |req| 
+          filter = [uc.digest_cache, req.digest_cache]
+
+          Load.timers.each do |sname|
+            stats = gt.stats.group(sname)[filter].merge
+            #Stella.stdout.info stats.inspect
+            puts [sname, stats.min, stats.mean, stats.max, stats.sd, stats.n].join('; ')
+          end
+          
+        end
+      end
+      
+    end
+    
     def update_prepare_request(client_id, usecase, req, counter)
      
     end
@@ -367,7 +377,7 @@ module Stella::Engine
         Stella.ld ex.backtrace
       end
     end
-
+    
     def update_usecase_quit client_id, msg, req, container
       args = [Time.now.to_f, Stella.sysinfo.hostname, client_id.short]
       Benelux.thread_timeline.add_count :quit, 1
@@ -393,7 +403,7 @@ module Stella::Engine
         Stella.le '  Client-%s %-45s %s' % [client_id.shorter, desc, ex.message]
       end
     end
-    
+      
     def update_request_repeat client_id, counter, total, req, container
       Stella.stdout.info3 "  Client-%s     REPEAT   %d of %d" % [client_id.shorter, counter, total]
     end

data/lib/stella/engine.rb

@@ -4,6 +4,7 @@ module Stella::Engine
   class << self
     attr_accessor :service
   end
+  # See functional.rb
   class Log < Storable
     include Selectable::Object
     field :stamp
@@ -23,6 +24,8 @@ module Stella::Engine
   module Base
     extend self
     
+    @testrun = nil
+    
     @@client_limit = 1000
     
     def update(*args)
@@ -84,6 +87,7 @@ module Stella::Engine
       opts
     end
     
+    
     def run; raise; end
     def update_usecase_quit(client_id, msg) raise end
     def update_request_repeat(client_id, counter, total) raise end
@@ -119,3 +123,98 @@ module Stella::Engine
 
 end
 
+class Stella::Testrun < Storable
+  extend Attic
+  attic :remote_digest
+  field :samples => Array
+  field :plan
+  field :summary
+  field :hosts
+  field :events
+  field :mode  # (f)unctional or (l)oad
+  field :clients => Integer
+  field :duration => Integer
+  field :arrival => Float
+  field :repetitions => Integer
+  field :nowait => Integer
+  def initialize(plan, events, opts={})
+    @plan, @events = plan, events
+    @samples, @summary = nil, nil
+    opts.each_pair do |n,v|
+      self.send("#{n}=", v) if has_field? n
+    end
+    reset
+  end
+  
+  def reset
+    @samples = []
+    @summary = { :summary => {} }
+    @plan.usecases.each do |uc|
+      @events.each do |event|
+        @summary[:summary][event] = Benelux::Stats::Calculator.new
+        @summary[uc.digest] ||= { :summary => {} }
+        @summary[uc.digest][:summary][event] = Benelux::Stats::Calculator.new
+        uc.requests.each do |req|
+          @summary[uc.digest][req.digest] ||= {}
+          @summary[uc.digest][req.digest][event] = Benelux::Stats::Calculator.new
+        end
+      end
+    end
+  end
+  
+  def add_sample batch, concurrency, tl
+    
+    opts = {
+      :batch => batch, 
+      :duration => tl.duration,
+      :stamp => Time.now.utc.to_i,
+      :concurrency => concurrency
+    }
+    
+    sam = Stella::Testrun::Sample.new opts
+    
+    @plan.usecases.uniq.each_with_index do |uc,i| 
+      sam.stats[uc.digest] ||= { }
+      uc.requests.each do |req| 
+        sam.stats[uc.digest][req.digest] ||= {}
+        filter = [uc.digest, req.digest]
+        @events.each_with_index do |event,idx|  # do_request, etc...
+          stats = tl.stats.group(event)[filter].merge
+          sam.stats[uc.digest][req.digest][event] = stats
+          # Tally request, usecase and total summaries at the same time. 
+          @summary[uc.digest][req.digest][event] += stats
+          @summary[uc.digest][:summary][event] += stats
+          @summary[:summary][event] += stats
+        end
+      end
+    end
+    
+    @samples << sam
+    
+    begin
+      if Stella::Engine.service
+        Stella::Engine.service.testrun_stats @summary, @samples
+      end
+    rescue => ex
+      Stella.stdout.info "Error syncing to #{Stella::Engine.service.source}"
+      Stella.stdout.info ex.message, ex.backtrace if Stella.debug?
+    end
+    
+  end
+  
+  
+  class Sample < Storable
+    field :batch
+    field :concurrency
+    field :stamp
+    field :duration
+    field :stats => Hash
+    #gibbler :batch, :concurrency, :stamp, :duration
+    def initialize(opts={})
+      opts.each_pair do |n,v|
+        self.send("#{n}=", v) if has_field? n
+      end
+      @stats = { }
+    end
+  end
+end

data/lib/stella/logger.rb

@@ -1,8 +1,10 @@
 
 
 module Stella
+  
 
   class Logger
+    
     @@disable = false
     def self.disable!()  @@disable = true  end
     def self.disabled?()  @@disable == true end

data/lib/stella/service.rb

@@ -1,6 +1,77 @@
 Stella::Utils.require_vendor "httpclient", '2.1.5.2'
 
+class Hash
+  
+  # Courtesy of Julien Genestoux
+  def flatten
+    params = {}
+    stack = []
+
+    each do |k, v|
+      if v.is_a?(Hash)
+        stack << [k,v]
+      elsif v.is_a?(Array)
+        stack << [k,Hash.from_array(v)]
+      else
+        params[k] =  v
+      end
+    end
+
+    stack.each do |parent, hash|
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          stack << ["#{parent}[#{k}]", v]
+        else
+          params["#{parent}[#{k}]"] = v
+        end
+      end
+    end
+
+    params
+  end
+  
+  # Courtesy of Julien Genestoux
+  # See: http://stackoverflow.com/questions/798710/how-to-turn-a-ruby-hash-into-http-params
+  def to_params
+    params = ''
+    stack = []
+
+    each do |k, v|
+      if v.is_a?(Hash)
+        stack << [k,v]
+      elsif v.is_a?(Array)
+        stack << [k,Hash.from_array(v)]
+      else
+        params << "#{k}=#{v}&"
+      end
+    end
+
+    stack.each do |parent, hash|
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          stack << ["#{parent}[#{k}]", v]
+        else
+          params << "#{parent}[#{k}]=#{v}&"
+        end
+      end
+    end
+
+    params.chop! 
+    params
+  end
+  def self.from_array(array = [])
+    h = Hash.new
+    array.size.times do |t|
+      h[t] = array[t]
+    end
+    h
+  end
+
+end
+
+
 class Stella::Service
+  attr_accessor :runid, :tid, :uid, :rtid
   class Problem < Stella::Error
     def res() @obj end
   end
@@ -60,27 +131,53 @@ class Stella::Service
       obj = JSON.parse res.content
       @rtid = obj['digest']
     end
-    def testrun_create(opts={})
+    def testrun_create(trun)
       raise NoTestplanSelected unless @tid
       req = uri('v1', 'testrun', "create.json")
       params = {
         :tid => @tid,
-        :start_time => Stella::START_TIME
-      }.merge! opts
+        :v => Stella::VERSION.to_s,
+        :start_at => Stella::START_TIME.to_i,
+        :mode => trun.mode,
+        :clients => trun.clients,
+        :duration => trun.duration,
+        :arrival => trun.arrival,
+        :repetitions => trun.repetitions,
+        :nowait => trun.nowait,
+        :hosts => trun.hosts,
+        :status => 'created'
+      }
       res = send_request :post, req, params
       obj = JSON.parse res.content
       Stella.ld "CREATED TRUN: #{obj.inspect}"
+      trun.remote_digest = obj['digest']
       @runid = obj['digest']
     end
-    def testrun_summary(opts={})
+    def testrun_stats(summary, samples)
+      raise NoTestrunSelected, "no testrun: #{runid}" unless @runid
+      req = uri('v1', 'testrun', "stats.json")
+      params = {
+        :runid => @runid,
+        :status => 'running',
+        :summary => summary.to_json,
+        :samples => samples.to_json
+      }
+      res = send_request :post, req, params
+      obj = JSON.parse res.content
+      Stella.ld "TESTRUN STATS: #{obj.inspect}"
+      @runid
+    end
+    def testrun_finalize(duration)
       raise NoTestrunSelected unless @runid
-      req = uri('v1', 'testrun', 'summary', "create.json")
+      req = uri('v1', 'testrun', "finalize.json")
       params = {
-        :runid => @runid
-      }.merge! opts
+        :runid => @runid,
+        :duration => duration,
+        :status => 'complete'
+      }
       res = send_request :post, req, params
       obj = JSON.parse res.content
-      Stella.ld "CREATED SUMMARY: #{obj.inspect}"
+      Stella.ld "FINALIZE TESTRUN: #{obj.inspect}"
       @runid
     end
     def client_create(clientid, opts={})
@@ -148,6 +245,14 @@ class Stella::Service
   attr_accessor :tid, :uid, :rtid, :runid
   
   def initialize(source=nil,apikey=nil)
+    begin
+      require 'bone'
+    rescue LoadError
+    end
+    if defined?(Bone)
+      source ||= Bone['STELLA_SOURCE'] rescue nil
+      apikey ||= Bone['STELLA_TOKEN'] rescue nil
+    end
     source ||= ENV['STELLA_SOURCE']
     apikey ||= ENV['STELLA_TOKEN']
     @source, @apikey = source, apikey
@@ -166,7 +271,9 @@ class Stella::Service
   
   def send_request(meth, uri, params={}, headers={})
     headers['X-TOKEN'] ||= @apikey
+
     params = process_params(params)
+
     if meth == "delete"
       args = [meth, uri, headers]
     else
@@ -175,7 +282,6 @@ class Stella::Service
     res = @http_client.send(*args) # booya!
     
     if res.status > 200
-      puts res.content
       raise Problem.new(res) 
     end
     

data/lib/stella.rb

@@ -22,7 +22,7 @@ module Stella
     unless defined?(MAJOR)
       MAJOR = 0.freeze
       MINOR = 8.freeze
-      TINY  = 0.freeze
+      TINY  = 1.freeze
       PATCH = '001'.freeze 
     end
     def self.to_s; [MAJOR, MINOR, TINY].join('.'); end
@@ -50,17 +50,12 @@ class Stella::Template
   attr_reader :src
   def initialize(src)
     src = src.to_s
-    @src, @template = src, ERB.new(Stella::Template.to_templ(src))
+    @src, @template = src, ERB.new(src)
   end
   def result(binding)
     @template.result(binding)
   end
   def to_s() src end
-  private
-  def self.to_templ(str)
-    return str if str.match(/\A<%.+%>\z/)
-    "<%= #{str} %>"
-  end
 end
 
 module Stella
@@ -83,7 +78,7 @@ module Stella
   class << self
     attr_accessor :log, :stdout
   end
-
+  
   def le(*msg); stdout.info "  " << msg.join("#{$/}  ").color(:red); end
   def ld(*msg)
     return unless Stella.debug?
@@ -129,6 +124,16 @@ module Stella
   autoload :Client, 'stella/client'
   autoload :Service, 'stella/service'
   
+  def get(uri, query={})
+    require 'stella/client'
+    http_client = HTTPClient.new :agent_name => "Opera/9.51 (Windows NT 5.1; U; en)"
+    http_client.get(uri, query).body.content
+  rescue => ex
+    STDERR.puts ex.message
+    STDERR.puts ex.backtrace if Stella.debug?
+    nil
+  end
+  
 end
 
 Stella.stdout.lev = Stella.quiet? ? 0 : 1

data/stella.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "stella"
   s.rubyforge_project = 'stella'
-  s.version = "0.8.0.001"
+  s.version = "0.8.1.001"
   s.summary = "Blame Stella for breaking your web application!"
   s.description = s.summary
   s.author = "Delano Mandelbaum"
@@ -14,8 +14,8 @@
   s.require_paths = %w[lib]
   
   s.executables = %w[stella]
-  
-  s.add_dependency 'benelux',    '>= 0.5.3'
+                          
+  s.add_dependency 'benelux',    '>= 0.5.6'
   s.add_dependency 'drydock',    '>= 0.6.8'
   s.add_dependency 'gibbler',    '>= 0.7.3'
   s.add_dependency 'sysinfo',    '>= 0.7.1'

data/vendor/httpclient-2.1.5.2/httpclient/http.rb

@@ -364,7 +364,12 @@ module HTTP
           set('Last-Modified', @body_date.httpdate)
         end
         if self['Content-Type'].empty?
-          set('Content-Type', "#{ @body_type || 'text/html' }; charset=#{ charset_label(@body_charset || $KCODE) }")
+          if RUBY_VERSION < "1.9"
+            charset = charset_label(@body_charset || $KCODE)
+          else
+            charset = charset_label(@body_charset)
+          end
+          set('Content-Type', "#{ @body_type || 'text/html' }; charset=#{ charset }")
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: stella
 version: !ruby/object:Gem::Version 
-  version: 0.8.0.001
+  version: 0.8.1.001
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-26 00:00:00 -05:00
+date: 2010-02-10 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.5.3
+        version: 0.5.6
     version: 
 - !ruby/object:Gem::Dependency 
   name: drydock