stella 0.7.1 → 0.7.2

data/CHANGES.txt

@@ -1,6 +1,22 @@
 STELLA, CHANGES
 
 
+#### 0.7.2 (2009-10-29) ###############################
+
+* FIXED: bin/stella exits with 1 if any request fails. 
+* CHANGE: sequential and rsequential resourcing is now global
+  across all clients. 
+* ADDED: Automatic form parsing for html pages
+* ADDED: Container now has params and headers from the request
+* ADDED: Assume HTTP response codes >= 400 are failed requests 
+  unless a response block is defined for that status in which 
+  case the block must return fail. 
+* ADDED: Support for HTTP Basic authentication
+* ADDED: Templating for resources parameters and headers. 
+* ADDED: Built-in variable :HOSTNAME can be overriden by CLI argument. 
+* ADDED: Automatic JSON parsing in response blocks (as 'doc')
+
+
 #### 0.7.1 (2009-10-21) ###############################
 
 NOTE: Complete rewrite. Features include:

data/Rudyfile

@@ -3,7 +3,7 @@
 machines do
   
   region :'us-east-1' do
-    ami 'ami-e348af8a'               # Alestic Debian 5.0, 32-bit (US)
+    ami 'ami-212ccf48'               # Stella Debian 5.0, 32-bit (US)
   end
   region :'eu-west-1' do
     ami 'ami-6ecde51a'               # Alestic Debian 5.0, 32-bit (EU)
@@ -20,8 +20,14 @@ machines do
     role :gen do
       user :root
       size 'm1.large'
-      ami 'ami-f0f61599'
+      ami 'ami-7133d018'
     end
+    
+    role :demo do
+      user :root
+      size 'm1.small'
+    end
+    
   end  
   
 
@@ -40,9 +46,11 @@ commands do
   allow :stella
   allow :rm
   allow :ulimit
-  
+  allow :ruby19, "/usr/local/bin/ruby"
+  allow :gem19_install, "/usr/local/bin/gem", "install"
   allow :rackup_path do
-    "/usr/lib/ruby/gems/1.8/gems/stella-#{Stella::VERSION}/support/sample_webapp/config.ru"
+    v = [Stella::VERSION::MAJOR, Stella::VERSION::MINOR, Stella::VERSION::TINY].join('.')
+    "/usr/lib/ruby/gems/1.8/gems/stella-#{v}/support/sample_webapp/config.ru"
   end
 end
 
@@ -53,9 +61,9 @@ routines do
     # rudy -r app -v start
     start do
       remote do
-        ulimit :n, '30000'
-        ulimit :n
-        rm 'thin.log'
+        #ulimit :n, '30000'
+        #ulimit :n
+        rm :f, 'thin.log'
         mkdir :p, 'stats'
         thin :d, :l, 'thin.log', :p, 3114, :R, rackup_path, '--stats', './stats', '--max-conns', 8192, 'start'
       end
@@ -69,28 +77,33 @@ routines do
         ps 'ux'
       end
     end
-    
-    # rudy -v -r gen verify ip-10-251-27-245.ec2.internal:3114
-    verify do
-      remote do |arg|
-        stella :v, 'verify', "#{arg.first}"
-      end
+
+  end
+  
+  
+  # rudy -v -r gen verify ip-10-251-27-245.ec2.internal:3114
+  verify do
+    remote do |arg|
+      file_upload 'examples/essentials/plan.rb'
+      file_upload 'examples/essentials/search_terms.txt'
+      file_upload 'examples/essentials/logo.png'
+      stella :v, 'verify', :p, 'plan.rb', "#{arg.first}"
     end
-    
-    # rudy -v -r gen generate ip-10-251-27-245.ec2.internal:3114
-    generate do
-      remote do |arg|
-        ulimit :n, '30000'
-        ulimit :n
-        stella :v, 'generate', :c, 200, :d, '10m', :W, "#{arg.first}"
-      end
+  end
+  
+  # rudy -v -r gen generate ip-10-251-27-245.ec2.internal:3114
+  generate do
+    remote do |arg|
+      file_upload 'examples/essentials/plan.rb'
+      file_upload 'examples/essentials/search_terms.txt'
+      file_upload 'examples/essentials/logo.png'
+      stella :v, 'generate', :p, 'plan.rb', :c, 1, :d, '1m', :W, "#{arg.first}"
     end
-    
   end
-    
+
+
   setup do  
-    before :startup                   
-    after :sysupdate, :installdeps, :install_gem
+    after :sysupdate, :installdeps, :install_ruby19
   end                            
                                  
   shutdown do                                          
@@ -105,6 +118,7 @@ routines do
   
   install_rubyforge do
     remote :root do
+      gem19_install 'stella', :V
       gem_install 'stella', :V
     end
   end
@@ -139,6 +153,17 @@ routines do
     
   end
   
+  install_zlib do
+    remote do
+      wget "http://www.zlib.net/zlib-1.2.3.tar.gz"
+      tar :x, :z, :f, "zlib-1.2.3.tar.gz"
+      cd "zlib-1.2.3"
+      configure '--prefix=/usr/local'
+      make
+      make "install"
+    end
+  end
+  
   installdeps do
     remote :root do
       gem_install "test-spec", "rspec", "camping", "fcgi", "memcache-client"
@@ -148,12 +173,23 @@ routines do
     end
   end
   
+  install_jruby do
+    remote do
+      wget 'http://jruby.kenai.com/downloads/1.4.0RC2/jruby-bin-1.4.0RC2.tar.gz'
+      tar :x, :z, :f, 'jruby-bin-1.4.0RC2.tar.gz'
+      mv 'jruby-1.4.0RC2', '/usr/jruby'
+    end
+  end
+  
   install_ruby19 do
+    before :install_zlib
     remote do
-      wget 'ftp://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.1-p243.tar.bz2'
+      apt_get "install", "libssl-dev", "libreadline5-dev", "zlib1g-dev"
+      #wget 'ftp://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.1-p243.tar.bz2'
+      rm :r, :f, 'ruby-1.9.1-p243'
       tar :x, :j, :v, :f, 'ruby-1.9.1-p243.tar.bz2'
       cd 'ruby-1.9.1-p243'
-      configure '--prefix=/usr/local', '--enable-shared'
+      configure '--prefix=/usr/local'
       make
       make 'install'
     end

data/bin/stella

@@ -100,6 +100,7 @@ class Stella::CLI::Definition
   option :W, :nowait, "Ignore wait times"
   option :w, :wait, Float, "Wait time (in seconds) between client requests (ignored if testplan supplied)"
   option :p, :testplan, String, "Path to testplan" 
+  option :'disable-templates', "Disable template parsing"
   command :generate => Stella::CLI
 
   about "Initialize Stella configuration"

data/examples/essentials/plan.rb

@@ -214,7 +214,7 @@ usecase 25, "YAML API" do
     # vuser will have its own copy of the Array and
     # iterate through it independently.
     #
-    param :lid => rsequential(:listing_ids)
+    param :lid => sequential(:listing_ids)
     
     # We can use response blocks to affect behaviour 
     # the user. Here we specify that every virtual

data/examples/exceptions/plan.rb

@@ -11,7 +11,7 @@ usecase "Exception Handling" do
     param :what  => 'No Such Listing'
     param :where => random(['Toronto', 'Montreal', 'Vancouver'])
     response 404 do
-      raise NoSearchResults
+      fail "No results"
     end
   end
   

data/lib/stella.rb

@@ -12,6 +12,7 @@ autoload :OpenStruct, 'ostruct'
 autoload :Storable, 'storable'
 autoload :Gibbler, 'gibbler/aliases'
 autoload :Attic, 'attic'
+autoload :ERB, 'erb'
 
 require 'benelux'
 
@@ -52,7 +53,10 @@ module Stella
   def le(*msg); @logger.puts "  " << msg.join("#{$/}  ").color(:red); end
   # Puts +msg+ to +@logger+ if +Rudy.debug?+ returns true
   def ld(*msg)
-    @logger.puts "D:  " << msg.join("#{$/}D:  ") if debug?
+    if debug?
+      @logger.puts "D(#{Thread.current.object_id}):  " << msg.join("#{$/}D:  ")
+      Stella.lflush
+    end
   end
   
   def sysinfo

data/lib/stella/cli.rb

@@ -26,7 +26,7 @@ class Stella::CLI < Drydock::Command
   def generate
     opts = {}
     opts[:hosts] = @hosts
-    [:nowait, :clients, :repetitions, :duration].each do |opt|
+    [:nowait, :clients, :repetitions, :duration, :'disable-templates'].each do |opt|
       opts[opt] = @option.send(opt) unless @option.send(opt).nil?
     end
     

data/lib/stella/client.rb

@@ -15,9 +15,12 @@ module Stella
     attr_accessor :base_uri
     attr_accessor :proxy
     
-    def initialize(base_uri=nil, client_id=1)
+    def initialize(base_uri=nil, client_id=1, opts={})
+      opts = {
+        :parse_templates => true
+      }.merge! opts
+      @opts = opts
       @base_uri, @client_id = base_uri, client_id
-      
       #@cookie_file = File.new("cookies-#{client_id}", 'w')
       @proxy = OpenStruct.new
     end
@@ -27,7 +30,7 @@ module Stella
       
       http_client = create_http_client
       stats = {}
-      container = Container.new(usecase)
+      container = Container.new(self.digest_cache, usecase)
       counter = 0
       usecase.requests.each do |req|
         counter += 1
@@ -36,11 +39,27 @@ module Stella
         
         stats ||= Benelux::Stats.new
         update(:prepare_request, usecase, req, counter)
-        uri_obj = URI.parse(req.uri)
+        
+        # This is for the values that were "set"
+        # in the part before the response body.
+        prepare_resources(container, req.resources)
+        
         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?
+        
+        container.params, container.headers = params, headers
+        
+        uri = build_request_uri req.uri, params, container
+        
+        if usecase.http_auth
+          # TODO: The first arg is domain and can include a URI path. 
+          #       Are there cases where this is important?
+          domain = '%s://%s%s' % [uri.scheme, uri.host, '/'] #File.dirname(uri.path)
+          user, pass = usecase.http_auth.user, usecase.http_auth.pass
+          Stella.li2 "  AUTH   (#{usecase.http_auth.kind}) #{domain} (#{user}/#{pass})"
+          http_client.set_auth(domain, user, pass)
+        end
+        raise NoHostDefined, req.uri if uri.host.nil? || uri.host.empty?
         stella_id = [Time.now, self.digest_cache, req.digest_cache, params, headers, counter].gibbler
         
         Benelux.add_thread_tags :request => req.digest_cache
@@ -50,39 +69,60 @@ module Stella
         params['__stella'] = headers['X-Stella-ID']= stella_id[0..10]
         
         meth = req.http_method.to_s.downcase
-        Stella.ld "#{req.http_method}: " << "#{uri_obj.to_s} " << params.inspect
-
+        Stella.ld "#{req.http_method}: " << "#{req.uri} " << params.inspect
+        
+        ret, asset_duration = nil, 0
         begin
           send_request http_client, usecase, meth, uri, req, params, headers, container, counter
-          
           Benelux.add_thread_tags :status => container.status
-          Benelux.thread_timeline.add_count :request_header_size, container.response.request.header.dump.size
-          Benelux.thread_timeline.add_count :request_content_size, container.response.request.body.content.size
-          Benelux.thread_timeline.add_count :response_headers_size, container.response.header.dump.size
-          Benelux.thread_timeline.add_count :response_content_size, container.response.body.content.size
+          res = container.response
+          [
+            [:request_header_size, res.request.header.dump.size],
+            [:request_content_size, res.request.body.content.size],
+            [:response_headers_size, res.header.dump.size],
+            [:response_content_size, res.body.content.size]
+          ].each do |att|
+            Benelux.thread_timeline.add_count att[0], att[1]
+          end
           ret = execute_response_handler container, req
-          Benelux.remove_thread_tags :status
-           
+          
+          asset_start = Time.now
+          container.assets.each do |uri|
+            Benelux.add_thread_tags :asset => uri
+            a = http_client.get uri
+            Stella.li3 "   FETCH ASSET: #{uri} #{a.status}"
+            Benelux.remove_thread_tags :asset
+          end
+          asset_duration = Time.now - asset_start
+          
         rescue => ex
           Benelux.thread_timeline.add_count :failed, 1
           update(:request_error, usecase, uri, req, params, ex)
+          Benelux.remove_thread_tags :status, :retry, :request, :stella_id
           next
         end
         
         Stella.lflush
         
-        run_sleeper(req.wait) if req.wait && !nowait?
+        run_sleeper(req.wait, asset_duration) if req.wait != 0 && !nowait?
         
         # TODO: consider throw/catch
         case ret.class.to_s
         when "Stella::Client::Repeat"
+          Benelux.remove_thread_tags :status
           update(:repeat_request, counter, ret.times+1)
           redo if counter <= ret.times
         when "Stella::Client::Quit"
+          Benelux.remove_thread_tags :status
           update(:quit_usecase, ret.message)
           break
+        when "Stella::Client::Fail"  
+          Benelux.thread_timeline.add_count :failed, 1
+          update(:fail_request, ret.message)
         end
-      
+        
+        Benelux.remove_thread_tags :status
+        
         counter = 0 # reset
       end
       Benelux.remove_thread_tags :retry, :request, :stella_id
@@ -103,14 +143,18 @@ module Stella
       changed and notify_observers(kind, self.digest_cache, *args)
     end
   
-    def run_sleeper(wait)
+    def run_sleeper(wait, already_waited=0)
+      # The time it took to download the assets can
+      # be removed from the specified wait time.
       if wait.is_a?(::Range)
         ms = rand(wait.last * 1000).to_f 
         ms = wait.first if ms < wait.first
       else
         ms = wait * 1000
       end
-      sleep ms / 1000
+      sec = ms / 1000
+      Stella.ld "WAIT ADJUSTED FROM %.1f TO: %.1f" % [sec, (sec - already_waited)]
+      sleep (sec - already_waited) if (sec - already_waited) > 0
     end
     
     def create_http_client
@@ -123,24 +167,32 @@ module Stella
       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.protocol_version = "HTTP/1.1"
+      http_client.ssl_config.verify_mode = ::OpenSSL::SSL::VERIFY_NONE
       http_client
     end
     
-    def prepare_params(container, params)
-      newparams = {}
-      params.each_pair do |n,v|
-        Stella.ld "PREPARE PARAM: #{n}"
-        v = container.instance_eval &v if v.is_a?(Proc)
-        newparams[n] = v
-      end
-      newparams
+    def prepare_resources(container, resources)
+      h = prepare_runtime_hash container, resources
+      # p [container.client_id.shorter, h]
+      container.resources.merge! h
     end
     
-    def prepare_headers(container, headers)
-      Stella.ld "PREPARE HEADERS: #{headers}"
-      headers = container.instance_eval &headers if headers.is_a?(Proc)
-      headers
+    # Process resource values from the request object
+    def prepare_runtime_hash(container, hashobj, &extra)
+      newh = {}
+      #Stella.ld "PREPARE HEADERS: #{headers}"
+      hashobj.each_pair do |n,v|
+        v = container.instance_eval &v if v.is_a?(Proc)
+        if @opts[:parse_templates]
+          v = container.parse_template v if String === v
+        end
+        v = extra.call(v) unless extra.nil?
+        newh[n] = v
+      end
+      newh
     end
+    alias_method :prepare_headers, :prepare_runtime_hash
+    alias_method :prepare_params, :prepare_runtime_hash
     
     # Testplan URIs can be relative or absolute. Either one can
     # contain variables in the form <tt>:varname</tt>, as in:
@@ -151,7 +203,17 @@ module Stella
     # if necessary and replaces all variables with literal values.
     # 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)
+      newuri = uri.clone  # don't modify uri template
+      # We call uri.clone b/c we modify uri. 
+      uri.scan(/:([a-z_]+)/i) do |instances|
+        instances.each do |varname|
+          val = find_replacement_value(varname, params, container, base_uri)
+          #Stella.ld "FOUND: #{val}"
+          newuri.gsub! /:#{varname}/, val.to_s unless val.nil?
+        end
+      end
+      
+      uri = URI.parse(newuri)
       
       if uri.host.nil? && base_uri.nil?
         Stella.abort!
@@ -163,15 +225,7 @@ module Stella
       uri.port = base_uri.port if uri.port.nil?
       uri.path ||= ''
       uri.path.gsub! /\/$/, ''  # Don't double up on the first slash
-      # We call req.uri again because we need  
-      # to modify request_uri inside the loop. 
-      uri.path.clone.scan(/:([a-z_]+)/i) do |instances|
-        instances.each do |varname|
-          val = find_replacement_value(varname, params, container)
-          #Stella.ld "FOUND: #{val}"
-          uri.path.gsub! /:#{varname}/, val.to_s unless val.nil?
-        end
-      end
+      
       uri
     end
     
@@ -179,35 +233,47 @@ module Stella
     # This method looks at the request parameters and then at the 
     # usecase's resource hash for a replacement value. 
     # If not found, returns nil. 
-    def find_replacement_value(name, params, container)
+    def find_replacement_value(name, params, container, base_uri)
       value = nil
       #Stella.ld "REPLACE: #{name}"
       #Stella.ld "PARAMS: #{params.inspect}"
       #Stella.ld "IVARS: #{container.instance_variables}"
-      value = params[name.to_sym] 
+      if name.to_sym == :HOSTNAME && !base_uri.nil?
+        value = base_uri.host 
+      elsif params.has_key?(name.to_sym)
+        value = params.delete name.to_sym
+      end
       value = container.resource name.to_sym if value.nil?
       value
     end 
     
     # Find the appropriate response handler by executing the
     # HTTP response status against the configured handlers. 
-    # If several match, the first one is used. 
-    def execute_response_handler(container, req)
+    # If several match, the first one is returned.
+    def find_response_handler(container, req)
       handler = nil
       req.response.each_pair do |regex,h|
         Stella.ld "HANDLER REGEX: #{regex.to_s} (#{container.status})"
         regex = /#{regex}/ unless regex.is_a? Regexp
         handler = h and break if container.status.to_s =~ regex
       end
+      handler
+    end
+    
+    
+    def execute_response_handler(container, req)
       ret = nil
-      unless handler.nil?
-        begin
-          ret = container.instance_eval &handler
-          update(:execute_response_handler, req, container)
-        rescue => ex
-          update(:error_execute_response_handler, ex, req, container)
-          Stella.ld ex.message, ex.backtrace
-        end
+      handler = find_response_handler container, req
+      if handler.nil?
+        Benelux.thread_timeline.add_count :failed, 1 if container.status >= 400
+        return
+      end
+      begin
+        ret = container.instance_eval &handler
+        update(:execute_response_handler, req, container)
+      rescue => ex
+        update(:error_execute_response_handler, ex, req, container)
+        Stella.ld ex.message, ex.backtrace
       end
       ret
     end