stella 0.5.4 → 0.5.5

data/lib/stella/logger.rb

@@ -11,9 +11,9 @@ module Stella
     # * <tt>:debug</tt> Log debugging output, true or false (default)
     def initialize(args={})
       @debug_level        = args[:debug] || false
-      @info_logger  = args[:info_logger] || STDOUT
-      @error_logger = args[:error_logger] || STDERR
-      @debug_logger = args[:debug_logger] || STDERR
+      @info_logger  = args[:info_logger]
+      @error_logger = args[:error_logger]
+      @debug_logger = args[:debug_logger]
     end
     
     # +msgs+ is an array which can contain a list of messages or a symbol and a list of values
@@ -22,41 +22,51 @@ module Stella
       return if !msgs || msgs.empty?
       if msgs[0].is_a? Symbol
         txtsym = msgs.shift
-        @info_logger.puts Stella::TEXT.msg(txtsym, msgs)
+        info_logger.puts Stella::TEXT.msg(txtsym, msgs)
       else
         msgs.each do |m|
-          @info_logger.puts m
+          info_logger.puts m
         end  
       end
-      @info_logger.flush
+      info_logger.flush
+    end
+    
+    def info_logger
+      @info_logger || $stdout
+    end
+    def debug_logger
+      @debug_logger || $stderr
+    end
+    def error_logger
+      @error_logger || $stderr
     end
     
     def flush
-      @info_logger.flush
-      @error_logger.flush
-      @debug_logger.flush
+      info_logger.flush
+      error_logger.flush
+      debug_logger.flush
     end
     
     # Print all messages on a single line. 
     def info_print(*msgs)
       msgs.each do |m|
-        @info_logger.print m
+        info_logger.print m
       end
-      @info_logger.flush
+      info_logger.flush
     end
     
     # Print all messages on a single line. 
     def info_printf(pattern, *vals)
-      @info_logger.printf(pattern, *vals)
-      @info_logger.flush
+      info_logger.printf(pattern, *vals)
+      info_logger.flush
     end
     
     def debug(*msgs)
       return unless @debug_level
       msgs.each do |m|
-        @debug_logger.puts "DEBUG: #{m}"
+        debug_logger.puts "DEBUG: #{m}"
       end  
-      @debug_logger.flush
+      debug_logger.flush
     end
     def warn(ex, prefix="WARN: ")
       error(ex, prefix)
@@ -64,11 +74,11 @@ module Stella
     
     def error(ex, prefix="ERR: ")
       msg = (ex.kind_of? String) ? ex : ex.message
-      @error_logger.puts "#{prefix}#{msg}"
+      error_logger.puts "#{prefix}#{msg}"
       return unless @debug_level && ex.kind_of?(Exception)
-      @error_logger.puts("#{prefix}------------------------------------------")
-      @error_logger.puts("#{prefix}#{ex.backtrace.join("\n")}")
-      @error_logger.puts("#{prefix}------------------------------------------")
+      error_logger.puts("#{prefix}------------------------------------------")
+      error_logger.puts("#{prefix}#{ex.backtrace.join("\n")}")
+      error_logger.puts("#{prefix}------------------------------------------")
     end
   end
 end

data/lib/stella/response.rb

@@ -6,8 +6,11 @@ module Stella
   # An object for HTTP response content
   #
   class Response < Storable
-    attr_accessor :errors, :content, :messages
-    attr_writer :success
+    
+    field :errors => Array
+    field :content => Hash
+    field :messages => Array
+    field :success => TrueClass
     
     def initialize
       @success = false

data/lib/stella/storable.rb

@@ -1,57 +1,160 @@
 
 # TODO: Handle nested hashes and arrays. 
 
+require 'yaml'
+require 'utils/fileutil'
+
 module Stella
   class Storable
-    NICE_TIME_FORMAT = "%Y-%m-%d@%H:%M:%S".freeze unless defined? NICE_TIME_FORMAT
-      
-    SupportedFormats= {
-      'yaml'  => 'yml',     # format name => file extension
-      'yml'   => 'yml',
-      'csv'   => 'csv',
-      'tsv'   => 'tsv',
-      'json'  => 'json'
-    }.freeze unless defined? SupportedFormats
+    NICE_TIME_FORMAT  = "%Y-%m-%d@%H:%M:%S".freeze unless defined? NICE_TIME_FORMAT
+    SUPPORTED_FORMATS = %w{tsv csv yaml json}.freeze unless defined? SUPPORTED_FORMATS
     
     attr_reader :format
     
     def format=(v)
-      raise "Unsupported format: #{v}" unless SupportedFormats.has_key?(v)
+      raise "Unsupported format: #{v}" unless SUPPORTED_FORMATS.member?(v)
       @format = v
     end
     
+    def init
+      self.class.send(:class_variable_set, :@@field_names, []) unless class_variable_defined?(:@@field_names)
+      self.class.send(:class_variable_set, :@@field_types, []) unless class_variable_defined?(:@@field_types)
+    end
+      
+    def self.field(args={})
+      
+        args = {args => nil} unless args.is_a? Hash
+
+      args.each_pair do |m,t|
+        
+        [[:@@field_names, m], [:@@field_types, t]].each do |tuple|
+          class_variable_set(tuple[0], []) unless class_variable_defined?(tuple[0])
+          class_variable_set(tuple[0], class_variable_get(tuple[0]) << tuple[1])
+        end
+        
+        next if method_defined?(m)
+        
+        # NOTE: I need a way to put these in the caller's namespace... Here's they're shared by all
+        # the subclasses which is not helpful. It will likely involve Kernel#caller and binding. 
+        # Maybe class_eval, wraped around def field. 
+
+        
+        define_method(m) do instance_variable_get("@#{m}") end
+        
+        define_method("#{m}=") do |val| 
+          instance_variable_set("@#{m}",val)
+        end
+      end
+    end
+    
+    def self.field_names
+      class_variable_get(:@@field_names)
+    end
+    def self.field_types
+      class_variable_get(:@@field_types)
+    end
+    
     def field_names
-      raise "You need to override field_names (#{self.class})"
+      self.class.send(:class_variable_get, :@@field_names)
     end
     
-    def self.undump(format, file=[])
-      #raise "Format not defined (#{@format})" unless self.method_defined?("to_#{@format}")
-      #puts "LOAD: from_#{format}"
-      send("from_#{format}", file)
+    def field_types
+      self.class.send(:class_variable_get, :@@field_types)
+    end
+    
+    def format=(v)
+      raise "Unsupported format: #{v}" unless SUPPORTED_FORMATS.member?(v)
+      @format = v
     end
 
     
-    def dump(format="yaml", with_titles=true)
-      #raise "Format not defined (#{@format})" unless self.method_defined?("to_#{@format}")  
-      #puts "DUMP: to_#{format}"
-      self.send("to_#{format}", with_titles) 
+    def dump(format=nil, with_titles=true)
+      format ||= @format
+      raise "Format not defined (#{format})" unless SUPPORTED_FORMATS.member?(format)
+      send("to_#{format}", with_titles) 
     end
     
+    def self.from_file(file_path=nil, format=nil)
+      raise "Cannot read file (#{file_path})" unless File.exists?(file_path)
+      format = format || File.extname(file_path).tr('.', '')
+      me = send("from_#{format}", FileUtil.read_file_to_array(file_path))
+      me.format = format
+      me
+    end
+    def to_file(file_path=nil, with_titles=true)
+      raise "Cannot store to nil path" if file_path.nil?
+      format = File.extname(file_path).tr('.', '')
+      format ||= @format
+      FileUtil.write_file(file_path, dump(format, with_titles))
+    end
+  
+
+    def self.from_hash(from={})
+      me = self.new
+    
+      return me if !from || from.empty?
+      
+      fnames = field_names
+      fnames.each_with_index do |key,index|
+        
+        value = from[key]
+        
+        # TODO: Correct this horrible implementation (sorry, me. It's just one of those days.)
+        
+        if field_types[index] == Time
+          value = Time.parse(from[key].to_s)
+        elsif field_types[index] == DateTime
+          value = DateTime.parse(from[key].to_s)
+        elsif field_types[index] == TrueClass
+          value = (from[key].to_s == "true")
+        elsif field_types[index] == Float
+          value = from[key].to_f
+        elsif field_types[index] == Integer
+          value = from[key].to_i
+        end
+        
+        me.send("#{key}=", value) if self.method_defined?("#{key}=")  
+      end
+      me
+    end
     def to_hash(with_titles=true)
       tmp = {}
-      
       field_names.each do |fname|
-        tmp[fname] = self.send(fname.to_s)
+        tmp[fname] = self.send(fname)
       end
-      
       tmp
     end
     
+
+    def self.from_yaml(from=[])
+      # from is an array of strings
+      from_str = from.join('')
+      hash = YAML::load(from_str)
+      hash = from_hash(hash) if hash.is_a? Hash 
+      hash
+    end
     def to_yaml(with_titles=true)
-      require 'yaml'
       to_hash.to_yaml
     end
     
+
+    def self.from_json(from=[])
+      require 'json'
+      # from is an array of strings
+      from_str = from.join('')
+      tmp = JSON::load(from_str)
+      hash_sym = tmp.keys.inject({}) do |hash, key|
+         hash[key.to_sym] = tmp[key]
+         hash
+      end
+      hash_sym = from_hash(hash_sym) if hash_sym.is_a? Hash  
+      hash_sym
+    end
+    def to_json(with_titles=true)
+      require 'json'
+      to_hash.to_json
+    end
+    
     def to_delimited(with_titles=false, delim=',')
       values = []
       field_names.each do |fname|
@@ -67,7 +170,12 @@ module Stella
     def to_csv(with_titles=false)
       to_delimited(with_titles, ',')
     end
-    
+    def self.from_tsv(from=[])
+      self.from_delimited(from, "\t")
+    end
+    def self.from_csv(from=[])
+      self.from_delimited(from, ',')
+    end
     
     def self.from_delimited(from=[],delim=',')
       return if from.empty?
@@ -79,40 +187,18 @@ module Stella
         fnames = from[0].chomp.split(delim)
         values = from[1].chomp.split(delim)
       else
-        fnames = self.new.field_names
+        fnames = self.field_names
         values = from[0].chomp.split(delim)
       end
       
       fnames.each_with_index do |key,index|
         next unless values[index]
-        number_or_string = (values[index].match(/[\d\.]+/)) ? values[index].to_f : values[index]
-        hash[key.to_sym] = number_or_string
+        hash[key.to_sym] = values[index]
       end
+      hash = from_hash(hash) if hash.is_a? Hash 
       hash
     end
-    def self.from_tsv(from=[])
-      self.from_delimited(from, "\t")
-    end
-    def self.from_csv(from=[])
-      self.from_delimited(from, ',')
-    end
-    
-    def self.from_hash(from={})
-      return if !from || from.empty?
-      me = self.new
-      fnames = me.to_hash.keys
-      fnames.each do |key|
-        # NOTE: this will skip generated values b/c they don't have a setter method
-        me.send("#{key}=", from[key]) if self.method_defined?("#{key}=")  
-      end
-      me
-    end
-    def self.from_yaml(from=[])
-      require 'yaml'
-      # from is an array of strings
-      from_str = from.join('')
-      YAML::load(from_str)
-    end
-       
+
+  
   end
-end
+end

data/lib/stella/support.rb

@@ -60,6 +60,20 @@ module Stella
   
   class Util
     
+    BrowserNicks = {
+      :ff => 'firefox',
+      :ie => 'internetexplorer'
+    }.freeze unless defined? BrowserNicks
+
+    OperatingSystemNicks = {
+      :win => 'windows',
+      :lin => 'linux',
+      :osx => 'osx',
+      :freebsd => 'bsd',
+      :netbsd => 'bsd',
+      :openbsd => 'bsd'
+    }.freeze unless defined? OperatingSystemNicks
+    
     # process_useragents
     #
     # We read the useragents.txt file into a hash index which 
@@ -71,16 +85,18 @@ module Stella
     #      --agent=ff-2.0.0.2-linux
     #      --agent=chrome-windows
     #      --agent=safari-3.0-osx
-    #
-    def self.process_useragents(ua_strs=[])
+    # 
+    def self.process_useragents(path=nil)
+      raise "Cannot find #{path}" unless File.exists? path
+      ua_strs = FileUtil.read_file_to_array(path)
+      return {} if ua_strs.empty?
+      
       agents_index = {}
-      return agents_index if ua_strs.empty?
-
       ua_strs.each do |ua_str|
         ua_str.chomp!   # remove trailing line separator
 
         ua = UserAgent.parse(ua_str)
-
+        
         # Standardize the index values
         # i.e. firefox-3-windows
         name = ua.browser.downcase.tr(' ', '')
@@ -115,12 +131,78 @@ module Stella
       agents_index
     end
     
+    def self.find_agents(agent_list, possible_agents=[])
+      return [] if agent_list.nil? || agent_list.empty?
+      return [] if possible_agents.nil? || possible_agents.empty?
+      
+      agents = []
+      possible_agents.each do |a|
+        agents << Stella::Util.find_agent(agent_list, *a)
+      end
+      
+      agents
+    end
+    
+    # find_agent
+    #
+    # Takes an input string which can be either a shortname or a complete
+    # user agent string. If the string matches the shortname format, it
+    # will select an agent string from useragents.txt based on the shortname.
+    # Shortname takes the following format: browser-version-os. 
+    # Examples: ff-3-linux, ie-5, opera-10-win, chrome-0.2-osx, random
+    # If os doesn't match, it will look for the browser and version. If it can't
+    # find the version it will look for the browser and apply the version given. 
+    # If browser doesn't match a known browser, it assumes the string is a 
+    # complete user agent and simply returns that value. 
+    def self.find_agent(agent_list, name,second=nil,third=nil)
+      return '' if agent_list.nil? || agent_list.empty?
+      name = (BrowserNicks.has_key?(name.to_s.to_sym)) ? BrowserNicks[name.to_s.to_sym] : name
+      return name unless agent_list.has_key?(name) || name == "random"
+
+      index = name
+      if (second && third)                # i.e. opera-9-osx
+        os = (OperatingSystemNicks.has_key?(third)) ? OperatingSystemNicks[third] : third
+        index = "#{name}-#{second}-#{os}"
+      elsif(second && second.to_i > 0)    # i.e. opera-9
+        index = "#{name}-#{second}"
+      elsif(second)                       # i.e. opera-osx
+        os = (OperatingSystemNicks.has_key?(second)) ? OperatingSystemNicks[second] : second
+        index = "#{name}-#{os}"
+      elsif(name == "random")
+        index = agent_list.keys[ rand(agent_list.keys.size) ]
+      end
+
+      # Attempt to find a pool of user agents that match the supplied index
+      ua_pool = agent_list[index]
+
+      # In the event we don't find an agent above (which will only happen
+      # when the user provided a version), we'll take a random agent for 
+      # the same browser and apply the version supplied by the user. We 
+      # create the index using just the major version number so if the user
+      # supplies a specific verswion number, they will always end up here.
+      unless ua_pool
+        os = (OperatingSystemNicks.has_key?(third)) ? OperatingSystemNicks[third] : third
+        index = (os) ? "#{name}-#{os}" : name
+        ua_tmp = agent_list[index][ rand(agent_list[index].size) ]
+        ua_tmp.version = second if second.to_i > 0
+        ua_pool = [ua_tmp]
+      end
+      
+      ua = ua_pool[ rand(ua_pool.size) ]
+      
+      ua.to_s
+
+    end
+    
     # expand_str
     # 
     # Turns a string like ff-4-freebsd into ["ff","4","freebsd"]
-    # We use this for command-line values liek agent and rampup
-    def self.expand_str(str)
-      str.split(/\s*[,\-]\s*/) # remove extra spaces at the same time. 
+    # We use this for command-line values liek agent and rampup.
+    # +str+ is a comma or dash separated string.
+    # +type+ is a class type to cast to (optional, default: String)
+    def self.expand_str(str, type=String)
+      # this removes extra spaces along with the comma
+      str.split(/\s*[,\-]\s*/).inject([]) do |list,value| list << eval("#{type}('#{value}')") end
     end
     
     
@@ -162,6 +244,23 @@ module Stella
       end
     end
     
+    # NOTE: Not used yet
+    # TODO: Use capture instead of capture_output
+    # Stolen from http://github.com/wycats/thor
+    def capture(stream)
+      begin
+        stream = stream.to_s
+        eval "$#{stream} = StringIO.new"
+        yield
+        result = eval("$#{stream}").string
+      ensure
+        eval("$#{stream} = #{stream.upcase}")
+      end
+
+      result
+    end
+    
+    
     # 
     # Generates a string of random alphanumeric characters
     # These are used as IDs throughout the system

data/lib/stella/sysinfo.rb

@@ -7,6 +7,7 @@ module Stella
   # Portions of this code is from Amazon's EC2 AMI tools, lib/platform.rb. 
   class SystemInfo < Stella::Storable
     IMPLEMENTATIONS = [
+      
       # These are for JRuby, System.getproperty('os.name'). 
       # For a list of all values, see: http://lopica.sourceforge.net/os.html
       [/mac\s*os\s*x/i,     :unix,    :osx     ],  
@@ -14,7 +15,9 @@ module Stella
       [/windows\s*ce/i,     :win32,   :windows ],
       [/windows/i,          :win32,   :windows ],  
       [/osx/i,              :unix,    :osx     ],
-
+      
+      # TODO: implement other windows matches: # /djgpp|(cyg|ms|bcc)win|mingw/ (from mongrel)
+      
       # These are for RUBY_PLATFORM and JRuby
       [/java/i,    :java,    :java             ],
       [/darwin/i,  :unix,    :osx              ],
@@ -31,6 +34,7 @@ module Stella
       [/vms/i,     :vms,     :vms              ],
       [/os2/i,     :os2,     :os2              ],
       [nil,        :unknown, :unknown          ],
+      
     ]
 
     ARCHITECTURES = [
@@ -46,18 +50,19 @@ module Stella
       [nil,         :unknown          ],
     ]
     
-    attr_reader :os
-    attr_reader :implementation
-    attr_reader :architecture
-    attr_reader :hostname
-    attr_reader :ipaddress
-    attr_reader :uptime
+
+  
+    field :os => String
+    field :implementation => String
+    field :architecture => String
+    field :hostname => String
+    field :ipaddress => String
+    field :uptime => Float
     
-    def field_names
-      [
-        :os, :implementation, :architecture, :hostname, :ipaddress, :uptime
-      ]
-    end
+    
+    alias :impl :implementation
+    alias :arch :architecture
+
     
     def initialize
       @os, @implementation, @architecture = guess
@@ -88,7 +93,7 @@ module Stella
       
       #
       if os == :win32
-        require 'Win32API'
+        #require 'Win32API'
   
       # If we're running in java, we'll need to look elsewhere
       # for the implementation and architecture. 
@@ -127,7 +132,7 @@ module Stella
       uptime = :unknown
 
       begin
-        hostname = Socket.gethostname
+        hostname = local_hostname
         ipaddr = local_ip_address
         uptime = local_uptime       
       rescue => ex
@@ -136,10 +141,15 @@ module Stella
       [hostname, ipaddr, uptime]
     end
 
-
+    # local_hostname
+    #
+    # Return the hostname for the local machine
+    def local_hostname
+      Socket.gethostname
+    end
+    
     # local_uptime
     #
-    # 
     # Returns the local uptime in hours. Use Win32API in Windows, 
     # 'sysctl -b kern.boottime' os osx, and 'who -b' on unix.
     # Based on Ruby Quiz solutions by: Matthias Reitinger 

data/lib/stella/test/definition.rb

@@ -44,7 +44,7 @@ module Stella
         # A warmup factor of 0.5 means run a test run at 50% strength. 
       attr_accessor :warmup
         # Contains an interval and maximum threshold to increase virtual users. 
-        # Rampup object, [R,M] where R is the interval and M is the maximum. 
+        # Rampup object, or Array like [R,M] where R is the interval and M is the maximum. 
       attr_reader :rampup
         # An array of string appropriate for a User-Agent HTTP header
       attr_accessor :agents

data/lib/stella/test/run/summary.rb

@@ -4,15 +4,31 @@
 module Stella::Test::Run
 
   class Summary < Stella::Storable
+    attr_accessor :format
     
-    attr_accessor :note
-    attr_accessor :tool, :version
-    attr_accessor :test, :transactions, :headers_transferred
-    attr_accessor :elapsed_time, :data_transferred, :response_time
-    attr_accessor :successful, :failed, :transaction_rate, :vusers, :raw
-    
+    field :availability => Float
+    field :transactions => Integer
+    field :elapsed_time => Float
+    field :data_transferred => Float
+    field :headers_transferred => Float 
+    field :response_time => Float
+    field :transaction_rate => Float
+    field :throughput => Float
+    field :vusers => Integer
+    field :successful => Integer
+    field :failed => Integer
+    field :note => String
+    field :raw => String
+    field :tool => String
+    field :version => String
+
     def initialize(note="")
+      #init
       @note = note
+      reset
+    end
+    
+    def reset
       @transactions = 0
       @headers_transferred = 0
       @elapsed_time = 0
@@ -42,13 +58,7 @@ module Stella::Test::Run
       end
     end
     
-    def field_names
-      [
-        :availability, :transactions, :elapsed_time, :data_transferred,
-        :headers_transferred, :response_time, :transaction_rate, :throughput,
-        :vusers, :successful, :failed, :note
-      ]
-    end
+
     
     def available?
       @successful && @transactions && @elapsed_time && @vusers && @response_time