stella 0.8.2.003 → 0.8.3.001

data/lib/stella/engine.rb

@@ -34,8 +34,6 @@ module Stella::Engine
       @logdir = nil
     end
     
-    @@client_limit = 1000
-    
     def update(*args)
       what, *args = args
       if respond_to?("update_#{what}")
@@ -49,69 +47,7 @@ module Stella::Engine
     def runid(plan)
       args = [Stella.sysinfo.hostname, Stella.sysinfo.user]
       args.push Stella::START_TIME, plan
-      args.digest
-    end
-    
-    def log_dir(plan, file=nil)
-      stamp = Stella::START_TIME.strftime("%Y%m%d-%H-%M-%S")
-      stamp <<"-#{plan.digest.shorter}"
-      #stamp << "STAMP"
-      l = File.join Stella::Config.project_dir, 'log', stamp
-      FileUtils.mkdir_p l unless File.exists? l
-      l
-    end
-    
-    def log_path(plan, file)
-      File.join log_dir(plan), file
-    end
-    
-    def process_options!(plan, opts={})
-      # Plan must be frozen before running (see freeze methods)
-      plan.frozen? || plan.freeze  
-      
-      opts = {
-        :hosts          => [],
-        :clients        => 1,
-        :duration       => 0,
-        :nowait         => false,
-        :arrival        => nil,
-        :repetitions    => 1
-      }.merge! opts
-      
-      Stella.ld " Options: #{opts.inspect}"
-      
-      unless Array === opts[:hosts]
-        opts[:hosts] = [opts[:hosts]]
-      end
-      
-      opts[:hosts].collect! do |host|
-        if URI::Generic === host
-          host
-        else
-          URI.parse host
-        end
-      end
-      
-      opts[:clients] &&= opts[:clients].to_i
-      opts[:duration] &&= opts[:duration].to_i
-      opts[:arrival] &&= opts[:arrival].to_f
-      opts[:repetitions] &&= opts[:repetitions].to_i
-      opts[:clients] = plan.usecases.size if opts[:clients] < plan.usecases.size
-      
-      if opts[:clients] > @@client_limit
-        Stella.stdout.info2 "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.stdout.info3 " Hosts: " << opts[:hosts].join(', ')
-      opts
+      args.id
     end
     
     
@@ -147,43 +83,214 @@ module Stella::Engine
 end
 
 class Stella::Testrun < Storable
-  extend Attic
-  attic :remote_digest
-  field :samples => Array
-  field :plan
-  field :stats
-  field :hosts
-  field :events
-  field :mode  # (f)unctional or (l)oad
+  CLIENT_LIMIT = 1000
+  include Gibbler::Complex
+  field :id => String, &gibbler_id_processor
+  field :status => String
+  field :userid => String
+  field :start_time => Integer
   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, @stats = nil, nil
-    opts.each_pair do |n,v|
-      self.send("#{n}=", v) if has_field? n
+  field :wait => Float
+  field :nowait => TrueClass
+  field :withparam => TrueClass
+  field :withheader => TrueClass
+  field :notemplates => TrueClass
+  field :nostats => TrueClass
+  field :stats => Hash
+  field :samples => Array
+  field :mode  # verify or generate
+  field :plan
+  field :hosts
+  field :events
+  field :log
+  gibbler :plan, :hosts, :mode, :clients, :duration, :repetitions, :wait, :start_time, :userid
+  def initialize(plan=nil, opts={})
+    @plan = plan
+    process_options! opts if !plan.nil? && !opts.empty?
+    reset_stats
+  end
+  def id
+    @id || self.digest
+  end
+  def has_log?() !@log.nil? && !@log.empty? end
+  def self.from_hash(hash={})
+    me = super(hash)
+    me.plan = Stella::Testplan.from_hash(me.plan)
+    me.process_options! unless me.plan.nil?
+    
+    me.samples.collect! do |sample|
+      Stella::Testrun::Sample.from_hash(sample)
+    end
+
+    me.plan.usecases.uniq.each_with_index do |uc,i| 
+      uc.requests.each do |req| 
+        me.events.each_with_index do |event,idx|  # do_request, etc...
+          event &&= event.to_s
+          me.stats[uc.id][req.id][event] = 
+            Benelux::Stats::Calculator.from_hash(me.stats[uc.id][req.id][event])
+          me.stats[uc.id]['summary'][event] = 
+            Benelux::Stats::Calculator.from_hash(me.stats[uc.id]['summary'][event])
+          me.stats['summary'][event] = 
+            Benelux::Stats::Calculator.from_hash(me.stats['summary'][event])
+        end
+      end
+    end
+    
+    me
+  end
+  
+  def client_options
+    opts = {
+      :nowait => self.nowait || false,
+      :notemplates => self.notemplates || false,
+      :withparam => self.withparam || false,
+      :withheader => self.withheader || false,
+      :wait => self.wait || 0
+    }
+  end
+  
+  def process_options!(opts={})
+    
+    unless opts.empty?
+      opts = {
+        :hosts          => [],
+        :clients        => 1,
+        :duration       => 0,
+        :wait           => 0,
+        :nowait         => false,
+        :arrival        => nil,
+        :repetitions    => 1, 
+        :mode           => :verify
+      }.merge! opts      
+
+      opts.each_pair do |n,v|
+        self.send("#{n}=", v) if has_field? n
+      end
+      
+      Stella.ld " Options: #{opts.inspect}"
     end
-    reset
+    
+    @id &&= Gibbler::Digest.new(@id)
+    
+    @samples ||= []
+    @stats ||= { :summary => {} }
+    
+    @status ||= "new"
+    @events ||= [:response_time, :failed]
+    
+    @start_time ||= Time.now.to_i
+    
+    @events.collect! { |event| event.to_sym }
+    
+    @duration ||= 0
+    @repetitions ||= 0
+    
+    @clients &&= @clients.to_i
+    @duration &&= @duration.to_i
+    @arrival &&= @arrival.to_f
+    @repetitions &&= @repetitions.to_i
+    @wait &&= @wait.to_f
+    
+    @mode &&= @mode.to_sym
+    
+    @hosts = [@hosts] unless Array === @hosts
+    
+    @hosts.collect! do |host|
+      host.to_s
+    end
+    
+    if @clients > CLIENT_LIMIT
+      Stella.stdout.info2 "Client limit is #{CLIENT_LIMIT}"
+      @clients = CLIENT_LIMIT
+    end
+    
+    # Parses 60m -> 3600. See mixins. 
+    @duration = @duration.in_seconds
+    
+    raise Stella::WackyDuration, @duration if @duration.nil?
+    
+    @mode &&= @mode.to_sym
+    
+    unless [:verify, :generate].member?(@mode)
+      raise Stella::Error, "Unsupported mode: #{@mode}"
+    end
+    
+    if Hash === self.plan # When reconstituting from JSON
+      self.plan = Stella::Testplan.from_hash(self.plan)
+    end
+    
+    if Stella::Testplan === self.plan
+      # Plan must be frozen before running (see freeze methods)
+      self.plan.frozen? || self.plan.freeze  
+      @clients = plan.usecases.size if @clients < plan.usecases.size
+    end
+    
+    @id ||= self.gibbler # populate id
+    
+  end
+  
+  def freeze
+    return if frozen?
+    Stella.ld "FREEZE TESTRUN: #{self.id}"
+    plan.freeze
+    super
+    self
   end
   
-  def save(path)
-    Stella::Utils.write_to_file(path, self.to_json, 'w', 0644) 
+  def log_dir
+    # Don't use @start_time here b/c that won't be set 
+    # until just before the actual testing starts. 
+    stamp = Stella::START_TIME.strftime("%Y%m%d-%H-%M-%S")
+    stamp << "-#{self.plan.id.shorter}" unless self.plan.nil?
+    l = File.join Stella::Config.project_dir, 'log', stamp
+    FileUtils.mkdir_p l unless File.exists?(l) || Stella::Logger.disabled?
+    l
   end
   
-  def reset
+  def log_path(file)
+    File.join log_dir, file
+  end
+  
+  
+  def run(opts={})
+    engine = case self.mode 
+    when :verify 
+      Stella::Engine::Functional.new(opts)
+    when :generate
+      Stella::Engine::Load.new(opts)
+    else
+      raise Stella::Error, "Unsupported mode: #{self.mode}"
+    end
+    engine.run self
+    @status = "done"
+    self.freeze
+    self
+  end
+  
+  def save
+    unless Stella::Logger.disabled?
+      path = log_path('stats')
+      Stella::Utils.write_to_file(path, self.to_json, 'w', 0644) 
+    end
+  end
+  
+  def reset_stats
     @samples = []
-    @stats = { :summary => {} }
-    @plan.usecases.each do |uc|
-      @events.each do |event|
-        @stats[:summary][event] = Benelux::Stats::Calculator.new
-        @stats[uc.digest] ||= { :summary => {} }
-        @stats[uc.digest][:summary][event] = Benelux::Stats::Calculator.new
-        uc.requests.each do |req|
-          @stats[uc.digest][req.digest] ||= {}
-          @stats[uc.digest][req.digest][event] = Benelux::Stats::Calculator.new
+    @stats = { 'summary' => {} }
+    unless @plan.nil?
+      @plan.usecases.each do |uc|
+        @events.each do |event|
+          event &&= event.to_s
+          @stats['summary'][event] = Benelux::Stats::Calculator.new
+          @stats[uc.id] ||= { 'summary' => {} }
+          @stats[uc.id]['summary'][event] = Benelux::Stats::Calculator.new
+          uc.requests.each do |req|
+            @stats[uc.id][req.id] ||= {}
+            @stats[uc.id][req.id][event] = Benelux::Stats::Calculator.new
+          end
         end
       end
     end
@@ -201,32 +308,24 @@ class Stella::Testrun < Storable
     sam = Stella::Testrun::Sample.new opts
     
     @plan.usecases.uniq.each_with_index do |uc,i| 
-      sam.stats[uc.digest] ||= { }
+      sam.stats[uc.id] ||= { }
       uc.requests.each do |req| 
-        sam.stats[uc.digest][req.digest] ||= {}
-        filter = [uc.digest, req.digest]
+        sam.stats[uc.id][req.id] ||= {}
+        filter = [uc.id, req.id]
         @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
+          event &&= event.to_s
+          stats = tl.stats.group(event.to_sym)[filter].merge
+          sam.stats[uc.id][req.id][event] = stats
           # Tally request, usecase and total summaries at the same time. 
-          @stats[uc.digest][req.digest][event] += stats
-          @stats[uc.digest][:summary][event] += stats
-          @stats[:summary][event] += stats
+          @stats[uc.id][req.id][event] += stats
+          @stats[uc.id]['summary'][event] += stats
+          @stats['summary'][event] += stats
         end
       end
     end
     
     @samples << sam
     
-    begin
-      if Stella::Engine.service
-        Stella::Engine.service.testrun_stats @stats, @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
-    
     sam
   end
   
@@ -244,5 +343,21 @@ class Stella::Testrun < Storable
       end
       @stats = { }
     end
+    def self.from_hash(hash={})
+      me = super(hash)
+      stats = {}
+      me.stats.each_pair { |ucid,uchash| 
+        stats[ucid] = {}
+        uchash.each_pair { |reqid,reqhash|
+          stats[ucid][reqid] = {}
+          reqhash.each_pair { |event,stat|
+            tmp = Benelux::Stats::Calculator.from_hash(stat)
+            stats[ucid][reqid][event] = tmp
+          }
+        }
+      }
+      me.stats = stats
+      me
+    end
   end
 end

data/lib/stella/logger.rb

@@ -8,18 +8,20 @@ module Stella
     attr_accessor :lev
     attr_reader :templates
     
+    @@disable = false
+    class << self
+      def disable!()  @@disable = true  end
+      def enable!()  @@disable = true  end
+      def disabled?()  @@disable == true end
+    end
+      
     def initialize(output=STDOUT)
       @mutex, @buffer = Mutex.new, StringIO.new
       @lev, @offset = 1, 0
       @templates = {}
       @autoflush = false
-      @disable = false
       self.output = output
     end
-    
-    def disable!()  @disable = true  end
-    def enable!()  @disable = true  end
-    def disabled?()  @disable == true end
       
     def autoflush!()  @autoflush = true   end
     def autoflush?()  @autoflush == true  end
@@ -37,14 +39,14 @@ module Stella
     end
     
     def print(level, *msg)
-      return if level > @lev || disabled?
+      return if level > @lev || self.class.disabled?
       @buffer.print *msg
       flush if autoflush?
       true
     end
     
     def puts(level, *msg)
-      return if level > @lev || disabled?
+      return if level > @lev || self.class.disabled?
       @buffer.puts *msg
       flush if autoflush?
       true
@@ -73,6 +75,7 @@ module Stella
     end
     
     def output=(o)
+      return if self.class.disabled?
       @mutex.synchronize do
         if o.kind_of? String
           o = File.open(o, File::CREAT|File::TRUNC|File::RDWR, 0644)
@@ -83,7 +86,7 @@ module Stella
     
     # TODO: There's a big when using print (no newline)
     def flush
-      return if disabled?
+      return if self.class.disabled?
       @mutex.synchronize do
         #return if @offset == @output.tell
         @buffer.seek @offset
@@ -99,7 +102,7 @@ module Stella
     end
     
     def clear
-      return if disabled?
+      return if self.class.disabled?
       flush
       @mutex.synchronize do
         @buffer.rewind
@@ -108,7 +111,7 @@ module Stella
     end
     
     def close
-      return if disabled?
+      return if self.class.disabled?
       flush
       @buffer.close
       @output.close
@@ -120,7 +123,7 @@ module Stella
   # Must call flush to send to output. 
   class SyncLogger < Logger
     def print(level, *msg)
-      return if level > @lev || disabled?
+      return if level > @lev || self.class.disabled?
       @mutex.synchronize { 
         @buffer.print *msg 
         flush if autoflush?
@@ -130,7 +133,7 @@ module Stella
 
     def puts(level, *msg)
       #Stella.ld [level, @lev, msg]
-      return if level > @lev || disabled?
+      return if level > @lev || self.class.disabled?
       @mutex.synchronize { 
         @buffer.puts *msg 
         flush if autoflush?

data/lib/stella/testplan.rb

@@ -32,14 +32,14 @@ class Testplan < Storable
   attic :plan_path
   attic :description
   
-  field :id, &gibbler_id_processor
+  field :id => String, &gibbler_id_processor
   
-  field :usecases 
-  field :description 
+  field :usecases => Array
+  field :description => String
   #field :resources
   
   # TODO: Add Stellar::TOKEN to the calculation
-  gibbler :id, :usecases, :description
+  gibbler :usecases
   
   def initialize(*uris)
     uris.flatten!
@@ -84,12 +84,23 @@ class Testplan < Storable
   
   # make sure all clients share identical test plans
   def freeze
+    return if frozen?
     Stella.ld "FREEZE TESTPLAN: #{self.description}"
     @usecases.each { |uc| uc.freeze }
     super
     self
   end
   
+  def id
+    Gibbler::Digest.new(@id || self.digest)
+  end
+  
+  def self.from_hash(*args)
+    me = super(*args)
+    me.usecases.collect! { |uc| Stella::Testplan::Usecase.from_hash(uc) }
+    me
+  end
+  
   def usecase(*args, &blk)
     return @usecases if args.empty? && blk.nil?
     ratio, name = nil,nil
@@ -189,16 +200,16 @@ class Testplan
     attic :base_path # we don't want gibbler to see this
     attic :plan_path
     
-    field :id, &gibbler_id_processor
+    field :id => String, &gibbler_id_processor
     
     attic :description
-    field :description
+    field :description => String
     
-    field :ratio
-    field :http_auth
-    field :timeout
-    field :requests
-    field :resources
+    field :ratio => Float
+    field :http_auth => Hash
+    field :timeout => Float
+    field :requests => Array
+    field :resources => Hash
     
     class UnknownResource < Stella::Error
       def message; "UnknownResource: #{@obj}"; end
@@ -209,6 +220,17 @@ class Testplan
       instance_eval &blk unless blk.nil?
     end
     
+    def id
+      Gibbler::Digest.new(@id || self.digest)
+    end
+    
+    def self.from_hash(hash={})
+      me = super(hash)
+      me.requests.collect! { |req| Stella::Data::HTTP::Request.from_hash(req) }
+      me
+    end
+    
+    
     def desc(*args)
       self.description = args.first unless args.empty?
       self.description
@@ -276,7 +298,9 @@ class Testplan
     end
     
     def freeze
+      return if frozen?
       @requests.each { |r| r.freeze }
+      self.id ||= self.digest
       super
       self
     end

data/lib/stella.rb

@@ -101,8 +101,8 @@ module Stella
   def abort!()        @abort =  true  end
   
   def quiet?()        @quiet == true  end
-  def enable_quiet()  @quiet = true; @stdout.disable!;  end
-  def disable_quiet() @quiet = false; @stdout.enable!;  end
+  def enable_quiet()  @quiet = true; Stella::Logger.disable!;  end
+  def disable_quiet() @quiet = false; Stella::Logger.enable!;  end
   
   def add_global(n,v)
     Stella.ld "SETGLOBAL: #{n}=#{v}"

data/stella.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{stella}
-  s.version = "0.8.2.003"
+  s.version = "0.8.3.001"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Delano Mandelbaum"]
-  s.date = %q{2010-03-06}
+  s.date = %q{2010-03-15}
   s.default_executable = %q{stella}
   s.description = %q{Blame Stella for breaking your web application!}
   s.email = %q{delano@solutious.com}
@@ -51,7 +51,6 @@ Gem::Specification.new do |s|
      "lib/stella/engine/load.rb",
      "lib/stella/guidelines.rb",
      "lib/stella/logger.rb",
-     "lib/stella/service.rb",
      "lib/stella/testplan.rb",
      "lib/stella/utils.rb",
      "lib/stella/utils/httputil.rb",
@@ -101,24 +100,24 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<gibbler>, [">= 0.7.4"])
       s.add_runtime_dependency(%q<drydock>, [">= 0.6.9"])
-      s.add_runtime_dependency(%q<benelux>, [">= 0.5.8"])
+      s.add_runtime_dependency(%q<benelux>, [">= 0.5.11"])
       s.add_runtime_dependency(%q<sysinfo>, [">= 0.7.3"])
-      s.add_runtime_dependency(%q<storable>, [">= 0.6.3"])
+      s.add_runtime_dependency(%q<storable>, [">= 0.6.4"])
       s.add_runtime_dependency(%q<nokogiri>, [">= 0"])
     else
       s.add_dependency(%q<gibbler>, [">= 0.7.4"])
       s.add_dependency(%q<drydock>, [">= 0.6.9"])
-      s.add_dependency(%q<benelux>, [">= 0.5.8"])
+      s.add_dependency(%q<benelux>, [">= 0.5.11"])
       s.add_dependency(%q<sysinfo>, [">= 0.7.3"])
-      s.add_dependency(%q<storable>, [">= 0.6.3"])
+      s.add_dependency(%q<storable>, [">= 0.6.4"])
       s.add_dependency(%q<nokogiri>, [">= 0"])
     end
   else
     s.add_dependency(%q<gibbler>, [">= 0.7.4"])
     s.add_dependency(%q<drydock>, [">= 0.6.9"])
-    s.add_dependency(%q<benelux>, [">= 0.5.8"])
+    s.add_dependency(%q<benelux>, [">= 0.5.11"])
     s.add_dependency(%q<sysinfo>, [">= 0.7.3"])
-    s.add_dependency(%q<storable>, [">= 0.6.3"])
+    s.add_dependency(%q<storable>, [">= 0.6.4"])
     s.add_dependency(%q<nokogiri>, [">= 0"])
   end
 end

data/tryouts/70_module_usage.rb

@@ -2,19 +2,20 @@
 
 require 'stella'
 
-Benelux.enable_debug
+#Benelux.enable_debug
+#Stella.stdout.lev = 3
 
 Stella.enable_quiet
-#Stella.stdout.lev = 3
+
 plan = Stella::Testplan.new('http://localhost:3114/search')
 opts = {
   :hosts => '', 
+  :mode => :generate,
   :clients => 100,
   #:duration => 10
 }
 
-#engine = Stella::Engine::Functional.new opts
-engine = Stella::Engine::Load.new opts
-engine.run plan
+testrun = Stella::Testrun.new plan, opts
+testrun.run
 
-puts engine.testrun.stats[:summary].to_json
+puts testrun.to_yaml