stella 0.3.2

data/lib/stella/logger.rb

@@ -0,0 +1,63 @@
+
+
+module Stella
+  class Logger
+    attr_accessor :debug
+    
+    # +args+ is a hash of initialization arguments
+    # * <tt>:info_logger</tt> The IO class for info level logging. Default: STDOUT
+    # * <tt>:error_logger</tt> The IO class for error level logging. Default: STDERR
+    # * <tt>:debug_logger</tt> The IO class for error level logging. Default: STDERR
+    # * <tt>:debug</tt> Log debugging output, true or false (default)
+    def initialize(args={})
+      @debug        = args[:debug] || false
+      @info_logger  = args[:info_logger] || STDOUT
+      @error_logger = args[:error_logger] || STDERR
+      @debug_logger = args[:debug_logger] || STDERR
+    end
+    
+    # +msgs+ is an array which can contain a list of messages or a symbol and a list of values
+    # If the first element is a symbol, this will return the output of Stella::Text.msg(msgs[0],msgs[1..-1]) 
+    def info(*msgs)
+      return if !msgs || msgs.empty?
+      if msgs[0].is_a? Symbol
+        txtsym = msgs.shift
+        @info_logger.puts Stella::TEXT.msg(txtsym, msgs)
+      else
+        msgs.each do |m|
+          @info_logger.puts m
+        end  
+      end
+      @info_logger.flush
+    end
+    
+    # Print all messages on a single line. 
+    def info_print(*msgs)
+      msgs.each do |m|
+        @info_logger.print m
+      end
+      @info_logger.flush
+    end
+    
+    # Print all messages on a single line. 
+    def info_printf(pattern, *vals)
+      @info_logger.printf(pattern, *vals)
+      @info_logger.flush
+    end
+    
+    def debug(*msgs)
+      return unless @debug
+      msgs.each do |m|
+        @debug_logger.puts "DEBUG: #{m}"
+      end  
+      @debug_logger.flush
+    end
+    def error(ex, prefix="ERR: ")
+      @error_logger.puts "#{prefix}#{ex.message}"
+      return unless @debug
+      @error_logger.puts("#{prefix}------------------------------------------")
+      @error_logger.puts("#{prefix}#{ex.backtrace.join("\n")}")
+      @error_logger.puts("#{prefix}------------------------------------------")
+    end
+  end
+end

data/lib/stella/response.rb

@@ -0,0 +1,82 @@
+
+
+
+module Stella
+  
+  # An object for HTTP response content
+  #
+  class Response < Storable
+    attr_accessor :errors, :content, :messages
+    attr_writer :success
+    
+    def initialize
+      @success = false
+      @errors = []
+      @messages = []
+      @content = {}
+    end
+    
+    def success?
+      @success
+    end
+    
+    def add(key, value)
+      @content[key] = value
+    end
+    
+    def get(key)
+      @content[key] if @content.has_key? key
+    end
+    
+    def message(msg)
+      @messages.push(msg)
+    end
+    
+    def error(msg)
+      @errors.push(msg)
+    end
+    
+    def output(format='yaml')
+      format = 'yaml' unless self.respond_to? "output_#{format}"
+      #STDERR.puts "OUTPUT: #{format}"
+      self.send("output_#{format}")
+    end
+    
+    def to_hash    
+      h = {}
+      h[:version] = API_VERSION
+      h[:errors] = @errors unless @errors.empty?
+      h[:messages] = @messages unless @messages.empty?
+      h[:content] = @content || {}
+      h[:success] = @success || false
+      h
+    end
+    
+    def output_zip
+      output = @content
+    end
+    
+    def output_yaml
+      to_hash.to_yaml
+    end
+    
+    # http://evang.eli.st/blog/2007/2/22/my-rails-gotcha-custom-to_xml-in-a-hash-or-array
+    # http://api.rubyonrails.org/classes/ActiveRecord/XmlSerialization.html#M000910
+    def output_xml
+      output = "<StellaResponse success=\":[\">\n"
+      output << "<todo>implement XML</todo>\n"
+      output << "</StellaResponse>\n"
+    end
+    
+    def output_json
+      to_hash.to_json
+    end
+    
+    def output_html
+     "hello!"
+    end
+    
+  end
+  
+end
+

data/lib/stella/storable.rb

@@ -0,0 +1,116 @@
+
+
+module Stella
+  class Storable
+    
+    SupportedFormats= {
+      'yaml'  => 'yml',     # format name => file extension
+      'yml'   => 'yml',
+      'csv'   => 'csv',
+      'tsv'   => 'tsv',
+      'json'  => 'json'
+    }.freeze unless defined? SupportedFormats
+    
+    attr_reader :format
+    
+    def format=(v)
+      raise "Unsupported format: #{v}" unless SupportedFormats.has_key?(v)
+      @format = v
+    end
+    
+    def field_names
+      raise "You need to override field_names (#{self.class})"
+    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)
+    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) 
+    end
+    
+    def to_hash(with_titles=true)
+      tmp = {}
+      
+      field_names.each do |fname|
+        tmp[fname] = self.send(fname.to_s)
+      end
+      
+      tmp
+    end
+    
+    def to_yaml(with_titles=true)
+      require 'yaml'
+      to_hash.to_yaml
+    end
+    
+    def to_delimited(with_titles=false, delim=',')
+      values = []
+      field_names.each do |fname|
+        values << self.send(fname.to_s)   # TODO: escape values
+      end
+      output = values.join(delim)
+      output = field_names.join(delim) << $/ << output if with_titles
+      output
+    end
+    def to_tsv(with_titles=false)
+      to_delimited(with_titles, "\t")
+    end
+    def to_csv(with_titles=false)
+      to_delimited(with_titles, ',')
+    end
+    
+    
+    def self.from_delimited(from=[],delim=',')
+      return if from.empty?
+      # We grab an instance of the class so we can 
+      hash = {}
+      
+      fnames = values = []
+      if (from.size > 1 && !from[1].empty?)
+        fnames = from[0].chomp.split(delim)
+        values = from[1].chomp.split(delim)
+      else
+        fnames = self.new.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
+      end
+      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.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

data/lib/stella/support.rb

@@ -0,0 +1,106 @@
+
+
+
+module Stella
+  
+  class InvalidArgument < RuntimeError
+    attr_accessor :name
+    def initialize(name)
+      @name = name
+    end
+    def message
+      Stella::TEXT.err(:error_invalid_argument, @name)
+    end
+  end
+  
+  class UnavailableAdapter < RuntimeError
+    attr_accessor :name
+    def initialize(name)
+      @name = name
+    end
+    def message
+      Stella::TEXT.err(:error_unavailable_adapter, @name)
+    end
+  end
+  
+  class UnknownValue < RuntimeError
+    attr_accessor :value
+    def initialize(value)
+      @value = value.to_s
+    end
+    def message
+      Stella::TEXT.err(:error_unknown_value, @value)
+    end
+  end
+  
+  class UnsupportedLanguage < RuntimeError
+  end
+  
+  class Util
+    
+    # process_useragents
+    #
+    # We read the useragents.txt file into a hash index which 
+    # useful for refering to specific useragents on the command-line
+    # and other places. 
+    # 
+    # Examples:
+    #      --agent=ie-5
+    #      --agent=ff-2.0.0.2-linux
+    #      --agent=chrome-windows
+    #      --agent=safari-3.0-osx
+    #
+    def self.process_useragents(ua_strs=[])
+      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(' ', '')
+        version = ua.version.to_i
+        os = ua.platform.downcase.tr(' ', '')
+
+        # Non-windows operating systems have the OS string inside of "os"
+        # rather than "platform". We look there for the value and then
+        # standardize the values. 
+        # i.e. firefox-3-osx
+        if os != 'windows'
+          os = ua.os.downcase
+          os = 'linux' if os.match(/^linux/)
+          os = 'osx' if os.match(/mac os x/)
+          os = 'bsd' if os.match(/bsd/)
+        end
+
+        # Make sure all arrays exist before we populate them
+        agents_index[name] ||= []
+        agents_index["#{name}-#{version}"] ||= []
+        agents_index["#{name}-#{version}-#{os}"] ||= []
+        agents_index["#{name}-#{os}"] ||= [] # We use this one for failover
+
+        # Populate each list. 
+        agents_index[name] << ua
+        agents_index["#{name}-#{version}"] << ua
+        agents_index["#{name}-#{version}-#{os}"] << ua
+        agents_index["#{name}-#{os}"] << ua
+
+      end
+
+      agents_index
+    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. 
+    end
+    
+  end
+  
+end

data/lib/stella/test/base.rb

@@ -0,0 +1,34 @@
+
+module Stella::Test
+  
+  module Base
+    
+    attr_reader :message
+    attr_reader :elapsed_time_avg, :transaction_rate_avg, :vusers_avg, :response_time_avg
+    attr_reader :elapsed_time_sdev, :transaction_rate_sdev, :vusers_sdev, :response_time_sdev
+    attr_accessor :transactions_total, :headers_transferred_total, :data_transferred_total
+    attr_accessor :successful_total, :failed_total, :elapsed_time_total, :throughput_avg, :throughput_sdev
+    
+    def availability
+      return 0 if @successful_total == 0
+      (@transactions_total / @successful_total).to_f * 100
+    end
+    
+    
+    # Defines the fields the are output by to_hash and to_csv. 
+    # For to_csv, this also determines the field order
+    def field_names
+      [ 
+        :message,
+        :elapsed_time_avg,  :transaction_rate_avg,  :vusers_avg,  :response_time_avg,
+        :elapsed_time_sdev, :transaction_rate_sdev, :vusers_sdev, :response_time_sdev,
+        
+        :transactions_total, :successful_total, :failed_total,
+        :data_transferred_total, :headers_transferred_total,
+        
+        :elapsed_time_total, :availability, :throughput_avg, :throughput_sdev
+      ]
+    end
+    
+  end
+end

data/lib/stella/test/definition.rb

@@ -0,0 +1,79 @@
+
+
+module Stella
+  
+
+  module Test
+    
+    # Stella::Test::Definition
+    # 
+    # This class defines the properties of load test. These are "generic" properties
+    # in that they don't relate to a specific tool.
+    class Definition
+      
+      # Stella::Test::Definition::Rampup
+      # 
+      # This class holds the values for a rampup: interval and ceiling.
+      class Rampup
+        attr_accessor :interval
+        attr_accessor :ceiling
+        def initialize(interval, ceiling)
+          @interval = interval
+          @ceiling = ceiling
+        end
+        def to_s
+          to_a.join(',')
+        end
+        def to_a
+          [interval,ceiling]
+        end
+      end
+      
+        # Number of virtual users to create or to begin with if rampup is specific.
+      attr_accessor :vusers 
+        # The total number of requests per test
+      attr_accessor :requests 
+        # The number of requests per virtual user
+      attr_accessor :request_ratio
+    
+        # Number of times to repeat the test run. Integer.
+      attr_reader :repetitions
+        # The amount of time to pause between test runs
+      attr_accessor :sleep
+        # Warmup factor (0.1 - 1) for a single test run before the actual test. 
+        # 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. 
+      attr_accessor :rampup
+        # An array of string appropriate for a User-Agent HTTP header
+      attr_accessor :agents
+        # A short reminder to yourself what you're testing 
+      attr_accessor :message
+    
+      def initialize  
+        @repetitions = 3
+      end
+      
+      def repetitions=(v)
+        return unless v && v > 0
+        @repetitions = v
+      end
+      
+      def rampup=(v)
+        return unless v
+        
+        if (v.is_a? Rampup)
+          @rampup = v
+        elsif (v.is_a?(Array) && v.size == 2)
+          @rampup = Rampup.new(v[0], v[1])
+        else
+          raise UnknownValue.new(v.to_s)
+        end
+      end
+      
+    end
+  end
+  
+end
+