stella 0.5.3 → 0.5.4

data/lib/stella/data/http.rb

@@ -0,0 +1,124 @@
+
+require 'utils/httputil'
+require 'base64'
+
+module Stella::Data
+  
+  # TODO: Implement HTTPHeaders. We should be printing untouched headers. 
+  # HTTPUtil should split the HTTP event lines and that's it. Replace 
+  # parse_header_body with split_header_body
+  class HTTPHeaders < Stella::Storable
+    attr_reader :raw_data
+    
+    def to_s
+      @raw_data
+    end
+    
+  end
+  
+  class HTTPRequest < Stella::Storable
+    attr_accessor :time, :client_ip, :server_ip, :header, :body, :method, :http_version 
+    attr_reader :raw_data
+    attr_writer :uri, :body
+    attr_accessor :response
+    
+    def has_body?
+      @body && !@body.nil & !@body.empty?
+    end
+    def has_request?
+      false
+    end
+    def has_response?
+      (@response && @response.status && !@response.status.nil?)
+    end
+    
+    def initialize(raw_data=nil)
+      @raw_data = raw_data
+      if @raw_data
+        @method, @http_version, @uri, @header, @body = HTTPUtil::parse_http_request(raw_data) 
+      end
+      @response = Stella::Data::HTTPResponse.new
+    end
+    
+    def uri
+      @uri.host = @server_ip.to_s if @uri && (@uri.host == 'unknown' || @uri.host.empty?)
+      @uri
+    end
+    
+    def body
+      return nil unless @body
+      @body
+      #(!header || header[:Content_Type] || header[:Content_Type] !~ /text/) ? Base64.encode64(@body) : @body
+    end
+    
+    def field_names
+      [ :time, :client_ip, :server_ip, :header, :uri, :body, :method, :http_version ]
+    end
+    
+    def inspect
+      headers = []
+      header.each_pair do |n,v|
+        headers << "#{n.to_s.gsub('_', '-')}: #{v[0]}"
+      end
+      str = "%s %s HTTP/%s" % [method, uri.to_s, http_version]
+      str << $/ + headers.join($/)
+      str << $/ + $/ + body if body
+      str
+    end
+    
+    def to_s
+      str = "%s: %s %s HTTP/%s" % [time.strftime(NICE_TIME_FORMAT), method, uri.to_s, http_version]
+      str
+    end
+    
+  end
+  
+  class HTTPResponse < Stella::Storable
+    attr_accessor :time, :client_ip, :server_ip, :header, :status, :message, :http_version
+    attr_reader :raw_data
+    attr_writer :body
+    
+    def initialize(raw_data=nil)
+      @raw_data = raw_data
+      if @raw_data
+        @status, @http_version, @message, @header, @body = HTTPUtil::parse_http_response(@raw_data)
+      end
+    end
+    
+    def has_body?
+      @body && !@body.nil & !@body.empty?
+    end
+    def has_request?
+      false
+    end
+    def has_response?
+      false
+    end
+    
+    def body
+      return nil unless @body
+      #Base64.encode64(@body)
+      (!header || !header[:Content_Type] || header[:Content_Type] !~ /text/) ? '' : @body
+    end
+    
+    def field_names
+      [ :time, :client_ip, :server_ip, :header, :body, :status, :message, :http_version ]
+    end
+    
+    def inspect
+      headers = []
+      header.each_pair do |n,v|
+        headers << "#{n.to_s.gsub('_', '-')}: #{v[0]}"
+      end
+      str = "HTTP/%s %s (%s)" % [@http_version, @status, @message]
+      str << $/ + headers.join($/)
+      str << $/ + $/ + body if body
+      str
+    end
+    
+    def to_s
+      str = "%s: HTTP/%s %s (%s)" % [time.strftime(NICE_TIME_FORMAT), @http_version, @status, @message]
+      str 
+    end
+  end
+end 

data/lib/stella/logger.rb

@@ -2,7 +2,7 @@
 
 module Stella
   class Logger
-    attr_accessor :debug
+    attr_accessor :debug_level
     
     # +args+ is a hash of initialization arguments
     # * <tt>:info_logger</tt> The IO class for info level logging. Default: STDOUT
@@ -10,7 +10,7 @@ module Stella
     # * <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
+      @debug_level        = args[:debug] || false
       @info_logger  = args[:info_logger] || STDOUT
       @error_logger = args[:error_logger] || STDERR
       @debug_logger = args[:debug_logger] || STDERR
@@ -31,6 +31,12 @@ module Stella
       @info_logger.flush
     end
     
+    def 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|
@@ -46,15 +52,20 @@ module Stella
     end
     
     def debug(*msgs)
-      return unless @debug
+      return unless @debug_level
       msgs.each do |m|
         @debug_logger.puts "DEBUG: #{m}"
       end  
       @debug_logger.flush
     end
+    def warn(ex, prefix="WARN: ")
+      error(ex, prefix)
+    end
+    
     def error(ex, prefix="ERR: ")
-      @error_logger.puts "#{prefix}#{ex.message}"
-      return unless @debug
+      msg = (ex.kind_of? String) ? ex : ex.message
+      @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}------------------------------------------")

data/lib/stella/storable.rb

@@ -1,8 +1,10 @@
 
+# TODO: Handle nested hashes and arrays. 
 
 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',
@@ -96,7 +98,7 @@ module Stella
     end
     
     def self.from_hash(from={})
-      return if from.empty?
+      return if !from || from.empty?
       me = self.new
       fnames = me.to_hash.keys
       fnames.each do |key|

data/lib/stella/support.rb

@@ -11,6 +11,7 @@ module Stella
     def message
       Stella::TEXT.err(:error_invalid_argument, @name)
     end
+    
   end
   
   class UnavailableAdapter < RuntimeError
@@ -36,6 +37,27 @@ module Stella
   class UnsupportedLanguage < RuntimeError
   end
   
+  class MissingDependency < RuntimeError
+    attr_accessor :dependency, :reason
+    def initialize(dependency, reason=:error_generic)
+      @dependency = dependency
+      @reason = (reason.kind_of? Symbol) ? Stella::TEXT.err(reason) : reason
+    end
+    def message
+      Stella::TEXT.err(:error_missing_dependency, @dependency, @reason)
+    end
+  end
+  
+  class AdapterError < MissingDependency
+    def initialize(adapter, reason=:error_generic)
+      @adapter = adapter
+      @reason = (reason.kind_of? Symbol) ? Stella::TEXT.err(reason) : reason
+    end
+    def message
+      Stella::TEXT.err(:error_adapter_runtime, @adapter, @reason)
+    end
+  end
+  
   class Util
     
     # process_useragents
@@ -101,6 +123,55 @@ module Stella
       str.split(/\s*[,\-]\s*/) # remove extra spaces at the same time. 
     end
     
+    
+    # capture_output
+    #
+    # +cmd+ is a shell command to run with Kernel.` It will be appended with 
+    # redirects to send STDOUT and STDERR to temp files. If the command already
+    # contains redirects they will be removed and replaced. 
+    # The tempfiles are sent to yield as arrays of lines (using file_sout.readlines)
+    # and deleted before returning. 
+    #
+    # We use files because popen and open3 are not implemented on Windows. 
+    def self.capture_output(cmd)
+      return unless cmd
+      file_sout = Tempfile.new("stdout" << strand(6)) # We add a strand to be super sure it doesn't exist
+      file_serr = Tempfile.new("stderr" << strand(6))
+      cmd.gsub!(/1>.+/, '')
+      cmd.gsub!(/2>.+/, '')
+      cmd = "#{cmd} 1> \"#{file_sout.path}\" 2> \"#{file_serr.path}\""
+      begin
+        # Windows will have a conniption because the tempfiles are already open.
+        # We close them here and then open them to read them. 
+        file_sout.close
+        file_serr.close
+        
+        system(cmd)
+        
+        file_sout.open
+        file_serr.open
+        sout, serr = file_sout.readlines, file_serr.readlines
+        file_sout.close
+        file_serr.close
+        
+        yield(sout, serr)
+        
+      ensure
+        file_sout.delete
+        file_serr.delete
+      end
+    end
+    
+    # 
+    # Generates a string of random alphanumeric characters
+    # These are used as IDs throughout the system
+    def self.strand( len )
+       chars = ("a".."z").to_a + ("0".."9").to_a
+       newpass = ""
+       1.upto(len) { |i| newpass << chars[rand(chars.size-1)] }
+       return newpass
+    end
+    
   end
   
 end

data/lib/stella/sysinfo.rb

@@ -0,0 +1,247 @@
+
+
+module Stella
+  # Stella::SystemInfo
+  # 
+  # A container for the system platform information. 
+  # 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     ],  
+      [/sunos/i,            :unix,    :solaris ], 
+      [/windows\s*ce/i,     :win32,   :windows ],
+      [/windows/i,          :win32,   :windows ],  
+      [/osx/i,              :unix,    :osx     ],
+
+      # These are for RUBY_PLATFORM and JRuby
+      [/java/i,    :java,    :java             ],
+      [/darwin/i,  :unix,    :osx              ],
+      [/linux/i,   :unix,    :linux            ],
+      [/freebsd/i, :unix,    :freebsd          ],
+      [/netbsd/i,  :unix,    :netbsd           ],
+      [/solaris/i, :unix,    :solaris          ],
+      [/irix/i,    :unix,    :irix             ],
+      [/cygwin/i,  :unix,    :cygwin           ],
+      [/mswin/i,   :win32,   :windows          ],
+      [/mingw/i,   :win32,   :mingw            ],
+      [/bccwin/i,  :win32,   :bccwin           ],
+      [/wince/i,   :win32,   :wince            ],
+      [/vms/i,     :vms,     :vms              ],
+      [/os2/i,     :os2,     :os2              ],
+      [nil,        :unknown, :unknown          ],
+    ]
+
+    ARCHITECTURES = [
+      [/(i\d86)/i,  :i386             ],
+      [/x86_64/i,   :x86_64           ],
+      [/x86/i,      :i386             ],  # JRuby
+      [/ia64/i,     :ia64             ],
+      [/alpha/i,    :alpha            ],
+      [/sparc/i,    :sparc            ],
+      [/mips/i,     :mips             ],
+      [/powerpc/i,  :powerpc          ],
+      [/universal/i,:universal        ],
+      [nil,         :unknown          ],
+    ]
+    
+    attr_reader :os
+    attr_reader :implementation
+    attr_reader :architecture
+    attr_reader :hostname
+    attr_reader :ipaddress
+    attr_reader :uptime
+    
+    def field_names
+      [
+        :os, :implementation, :architecture, :hostname, :ipaddress, :uptime
+      ]
+    end
+    
+    def initialize
+      @os, @implementation, @architecture = guess
+      @hostname, @ipaddress, @uptime = get_info
+    end
+    
+    # guess
+    #
+    # This is called at require-time in stella.rb. It guesses
+    # the current operating system, implementation, architecture. 
+    # Returns [os, impl, arch]
+    def guess
+      os = :unknown
+      impl = :unknown
+      arch = :unknown
+      IMPLEMENTATIONS.each do |r, o, i|
+        if r and RUBY_PLATFORM =~ r
+          os, impl = [o, i]
+          break
+        end
+      end
+      ARCHITECTURES.each do |r, a|
+        if r and RUBY_PLATFORM =~ r
+          arch = a
+          break
+        end
+      end
+      
+      #
+      if os == :win32
+        require 'Win32API'
+  
+      # If we're running in java, we'll need to look elsewhere
+      # for the implementation and architecture. 
+      # We'll replace IMPL and ARCH with what we find. 
+      elsif os == :java
+        require 'java'
+        include_class java.lang.System
+        
+        osname = System.getProperty("os.name")
+        IMPLEMENTATIONS.each do |r, o, i|
+          if r and osname =~ r
+            impl = i
+            break
+          end
+        end
+        
+        osarch = System.getProperty("os.arch")
+        ARCHITECTURES.each do |r, a|
+          if r and osarch =~ r
+            arch = a
+            break
+          end
+        end
+        
+      end
+
+      [os, impl, arch]
+    end
+
+    # get_info
+    #
+    # Returns [hostname, ipaddr, uptime] for the local machine
+    def get_info
+      hostname = :unknown
+      ipaddr = :unknown
+      uptime = :unknown
+
+      begin
+        hostname = Socket.gethostname
+        ipaddr = local_ip_address
+        uptime = local_uptime       
+      rescue => ex
+      end
+
+      [hostname, ipaddr, uptime]
+    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 
+    # On Windows, see also: net statistics server
+    def local_uptime
+
+      # Each method must return uptime in seconds
+      methods = {
+  
+        :win32_windows => lambda {
+          # Win32API is required in self.guess
+          getTickCount = Win32API.new("kernel32", "GetTickCount", nil, 'L')
+          ((getTickCount.call()).to_f / 1000).to_f
+        },
+  
+        # Ya, this is kinda wack. Ruby -> Java -> Kernel32. See:
+        # http://www.oreillynet.com/ruby/blog/2008/01/jruby_meets_the_windows_api_1.html
+        # http://msdn.microsoft.com/en-us/library/ms724408(VS.85).aspx
+        # Ruby 1.9.1: Win32API is now deprecated in favor of using the DL library.
+        :java_windows => lambda {
+          kernel32 = com.sun.jna.NativeLibrary.getInstance('kernel32')
+          buf = java.nio.ByteBuffer.allocate(256)
+          (kernel32.getFunction('GetTickCount').invokeInt([256, buf].to_java).to_f / 1000).to_f 
+        },
+        
+        :unix_osx => lambda {
+          # This is faster than who and could work on BSD also. 
+          (Time.now.to_f - Time.at(`sysctl -b kern.boottime 2>/dev/null`.unpack('L').first).to_f).to_f
+
+        },
+        # This should work for most unix flavours. 
+        :unix => lambda {
+          # who is sloooooow. Use File.read('/proc/uptime')
+          (Time.now.to_f - Time.parse(`who -b 2>/dev/null`).to_f)
+        }
+      }
+
+      hours = 0
+
+      begin
+        key = platform
+        method = (methods.has_key? key) ? methods[key] : methods[:unix]
+        hours = (method.call) / 3600 # seconds to hours
+      rescue => ex
+      end
+      hours
+    end
+
+
+    # local_ip_address
+    #
+    # Return the local IP address which receives external traffic
+    # from: http://coderrr.wordpress.com/2008/05/28/get-your-local-ip-address/
+    # NOTE: This <em>does not</em> open a connection to the IP address. 
+    def local_ip_address
+      # turn off reverse DNS resolution temporarily 
+      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true   
+      UDPSocket.open {|s| s.connect('75.101.137.7', 1); s.addr.last } # Solutious IP
+    ensure  
+      Socket.do_not_reverse_lookup = orig
+    end
+
+    # local_ip_address_alt
+    #
+    # Returns the local IP address based on the hostname. 
+    # According to coderrr (see comments on blog link above), this implementation
+    # doesn't guarantee that it will return the address for the interface external
+    # traffic goes through. It's also possible the hostname isn't resolvable to the
+    # local IP.  
+    def local_ip_address_alt
+      ipaddr = :unknown
+      begin
+        saddr = Socket.getaddrinfo(  Socket.gethostname, nil, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)
+        ipaddr = saddr.select{|type| type[0] == 'AF_INET' }[0][3]
+      rescue => ex
+      end
+      ipaddr
+    end
+
+    # platform
+    #
+    # returns a symbol in the form: os_implementation. This is used throughout Stella
+    # for platform specific support. 
+    def platform
+      "#{@os}_#{@implementation}".to_sym
+    end
+    
+    # ruby
+    #
+    # Returns Ruby version as an array
+    def ruby
+      RUBY_VERSION.split('.').map { |v| v.to_i }
+    end
+    
+    # to_s
+    # 
+    # Print friendly system information. 
+    def to_s
+      sprintf("Hostname: %s#{$/}IP Address: %s#{$/}System: %s#{$/}Uptime: %.2f (hours)#{$/}Ruby: #{ruby.join('.')}", 
+        @hostname, @ipaddress, "#{@os}-#{@implementation}-#{@architecture}", @uptime)
+    end
+    
+    
+  end
+end

data/lib/stella/test/base.rb

@@ -11,7 +11,11 @@ module Stella::Test
     
     def availability
       return 0 if @successful_total == 0
-      (@transactions_total / @successful_total).to_f * 100
+      begin
+        (@transactions_total / @successful_total).to_f * 100
+      rescue => ex
+        0.0
+      end
     end
     
     

data/lib/stella/test/definition.rb

@@ -45,7 +45,7 @@ module Stella
       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
+      attr_reader :rampup
         # An array of string appropriate for a User-Agent HTTP header
       attr_accessor :agents
         # A short reminder to yourself what you're testing 

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

@@ -25,15 +25,21 @@ module Stella::Test::Run
     end
     
     def availability
-      return 0 if @successful == 0
-      (@transactions / @successful).to_f * 100
+      begin
+        (@transactions / @successful).to_f * 100
+      rescue => ex
+        return 0.0
+      end
     end
     
     # We calculate the throughput because Apache Bench does not provide this
     # value in the output. 
     def throughput
-      return 0 if !@elapsed_time || @elapsed_time == 0
-      (@data_transferred / @elapsed_time).to_f
+      begin
+        return (@data_transferred / @elapsed_time).to_f
+      rescue => ex
+        return 0.0
+      end
     end
     
     def field_names
@@ -44,6 +50,10 @@ module Stella::Test::Run
       ]
     end
     
+    def available?
+      @successful && @transactions && @elapsed_time && @vusers && @response_time
+    end
+    
   end
   
   

data/lib/stella/text/resource.rb

@@ -7,7 +7,6 @@ module Stella
       require 'yaml'
       
       attr_reader :lang, :country, :encoding
-      attr_reader :messages, :path
       
       def initialize(path, lang)
         @path = path

data/lib/stella.rb

@@ -1,26 +1,35 @@
 
-$: << File.join(STELLA_HOME, 'vendor', 'useragent', 'lib')
-
 
 require 'date'
-require 'open3'
+require 'time'
+require 'tempfile'
+require 'socket'
 
 # Common utilities
+require 'utils/domainutil'
 require 'utils/httputil'
-require 'utils/crypto-key'
 require 'utils/fileutil'
 require 'utils/mathutil'
 require 'utils/escape'
 
 # Common dependencies
+$: << File.join(STELLA_HOME, 'vendor', 'useragent', 'lib')
+require 'user_agent'
+
+# Common Stella dependencies
 require 'stella/support'
 require 'stella/storable'
-require 'user_agent'
 
-# Common objects
+# Common Stella Data Objects
+require 'stella/data/http'
+require 'stella/data/domain'
+
+# Common Stella objects
 require 'stella/text'
+
 require 'stella/logger'
 require 'stella/response'
+require 'stella/sysinfo'
 require 'stella/test/definition'
 require 'stella/test/run/summary'
 require 'stella/test/summary'
@@ -38,14 +47,23 @@ require 'stella/adapter/httperf'
 # = Stella
 #  A friend in performance testing. 
 #
+# This class ties Stella together. It must be required because it defines
+# several constants which are used througout the other classes. +SYSINFO+ 
+# is particularly important because it detects the platform and requires
+# platform specific modules. 
 module Stella 
-  LOGGER = Stella::Logger.new(:debug=>false)
-  TEXT = Stella::Text.new('en')
+    # Autodetecets information about the local system, 
+    # including OS (unix), implementation (freebsd), and architecture (x64)
+  SYSINFO = Stella::SystemInfo.new unless defined? SYSINFO
+    # A global logger for info, error, and debug messages. 
+  LOGGER = Stella::Logger.new(:debug=>true) unless defined? LOGGER
+    # A global resource for all interface text. 
+  TEXT = Stella::Text.new('en') unless defined? TEXT
   
   module VERSION #:nodoc:
     MAJOR = 0.freeze unless defined? MAJOR
     MINOR = 5.freeze unless defined? MINOR
-    TINY  = 3.freeze unless defined? TINY
+    TINY  = 4.freeze unless defined? TINY
     def self.to_s
       [MAJOR, MINOR, TINY].join('.')
     end
@@ -53,6 +71,6 @@ module Stella
       self.to_s.to_f
     end
   end
-  
+
 end