stella 0.7.0.006 → 0.7.0.012

data/lib/stella/client.rb

@@ -4,86 +4,100 @@ require 'nokogiri'
 
 module Stella
   class Client
+    require 'stella/client/modifiers'
+    require 'stella/client/container'
+    
     include Gibbler::Complex
     include Observable
     
     attr_reader :client_id
     attr_accessor :base_uri
     attr_accessor :proxy
-    attr_reader :stats
+    
     def initialize(base_uri=nil, client_id=1)
       @base_uri, @client_id = base_uri, client_id
-      @cookie_file = Tempfile.new('stella-cookie')
-      @stats = Stella::Stats.new("Client #{@client_id}")
+      #@cookie_file = File.new("cookies-#{client_id}", 'w')
       @proxy = OpenStruct.new
     end
-    
-    def execute(usecase)
+    def execute(usecase, &stat_collector)
+      # We need to make sure the gibbler cache has a value
+      self.gibbler if self.__gibbler_cache.nil?
+      
       http_client = create_http_client
+      stats = {}
       container = Container.new(usecase)
       counter = 0
       usecase.requests.each do |req|
         counter += 1
+        
+        stats ||= Benelux::Stats.new
         update(:prepare_request, usecase, req, counter)
         uri_obj = URI.parse(req.uri)
-        params = prepare_params(usecase, req.params)
-        headers = prepare_headers(usecase, req.headers)
+        params = prepare_params(container, req.params)
+        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, params, headers, counter].gibbler
+        
+        Benelux.add_thread_tags :request => req.gibbler_cache
+        Benelux.add_thread_tags :retry => counter
+        Benelux.add_thread_tags :stella_id => stella_id
         
-        unique_id = [req, params, headers, counter].gibbler
-        req_id = req.gibbler
+        params['__stella'] = stella_id
+        headers['X-Stella-ID'] = stella_id
         
         meth = req.http_method.to_s.downcase
         Stella.ld "#{req.http_method}: " << "#{uri_obj.to_s} " << params.inspect
 
         begin
-          send_request http_client, usecase, meth, uri, req, params, headers, container
+          send_request http_client, usecase, meth, uri, req, params, headers, container, counter
+          #http_client.save_cookie_store
+          update(:stats, http_client, usecase, req)
         rescue => ex
           update(:request_error, usecase, uri, req, params, ex)
           next
         end
         
-        #probe_header_size(container.response)
-        #probe_body_size(container.response)
-        
+        Benelux.add_thread_tags :status => container.status
         ret = execute_response_handler container, req
+        Benelux.remove_thread_tags :status
         
         Stella.lflush
         
+        run_sleeper(req.wait) if req.wait && !nowait?
+        
         # TODO: consider throw/catch
         case ret.class.to_s
         when "Stella::Client::Repeat"
-          Stella.ld "REPETITION: #{counter} of #{ret.times+1}"
+          update(:repeat_request, counter, ret.times+1)
           redo if counter <= ret.times
         when "Stella::Client::Quit"
-          Stella.ld "QUIT USECASE: #{ret.message}"
+          update(:quit_usecase, ret.message)
           break
         end
       
-        
         counter = 0 # reset
-        run_sleeper(req.wait) if req.wait && !benchmark?
       end
+      Benelux.remove_thread_tags :retry, :request, :stella_id
+      stats
     end
     
-    def enable_benchmark_mode; @bm = true; end
-    def disable_benchmark_mode; @bm = false; end
-    def benchmark?; @bm == true; end
+    def enable_nowait_mode; @nowait = true; end
+    def disable_nowait_mode; @nowait = false; end
+    def nowait?; @nowait == true; end
       
   private
-    def send_request(http_client, usecase, meth, uri, req, params, headers, container)
-      update(:send_request, usecase, uri, req, params, container)
+    def send_request(http_client, usecase, meth, uri, req, params, headers, container, counter)
       container.response = http_client.send(meth, uri, params, headers) # booya!
-      update(:receive_response, usecase, uri, req, params, container)
+      update(:receive_response, usecase, uri, req, counter, container)
     end
     
     def update(kind, *args)
-      changed and notify_observers(kind, @client_id, *args)
+      changed and notify_observers(kind, self.__gibbler_cache, *args)
     end
   
     def run_sleeper(wait)
-      if wait.is_a?(Range)
+      if wait.is_a?(::Range)
         ms = rand(wait.last * 1000).to_f 
         ms = wait.first if ms < wait.first
       else
@@ -101,24 +115,23 @@ 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.to_s
-      #http_client.redirect_uri_callback = ??
+      #http_client.set_cookie_store @cookie_file.path
       http_client
     end
     
-    def prepare_params(usecase, params)
+    def prepare_params(container, params)
       newparams = {}
       params.each_pair do |n,v|
         Stella.ld "PREPARE PARAM: #{n}"
-        v = usecase.instance_eval &v if v.is_a?(Proc)
+        v = container.instance_eval &v if v.is_a?(Proc)
         newparams[n] = v
       end
       newparams
     end
     
-    def prepare_headers(usecase, headers)
+    def prepare_headers(container, headers)
       Stella.ld "PREPARE HEADERS: #{headers}"
-      headers = usecase.instance_eval &headers if headers.is_a?(Proc)
+      headers = container.instance_eval &headers if headers.is_a?(Proc)
       headers
     end
     
@@ -132,6 +145,12 @@ module Stella
     # If no replacement value can be found, the variable will remain. 
     def build_request_uri(uri, params, container)
       uri = URI::HTTP.build({:path => uri}) unless uri.is_a?(URI::Generic)
+      
+      if uri.host.nil? && base_uri.nil?
+        Stella.abort!
+        raise NoHostDefined, uri
+      end
+      
       uri.scheme = base_uri.scheme if uri.scheme.nil?
       uri.host = base_uri.host if uri.host.nil?
       uri.port = base_uri.port if uri.port.nil?
@@ -197,52 +216,5 @@ module Stella
       end
     end
     
-    class Container
-      attr_accessor :usecase
-      attr_accessor :response
-      def initialize(usecase)
-        @usecase = usecase
-      end
-      
-      def self.const_missing(const, *args)
-        ResponseError.new(const)
-      end
-      
-      def doc
-        # NOTE: It's important to parse the document on every 
-        # request because this container is available for the
-        # entire life of a usecase. 
-        case @response.header['Content-Type']
-        when ['text/html']
-          Nokogiri::HTML(body)
-        when ['text/yaml']
-          YAML.load(body)
-        end
-      end
-
-      def body; @response.body.content; end
-      def headers; @response.header; end
-        alias_method :header, :headers
-      def status; @response.status; end
-      def set(n, v); usecase.resource n, v; end
-      def resource(n);    usecase.resource n;    end
-      def wait(t); sleep t; end
-      def quit(msg=nil); Quit.new(msg); end
-      def repeat(t=1); Repeat.new(t); end
-    end
-    
-    class ResponseModifier; end
-    class Repeat < ResponseModifier; 
-      attr_accessor :times
-      def initialize(times)
-        @times = times
-      end
-    end
-    class Quit < ResponseModifier; 
-      attr_accessor :message
-      def initialize(msg=nil)
-        @message = msg
-      end
-    end
   end
 end

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

@@ -84,14 +84,14 @@ module Stella::Data::HTTP
     end
     
     def inspect
-      str = "%s %s HTTP/%s" % [http_method, uri.to_s, http_version]
+      str = "%s %s" % [http_method, uri.to_s, http_version]
       #str << $/ + headers.join($/) unless headers.empty?
       #str << $/ + $/ + body.to_s if body
       str
     end
     
     def to_s
-      str = "%s %s HTTP/%s" % [http_method, uri.to_s, http_version]
+      str = "%s %s" % [http_method, uri.to_s, http_version]
       str
     end
     

data/lib/stella/engine/functional.rb

@@ -7,7 +7,7 @@ module Stella::Engine
     def run(plan, opts={})
       opts = {
         :hosts        => [],
-        :benchmark    => false,
+        :nowait    => false,
         :repetitions  => 1
       }.merge! opts
       Stella.ld "OPTIONS: #{opts.inspect}"
@@ -17,7 +17,7 @@ module Stella::Engine
       client = Stella::Client.new opts[:hosts].first
       client.add_observer(self)
 
-      client.enable_benchmark_mode if opts[:benchmark]
+      client.enable_nowait_mode if opts[:nowait]
       
       Stella.li $/, "Starting test...", $/
       Stella.lflush
@@ -25,40 +25,35 @@ module Stella::Engine
       
       plan.usecases.each_with_index do |uc,i|
         desc = (uc.desc || "Usecase ##{i+1}")
-        Stella.li ' %-65s '.att(:reverse).bright % [desc]
+        Stella.li ' %-65s '.att(:reverse).bright % ["#{desc}  (#{uc.gibbler_cache.shorter}) "]
         Stella.rescue { client.execute uc }
       end
       
-      
-      #p client.benelux_at(:execute_start).first.name
-      
-      #p client.benelux_between(:execute_start, :execute_end)
-      
-      #p client.benelux_duration(:execute)
-      
       !plan.errors?
     end
     
     
     def update_prepare_request(client_id, usecase, req, counter)
       notice = "repeat: #{counter-1}" if counter > 1
-      Stella.li2 ' ' << " %-46s %16s ".att(:reverse) % [req.desc, notice]
+      Stella.li2 "  %-46s %16s ".bright % [req.desc, notice]
     end
     
-    def update_send_request(client_id, usecase, uri, req, params, counter)
-
-    end
-    
-    def update_receive_response(client_id, usecase, uri, req, params, container)
-      Stella.li '  %-59s %3d' % [uri, container.status]
-      Stella.li2 "  Method: " << req.http_method
-      Stella.li2 "  Params: " << params.inspect
-      Stella.li3 $/, "  Headers:"
+    def update_receive_response(client_id, usecase, uri, req, counter, container)
+      Stella.li '   %-59s %3d' % [uri, container.status]
+      
+      Stella.li2 '   ' << container.response.request.header.send(:request_line)
+      
+      Stella.li2 $/, "   Request-Headers:"
+      container.response.request.header.all.each do |pair|
+        Stella.li2 "     %s: %s" % pair
+      end
+      
+      Stella.li2 $/, "   Response-Headers:"
       container.headers.all.each do |pair|
-        Stella.li3 "    %s: %s" % pair
+        Stella.li2 "     %s: %s" % pair
       end
-      Stella.li4 $/, "  Content:"
-      Stella.li4 container.body.empty? ? '    [empty]' : container.body
+      Stella.li3 $/, "   Response-Content:"
+      Stella.li3 container.body.empty? ? '     [empty]' : container.body
       Stella.li2 $/
     end
     
@@ -72,7 +67,7 @@ module Stella::Engine
     
     def update_request_error(client_id, usecase, uri, req, params, ex)
       desc = "#{usecase.desc} > #{req.desc}"
-      Stella.le '  Client%-3s %-45s %s' % [client_id, desc, ex.message]
+      Stella.le '  Client-%s %-45s %s' % [client_id.short, desc, ex.message]
       Stella.ld ex.backtrace
     end
     

data/lib/stella/engine/load.rb

@@ -3,13 +3,13 @@ module Stella::Engine
   module Load
     extend Stella::Engine::Base
     extend self
-    
+      
     def run(plan, opts={})
       opts = {
         :hosts        => [],
         :clients        => 1,
         :time         => nil,
-        :benchmark    => false,
+        :nowait    => false,
         :repetitions  => 1
       }.merge! opts
       opts[:clients] = plan.usecases.size if opts[:clients] < plan.usecases.size
@@ -19,50 +19,42 @@ module Stella::Engine
       Stella.li3 "Hosts: " << opts[:hosts].join(', ')
       Stella.li2 plan.pretty
       
-      packages = build_thread_package plan, opts
-      Stella.li $/, "Prepared #{packages.size} virtual clients..."
-      Stella.lflush
-      
+      counts = calculate_usecase_clients plan, opts
       
-      Stella.li $/, "Starting test...", $/
+      Stella.li $/, "Preparing #{counts[:total]} virtual clients...", $/
       Stella.lflush
-      sleep 0.3
+      packages = build_thread_package plan, opts, counts
       
+      Stella.li "Generating load...", $/
+      Stella.lflush
       
-      Thread.ify packages, :threads => opts[:clients] do |package|
-        # TEMPFIX. The fill in build_thread_package is creating nil elements
-        next if package.nil? 
-        (1..opts[:repetitions]).to_a.each do |rep|
-          # We store client specific data in the usecase
-          # so we clone it here so each thread is unique.
-          Stella.rescue { package.client.execute package.usecase }
-        end
-        
-        #package.client.benelux_timeline.each do |i|
-        #  Stella.li "#{package.client.client_id}: #{i.to_f}: #{i.name}"
-        #end
-        #t = Benelux.thread_timeline.sort
-        #dur = t.last.to_f - t.first.to_f
-        #Stella.li [:thread, t.first.name, t.last.name, dur].inspect
-        #Stella.lflush
+      begin
+        execute_test_plan packages, opts[:repetitions]
+      rescue Interrupt
+        Stella.li "Stopping test...", $/
+        Stella.abort!
+      ensure
+        Stella.li "Processing statistics...", $/
+        Stella.lflush
+        generate_report plan
+
+        rep_stats = self.timeline.ranges(:build_thread_package).first    
+        Stella.li "%20s %0.4f" % ['Prep time:', rep_stats.duration]
+
+        rep_stats = self.timeline.ranges(:execute_test_plan).first    
+        Stella.li "%20s %0.4f" % ['Test time:', rep_stats.duration]
+
+        rep_stats = self.timeline.ranges(:generate_report).first    
+        Stella.li "%20s %0.4f" % ['Reporting time:', rep_stats.duration]
+        Stella.li $/
       end
       
-      #t = Benelux.timeline.sort
-      #dur = t.last.to_f - t.first.to_f
-      #Stella.li [:global, t.first.name, t.last.name, dur].inspect
-      
-      #puts Thread.list
-      #p Benelux.timeline
+
       
-      prev = nil
-      #Stella.li Benelux.timeline.sort.collect { |obj|
-      #  str = "#{obj.to_f}: #{obj.name} (#{obj.same_timeline?(prev)})" 
-      #  prev = obj
-      #  str
-      #}
       !plan.errors?
     end
     
+
   protected
     class ThreadPackage
       attr_accessor :index
@@ -73,10 +65,9 @@ module Stella::Engine
       end
     end
     
-    def build_thread_package(plan, opts)
-      packages, pointer = Array.new(opts[:clients]), 0
+    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) 
@@ -88,48 +79,127 @@ module Stella::Engine
         else
           (opts[:clients] * usecase.ratio).to_i
         end
-        
+        counts[usecase.gibbler_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.gibbler_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|
-          Stella.li2 "Creating client ##{index+1} "
+          Stella.li3 "Creating client ##{index+1} "
           client = Stella::Client.new opts[:hosts].first, index+1
           client.add_observer(self)
-          client.enable_benchmark_mode if opts[:benchmark]
-          ThreadPackage.new(index+1, client, usecase.clone)
+          client.enable_nowait_mode if opts[:nowait]
+          ThreadPackage.new(index+1, client, usecase)
         end
         pointer += count
       end
-      packages
+      packages.compact # TODO: Why one nil element sometimes?
     end
     
-    
-    def update_prepare_request(client_id, usecase, req, counter)
-
+    def execute_test_plan(packages, reps=1)
+      Thread.ify packages, :threads => packages.size do |package|
+        
+        # This thread will stay on this one track. 
+        Benelux.current_track package.client.gibbler
+        Benelux.add_thread_tags :usecase => package.usecase.gibbler_cache
+        
+        (1..reps).to_a.each do |rep|
+          Benelux.add_thread_tags :rep =>  rep
+          Stella::Engine::Load.rescue(package.client.gibbler_cache) {
+            print '.' if Stella.loglev == 1
+            stats = package.client.execute package.usecase
+            break if Stella.abort?
+          }
+          Benelux.remove_thread_tags :rep
+        end
+        
+        Benelux.remove_thread_tags :usecase
+      end
+      Stella.li $/, $/
     end
-    
-    def update_send_request(client_id, usecase, uri, req, params, counter)
       
+    def generate_report(plan)
+      Benelux.update_all_track_timelines
+      global_timeline = Benelux.timeline
+      
+      Stella.li $/, " %-72s  ".att(:reverse) % ["#{plan.desc}  (#{plan.gibbler_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.gibbler_cache.shorter}) "
+        str = ' ' << " %-66s %s   %d%% ".bright.att(:reverse)
+        Stella.li str % [desc, '', uc.ratio_pretty]
+        
+        uc.requests.each do |req| 
+          desc = req.desc 
+          Stella.li "   %-72s ".bright % ["#{req.desc}  (#{req.gibbler_cache.shorter})"]
+          Stella.li "    %s" % [req.to_s]
+          global_timeline.stats.each_pair do |n,stat|
+            filter = {
+              :usecase => uc.gibbler_cache,
+              :request => req.gibbler_cache
+            }
+            stats = stat[filter]
+            Stella.li '      %-30s %.3f <= %.3f >= %.3f; %.3f(SD) %d(N)' % [n, stats.min, stats.mean, stats.max, stats.sd, stats.n]
+            Stella.lflush
+          end
+          Stella.li $/
+        end
+      end
     end
     
-    def update_receive_response(client_id, usecase, uri, req, params, container)
+    
+    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.li2 '  Client%-3s %3d %-6s %-45s %s' % [client_id, container.status, req.http_method, desc, uri]
+      Stella.li2 '  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.ld ex.backtrace
     end
     
     def update_request_error(client_id, usecase, uri, req, params, ex)
       desc = "#{usecase.desc} > #{req.desc}"
-      Stella.le '  Client%-3s %-45s %s' % [client_id, desc, ex.message]
+      Stella.li $/ if Stella.loglev == 1
+      Stella.le '  Client-%s %-45s %s' % [client_id.shorter, desc, ex.message]
       Stella.ld ex.backtrace
     end
 
     
+    def self.rescue(client_id, &blk)
+      blk.call
+    rescue => ex
+      Stella.le '  Error in Client-%s: %s' % [client_id.shorter, ex.message]
+      Stella.ld ex.backtrace
+    end
+    
+    
+    Benelux.add_timer Stella::Engine::Load, :generate_report
+    Benelux.add_timer Stella::Engine::Load, :build_thread_package
+    Benelux.add_timer Stella::Engine::Load, :execute_test_plan
+    Benelux.add_timer Stella::Client, :execute_response_handler
   end
 end
 

data/lib/stella/engine.rb

@@ -2,15 +2,20 @@
 
 module Stella::Engine
   
-  Benelux.add_timer      Stella::Client, :execute
-  Benelux.add_timer      Stella::Client, :send_request
+  # These commented out timers are not very revealing.
+  #Benelux.add_timer      Stella::Client, :execute
+  #Benelux.add_timer      Stella::Client, :send_request
+  #Benelux.add_timer          HTTPClient, :create_request
+  
+  # These timers are interesting from a reporting perspective.
   Benelux.add_timer          HTTPClient, :do_request
   Benelux.add_timer HTTPClient::Session, :create_socket
+  Benelux.add_timer HTTPClient::Session, :create_ssl_socket
   Benelux.add_timer HTTPClient::Session, :connect
   Benelux.add_timer HTTPClient::Session, :query
-  Benelux.add_timer HTTPClient::Session, :socket_gets_initial_line
+  Benelux.add_timer HTTPClient::Session, :socket_gets_first_byte
   Benelux.add_timer HTTPClient::Session, :get_body
-  
+
   module Base
     extend self
     
@@ -26,6 +31,22 @@ module Stella::Engine
 
     def run; raise; end
     
+    
+    def update_quit_usecase client_id, msg
+      Stella.li2 "  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 update_stats client_id, http_client, usecase, req
+      #range = Thread.current.timeline.ranges(:do_request).last
+      #Thread.current.stathash 
+      #Stella.li "Client-%s: %s-%s %s %.4f" % [client_id.short, usecase.gibbler.short, req.gibbler.short, req.desc, range.duration]
+    end
+    
     def update_prepare_request(*args) raise end
     def update_send_request(*args) raise end
     def update_receive_response(*args) raise end

data/lib/stella/mixins/thread.rb

@@ -0,0 +1,6 @@
+
+
+class Thread
+  extend Attic
+  attic :stats
+end