stella 0.8.2.003 → 0.8.3.001

data/CHANGES.txt

@@ -11,6 +11,25 @@ STELLA, CHANGES
 * TODO: process templates for calls to set in get blocks
 
 
+#### 0.8.3 (2010-03-15) ###############################
+
+* FIXED: Testrun digest handling
+* FIXED: Testrun.id will be converted to a Gibbler::Digest if it's a String. 
+* FIXED: Reconstituting Testrun from a hash (samples and stats)
+* CHANGE: Removed dashes from CLI params: notemplate, nostats, nowait, withheader, withparam
+* CHANGE: Engine is now called via Testrun#run
+* CHANGE: Use the ID attribute (e.g. Testplan.id) instead of digest or digest_cache (which only
+  be used once to generate an ID 
+* ADDED: Testrun#client_options
+* ADDED: Reconstituting Stella::Testrun and Stella::Testplan objects from JSON/Hash
+* ADDED: Testrun objects are now frozen after the run
+* ADDED: Testrun#userid, Testrun#runinfo
+* ADDED: Default Testrun status is "new"
+* ADDED: Testrun#run now accepts an options hash which is passed to Engine#run
+* ADDED: Engine option: with_content (populate Testrun#log during a load test)
+* ADDED: First batch of requests store header content (for load tests)
+
+
 #### 0.8.2 (2010-03-05) ###############################
 
 * FIXED: Misc issues with usage via module (Stella::Engine.load)

data/Rakefile

@@ -27,9 +27,9 @@ begin
     gem.authors = ["Delano Mandelbaum"]
     gem.add_dependency("gibbler",    ">= 0.7.4")
     gem.add_dependency("drydock",    ">= 0.6.9")
-    gem.add_dependency("benelux",    ">= 0.5.8")
+    gem.add_dependency("benelux",    ">= 0.5.11")
     gem.add_dependency('sysinfo',    '>= 0.7.3')
-    gem.add_dependency('storable',   '>= 0.6.3')
+    gem.add_dependency('storable',   '>= 0.6.4')
     gem.add_dependency("nokogiri")
 
     #gem.add_development_dependency("rspec", ">= 1.2.9")

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :MAJOR: 0
 :MINOR: 8
-:PATCH: 2
-:BUILD: '003'
+:PATCH: 3
+:BUILD: '001'

data/bin/stella

@@ -43,9 +43,8 @@ class Stella::CLI::Definition
     Stella.enable_debug
   end
   global :W, :wait, Integer, "Seconds to wait before starting test"
-  global :'with-header', "Include X-Stella-ID request header" 
-  global :'with-param', "Include __stella query parameter header"
-  global :R, :remote
+  global :H, :withheader, "Include X-Stella-ID request header" 
+  global :P, :withparam, "Include __stella query parameter header"
   global :o, :output, String, "Write output to the given file" do |v|
     String.disable_color
     Stella.log.output = v
@@ -61,10 +60,10 @@ class Stella::CLI::Definition
   global :v, :verbose, "Increase verbosity of output (e.g. -v or -vv or -vvv)" do
     Stella.stdout.lev += 1
   end
-  global :'no-stats', "Disable stat collection" do
+  global :nostats, "Disable stat collection" do
     true
   end
-  global :'no-templates', "Disable template parsing" do
+  global :notemplates, "Disable template parsing" do
     true
   end
   global :V, :version, "Display version number" do

data/lib/proc_source.rb

@@ -1,3 +1,4 @@
+
 require 'stringio'
 require 'irb/ruby-lex'
 #SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__

data/lib/stella/cli.rb

@@ -14,45 +14,34 @@ class Stella::CLI < Drydock::Command
   def verify_valid?
     create_testplan
   end
-  
-  def verify
-    opts = {}
-    opts[:hosts] = @hosts
-    opts[:nowait] = true if @option.nowait
-    
-    connect_service if @global.remote
-    
-    [:'no-templates', :'no-stats', :'with-header', :'with-param'].each do |opt|
-      opts[opt] = @global.send(opt) unless @global.send(opt).nil?
-    end
-    
-    engine = Stella::Engine::Functional.new opts
-    testrun = engine.run @testplan
-    @exit_code = (testrun.stats[:summary][:failed].n == 0 ? 0 : 1)
-  end
-  
+
   def generate_valid?
     create_testplan
   end
   
-  def generate
-    opts = {}
+  def run(mode)
+    opts = { :mode => mode }
     opts[:hosts] = @hosts
     [:nowait, :clients, :repetitions, :duration, :arrival].each do |opt|
       opts[opt] = @option.send(opt) unless @option.send(opt).nil?
     end
-
-    [:'no-templates', :'no-stats', :'no-header', :'no-param'].each do |opt|
+    [:'notemplates', :'nostats', :'noheader', :'noparam'].each do |opt|
       opts[opt] = @global.send(opt) unless @global.send(opt).nil?
     end
-    
-    connect_service if @global.remote
-    
-    engine = Stella::Engine::Load.new opts
-    testrun = engine.run @testplan
-    @exit_code = (testrun.stats[:summary][:failed].n == 0 ? 0 : 1)
+    testrun = Stella::Testrun.new @testplan, opts
+    testrun.run
+    testrun
   end
   
+  def generate
+    testrun = run :generate
+    @exit_code = (testrun.stats['summary']['failed'].n == 0 ? 0 : 1)
+  end
+  def verify
+    testrun = run :verify
+    @exit_code = (testrun.stats['summary']['failed'].n == 0 ? 0 : 1)
+  end
+    
   def example
     base_path = File.expand_path(File.join(STELLA_LIB_HOME, '..'))
     thin_path = File.join(base_path, 'support', 'sample_webapp', 'config.ru')
@@ -88,27 +77,21 @@ 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}" 
     end
-    @hosts = @argv.collect { |uri|; 
-      uri = 'http://' << uri unless uri.match /^https?:\/\//i
-      URI.parse uri; 
-    }
     (@global.var || []).each do |var|
       n, v = *var.split('=')
       raise "Bad variable format: #{var}" if n.nil? || !n.match(/[a-z]+/i)
       Stella::Testplan.global(n.to_sym, v)
     end
     if @option.testplan
+      @hosts = @argv.collect { |uri|; 
+        uri = 'http://' << uri unless uri.match /^https?:\/\//i
+        URI.parse uri; 
+      }
       @testplan = Stella::Testplan.load_file @option.testplan
     else
       opts = {}

data/lib/stella/client.rb

@@ -19,25 +19,33 @@ module Stella
     attr_accessor :created 
     
     gibbler :opts, :index, :base_uri, :proxy, :nowait, :created
-    
-    def initialize(base_uri=nil, index=1, opts={})
+    @@client_index = 0
+    def initialize(base_uri=nil, opts={})
+      @index = @@client_index += 1
       @created = Time.now.to_f
       opts = {
-        :'no-templates' => false
+        :nowait => false,
+        :withparam => false,
+        :withheader => false,
+        :notemplates => false,
+        :wait => 0
       }.merge! opts
       @opts = opts
       @base_uri, @index = base_uri, index
       #@cookie_file = File.new("cookies-#{index}", 'w')
       @proxy = OpenStruct.new
     end
+    def id
+      @id || self.digest
+    end
     def execute(usecase, &stat_collector)
 #      Gibbler.enable_debug
       # We need to make sure the digest cache has a value
-      self.digest if self.digest_cache.nil?
+      @id = self.digest if self.digest_cache.nil?
       Gibbler.disable_debug
       http_client = create_http_client
       stats = {}
-      container = Container.new(self.digest_cache, usecase)
+      container = Container.new(self.id, usecase)
       counter = 0
       usecase.requests.each do |req|
         counter += 1
@@ -58,10 +66,11 @@ module Stella
           container.params, container.headers = params, headers
           
           uri = build_request_uri req.uri, params, container
-          
+
           if http_auth = req.http_auth || usecase.http_auth
             # TODO: The first arg is domain and can include a URI path. 
             #       Are there cases where this is important?
+            
             domain = http_auth.domain
             # When req.uri is a fully qualified URI, domain will be
             # set to an incorrect value like, http://domain1/http://domain2. 
@@ -83,16 +92,16 @@ module Stella
           Stella.ld "TIMEOUT " << http_client.receive_timeout.to_s
           
           raise NoHostDefined, req.uri if uri.host.nil? || uri.host.empty?
-          stella_id = [Time.now.to_f, self.digest_cache, req.digest_cache, params, headers, counter].digest
+          stella_id = [Time.now.to_f, self.id, req.id, params, headers, counter].digest
         
-          Benelux.add_thread_tags :request => req.digest_cache
+          Benelux.add_thread_tags :request => req.id
           Benelux.add_thread_tags :retry => counter
           Benelux.add_thread_tags :stella_id => stella_id
           
           container.unique_id = stella_id
           
-          params['__stella'] = container.unique_id.short if @opts[:'with-param']
-          headers['X-Stella-ID'] = container.unique_id.short if @opts[:'with-header']
+          params['__stella'] = container.unique_id.short if @opts[:'withparam']
+          headers['X-Stella-ID'] = container.unique_id.short if @opts[:'withheader']
           
           meth = req.http_method.to_s.downcase
           Stella.ld "#{req.http_method}: " << "#{req.uri} " << params.inspect
@@ -104,9 +113,14 @@ module Stella
           break
         end
         
+        
+        
         begin
+          
           send_request http_client, usecase, meth, uri, req, params, headers, container, counter
+          
           update(:receive_response, usecase, uri, req, params, headers, counter, container)
+          
           Benelux.add_thread_tags :status => container.status
           res = container.response
           [
@@ -117,6 +131,8 @@ module Stella
           ].each do |att|
             Benelux.thread_timeline.add_count att[0], att[1]
           end
+          
+          
           ret = execute_response_handler container, req
           
           asset_start = Time.now
@@ -138,7 +154,8 @@ module Stella
           next
         end
         
-        run_sleeper(req.wait, asset_duration) if req.wait != 0 && !nowait?
+        wait = (req.wait > 0) ? req.wait : @opts[:wait]
+        run_sleeper(wait, asset_duration) if (wait > 0) && !nowait?
         
         # TODO: consider throw/catch
         case ret.class.to_s
@@ -175,9 +192,9 @@ module Stella
       stats
     end
     
-    def enable_nowait_mode; @nowait = true; end
-    def disable_nowait_mode; @nowait = false; end
-    def nowait?; @nowait == true; end
+    def enable_nowait_mode; @opts[:'nowait'] = true; end
+    def disable_nowait_mode; @opts[:'nowait'] = false; end
+    def nowait?; @opts[:'nowait'] == true; end
       
   private
     # We use a method so we can time it with Benelux
@@ -191,7 +208,7 @@ module Stella
     end
     
     def update(kind, *args)
-      changed and notify_observers(kind, self.digest_cache, *args)
+      changed and notify_observers(kind, self.id, *args)
     end
   
     def run_sleeper(wait, already_waited=0)
@@ -233,7 +250,7 @@ module Stella
       newh = {}
       #Stella.ld "PREPARE HEADERS: #{headers}"
       hashobj.each_pair do |n,v|
-        unless @opts[:'no-templates']
+        unless @opts[:'notemplates']
           v = container.parse_template v
         end
         v = extra.call(v) unless extra.nil?
@@ -270,13 +287,14 @@ module Stella
         raise NoHostDefined, uri
       end
       
+      base_uri = URI.parse(self.base_uri || '')
       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?
       
       # Support for specifying default path prefix:
       # $ stella verify -p plan.rb http://localhost/basicauth
-      if base_uri.path
+      if URI::Generic === base_uri && base_uri.path
         if uri.path.nil? || uri.path.empty?
           uri.path = base_uri.path
         else

data/lib/stella/common.rb

@@ -3,6 +3,79 @@
 $KCODE = "u" if RUBY_VERSION =~ /^1.8/
 
 
+
+# A hash with indifferent access and magic predicates.
+#
+#   hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+#
+#   hash[:foo]  #=> 'bar'
+#   hash['foo'] #=> 'bar'
+#   hash.foo?   #=> true
+#
+class HashWithIndifferentAccess < ::Hash #:nodoc:
+
+  def initialize(hash={})
+    super()
+    hash.each do |key, value|
+      self[convert_key(key)] = value
+    end
+  end
+
+  def [](key)
+    super(convert_key(key))
+  end
+
+  def []=(key, value)
+    super(convert_key(key), value)
+  end
+
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def values_at(*indices)
+    indices.collect { |key| self[convert_key(key)] }
+  end
+
+  def merge(other)
+    dup.merge!(other)
+  end
+
+  def merge!(other)
+    other.each do |key, value|
+      self[convert_key(key)] = value
+    end
+    self
+  end
+
+  protected
+
+    def convert_key(key)
+      key.is_a?(Symbol) ? key.to_s : key
+    end
+
+    # Magic predicates. For instance:
+    #
+    #   options.force?                  # => !!options['force']
+    #   options.shebang                 # => "/usr/lib/local/ruby"
+    #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+    #
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      if method =~ /^(\w+)\?$/
+        if args.empty?
+          !!self[$1]
+        else
+          self[$1] == args.first
+        end
+      else 
+        self[method]
+      end
+    end
+
+end
+
+
 # Assumes Time::Units and Numeric mixins are available. 
 
 class String
@@ -235,11 +308,7 @@ class Stella::Config < Storable
       USER_PATH = File.join(Stella.sysinfo.home, DIR_NAME, 'config')
     end
     PROJECT_PATH = Stella::Config.find_project_config
-    DEFAULT_CONFIG = <<CONF
-apikey: ''
-secret: ''
-source: ''
-CONF
+    DEFAULT_CONFIG = ""
     DEFAULT_CONFIG_HASH = YAML.load(DEFAULT_CONFIG).gibbler
   end
     

data/lib/stella/data/http.rb

@@ -5,7 +5,16 @@ module Stella::Data::HTTP
     include Gibbler::Complex
     include Stella::Data::Helpers
     
-    field :id, &gibbler_id_processor
+    field :id => String, &gibbler_id_processor
+    
+      # A hash containing blocks to be executed depending on the HTTP response status.
+      # The hash keys are numeric HTTP Status Codes. 
+      #
+      #     200 => { ... }
+      #     304 => { ... }
+      #     500 => { ... }
+      #
+    field :response_handler => Hash, &hash_proc_processor
     
     # Store the description in the attic so
     # it's not used in the gibbler digest.
@@ -24,21 +33,17 @@ module Stella::Data::HTTP
     field :timeout
     
     field :autofollow  # boolean. Was this an auto generated follow request. 
-    
-      # A hash containing blocks to be executed depending on the HTTP response status.
-      # The hash keys are numeric HTTP Status Codes. 
-      #
-      #     200 => { ... }
-      #     304 => { ... }
-      #     500 => { ... }
-      #
-    field :response_handler, &hash_proc_processor
+
     
     def has_body?
       !@body.nil?
     end
     
-    def initialize (method, uri_str, version="1.1", &definition)
+    def id
+      Gibbler::Digest.new @id || self.digest
+    end
+    
+    def initialize (method=nil, uri_str=nil, version="1.1", &definition)
       @uri = uri_str.to_s
       @http_method, @http_version = method, version
       @headers, @params, @response_handler = {}, {}, {}
@@ -53,6 +58,16 @@ module Stella::Data::HTTP
       @autofollow = true
     end
     
+    def self.from_hash(hash={})
+      me = super(hash)
+      me.response_handler.keys.each do |status|
+        proc_str = me.response_handler[status]
+        me.response_handler[status] = eval "Proc.new #{proc_str}"
+        me.response_handler[status].source = proc_str
+      end
+      me
+    end
+    
     def auth(user=nil, pass=nil, domain=nil)
       @http_auth ||= Stella::Testplan::Usecase::Auth.new
       @http_auth.user, @http_auth.pass, @http_auth.domain = user, pass, domain
@@ -143,6 +158,7 @@ module Stella::Data::HTTP
     end
     
     def freeze
+      return if frozen?
       @params = convert_values_to_templates @params
       @headers = convert_values_to_templates @headers
       super

data/lib/stella/engine/functional.rb

@@ -2,27 +2,12 @@
 module Stella::Engine
   class Functional < Stella::Engine::Base
     
-    def run(plan)
-      opts = process_options! plan, @opts
-      
-      Stella.stdout.info2 "Hosts: " << opts[:hosts].join(', ') if !opts[:hosts].empty?
-      
-      client = Stella::Client.new opts[:hosts].first, 1, opts
+    def run(testrun)
+      client = Stella::Client.new testrun.hosts.first, testrun.client_options
       client.add_observer(self)
-            
-      client.enable_nowait_mode if opts[:nowait]
-      
-      @testrun = Stella::Testrun.new plan, [:response_time, :failed], opts
-      @testrun.mode = 'f'      
-      
-      if Stella::Engine.service
-        Stella::Engine.service.testplan_sync plan
-        Stella::Engine.service.testrun_create @testrun
-        Stella::Engine.service.client_create client.digest, :index => client.index
-        Stella.stdout.info "Testrun: #{@testrun.remote_digest}"
-      end
       
       Stella.stdout.info2 $/, "Starting test...", $/
+      testrun.start_time = Time.now.utc.to_i
       
       start_time = Time.now.utc
       
@@ -30,12 +15,12 @@ module Stella::Engine
         # 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|
+        dig = Stella.stdout.lev > 1 ? testrun.plan.id : testrun.plan.id.shorter
+        Stella.stdout.info " %-65s  ".att(:reverse) % ["#{testrun.plan.desc}  (#{dig})"]
+        testrun.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
+          Benelux.add_thread_tags :usecase => uc.id
+          dig = Stella.stdout.lev > 1 ? uc.id : uc.id.shorter
           Stella.stdout.info ' %-65s '.att(:reverse).bright % ["#{desc}  (#{dig}) "]
           Stella.rescue { client.execute uc }
         end
@@ -45,25 +30,17 @@ module Stella::Engine
       
       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 = thread.timeline
       
-      if Stella::Engine.service
-        data = tt.messages.filter(:kind => :log).to_json
-        Stella::Engine.service.client_log client.digest, data
-        @testrun.add_sample 1, 1, tt
-      end
-      
-      @testrun
+      testrun
     end
     
     
     def update_prepare_request(client_id, usecase, req, counter)
       notice = "repeat: #{counter-1}" if counter > 1
-      dig = Stella.stdout.lev > 1 ? req.digest_cache : req.digest_cache.shorter
+      dig = Stella.stdout.lev > 1 ? req.id : req.id.shorter
       desc = "#{req.desc}  (#{dig}) "
       Stella.stdout.info2 "  %-46s %16s ".bright % [desc, notice]
     end
@@ -72,7 +49,7 @@ module Stella::Engine
     def update_receive_response(client_id, usecase, uri, req, params, headers, counter, container)
       log = Stella::Engine::Log.new Time.now.to_f, container.unique_id, client_id,
                                     'testplanid',
-                                    usecase.digest, req.digest,
+                                    usecase.id, req.id,
                                     req.http_method, container.status, uri,
                                     params, container.response.request.header.dump, 
                                     container.response.header.dump, 
@@ -175,12 +152,3 @@ module Stella::Engine
     
   end
 end
-
-__END__
-
-
-$ stella verify -p examples/basic/plan.rb http://localhost:3114
-$ stella load -p examples/basic/plan.rb http://localhost:3114
-$ stella remote-load -p examples/basic/plan.rb http://localhost:3114
-$ stella remote-verify -p examples/basic/plan.rb http://localhost:3114
-