stella 0.7.3.002 → 0.7.4.001

data/lib/stella/client/container.rb

@@ -45,6 +45,7 @@ class Stella::Client
     attr_accessor :params
     attr_accessor :headers
     attr_accessor :response
+    attr_accessor :unique_id
     attr_reader :resources
     attr_reader :client_id
     attr_reader :assets
@@ -87,7 +88,8 @@ class Stella::Client
       # wrong number of arguments(1 for 0)
       template = ERB.new(t)
       v = template.result(binding)  
-    rescue 
+    rescue => ex
+      Stella.ld ex.message, ex.backtrace
       t
     end
     
@@ -163,6 +165,7 @@ class Stella::Client
     def wait(t); sleep t; end
     def quit(msg=nil); Quit.new(msg); end
     def fail(msg=nil); Fail.new(msg); end
+    def error(msg=nil); Error.new(msg); end
     def repeat(t=1); Repeat.new(t); end
     
     

data/lib/stella/common.rb

@@ -0,0 +1,255 @@
+#encoding: utf-8
+
+$KCODE = "u" if RUBY_VERSION =~ /^1.8/
+
+
+
+# Assumes Time::Units and Numeric mixins are available. 
+
+class String
+  
+  def in_seconds
+    # "60m" => ["60", "m"]
+    q,u = self.scan(/([\d\.]+)([s,m,h])?/).flatten
+    q &&= q.to_f and u ||= 's'
+    q &&= q.in_seconds(u)
+  end
+  
+end
+
+class MatchData
+  include Gibbler::String
+end
+
+class Thread
+  extend Attic
+  attic :stats
+end
+
+class Time
+  module Units
+    PER_MICROSECOND = 0.000001.freeze
+    PER_MILLISECOND = 0.001.freeze
+    PER_MINUTE = 60.0.freeze
+    PER_HOUR = 3600.0.freeze
+    PER_DAY = 86400.0.freeze
+    
+    def microseconds()    seconds * PER_MICROSECOND     end
+    def milliseconds()    seconds * PER_MILLISECOND    end
+    def seconds()         self                         end
+    def minutes()         seconds * PER_MINUTE          end
+    def hours()           seconds * PER_HOUR             end
+    def days()            seconds * PER_DAY               end
+    def weeks()           seconds * PER_DAY * 7           end
+    def years()           seconds * PER_DAY * 365        end 
+            
+    def in_years()        seconds / PER_DAY / 365      end
+    def in_weeks()        seconds / PER_DAY / 7       end
+    def in_days()         seconds / PER_DAY          end
+    def in_hours()        seconds / PER_HOUR          end
+    def in_minutes()      seconds / PER_MINUTE         end
+    def in_milliseconds() seconds / PER_MILLISECOND    end
+    def in_microseconds() seconds / PER_MICROSECOND   end
+
+    def in_seconds(u=nil)
+      case u.to_s
+      when /\A(y)|(years?)\z/
+        years
+      when /\A(w)|(weeks?)\z/
+        weeks
+      when /\A(d)|(days?)\z/
+        days
+      when /\A(h)|(hours?)\z/
+        hours
+      when /\A(m)|(minutes?)\z/
+        minutes
+      when /\A(ms)|(milliseconds?)\z/
+        milliseconds
+      when /\A(us)|(microseconds?)|(μs)\z/
+        microseconds
+      else
+        self
+      end
+    end
+    
+    ## JRuby doesn't like using instance_methods.select here. 
+    ## It could be a bug or something quirky with Attic 
+    ## (although it works in 1.8 and 1.9). The error:
+    ##  
+    ##  lib/attic.rb:32:in `select': yield called out of block (LocalJumpError)
+    ##  lib/stella/mixins/numeric.rb:24
+    ##
+    ## Create singular methods, like hour and day. 
+    # instance_methods.select.each do |plural|
+    #   singular = plural.to_s.chop
+    #   alias_method singular, plural
+    # end
+    
+    alias_method :ms, :milliseconds
+    alias_method :'μs', :microseconds
+    alias_method :second, :seconds
+    alias_method :minute, :minutes
+    alias_method :hour, :hours
+    alias_method :day, :days
+    alias_method :week, :weeks
+    alias_method :year, :years
+
+  end
+end
+
+class Numeric
+  include Time::Units
+  # TODO: Use 1024?
+  def to_bytes
+    args = case self.abs.to_i
+    when 0..1000
+      [(self).to_s, 'B']
+    when (1000)..(1000**2)
+      [(self / 1000.to_f).to_s, 'KB']
+    when (1000**2)..(1000**3)
+      [(self / (1000**2).to_f).to_s, 'MB']
+    when (1000**3)..(1000**4)
+      [(self / (1000**3).to_f).to_s, 'GB']
+    when (1000**4)..(1000**6)
+      [(self / (1000**4).to_f).to_s, 'TB']
+    else
+      [self, 'B']
+    end
+    '%3.2f%s' % args
+  end
+end
+
+
+
+
+
+class Stella::Config < Storable
+  include Gibbler::Complex
+  
+  field :source
+  field :apikey
+  field :secret
+  
+  field :redis_host
+  field :redis_port
+  field :redis_pass
+  
+   # Returns true when the current config matches the default config
+  def default?; to_hash.gibbler == DEFAULT_CONFIG_HASH; end
+  
+  def self.each_path(&blk)
+    [PROJECT_PATH, USER_PATH].each do |path|
+      Stella.ld "Loading #{path}"
+      blk.call(path) if File.exists? path
+    end
+  end
+  
+  def self.refresh
+    conf = {}
+    Stella::Config.each_path do |path| 
+      tmp = YAML.load_file path
+      conf.merge! tmp if tmp
+    end
+    a = from_hash conf
+    a || new
+  end
+  
+  def self.init
+    raise AlreadyInitialized, PROJECT_PATH if File.exists? PROJECT_PATH
+    dir = File.dirname USER_PATH
+    Dir.mkdir(dir, 0700) unless File.exists? dir
+    unless File.exists? USER_PATH
+      Stella.stdout.info "Creating #{USER_PATH} (Add your credentials here)"
+      Stella::Utils.write_to_file(USER_PATH, DEFAULT_CONFIG, 'w', 0600)
+    end
+    
+    dir = File.dirname PROJECT_PATH
+    Dir.mkdir(dir, 0700) unless File.exists? dir
+    
+    Stella.stdout.info "Creating #{PROJECT_PATH}"
+    Stella::Utils.write_to_file(PROJECT_PATH, 'target:', 'w', 0600)
+  end
+  
+  def self.blast
+    if File.exists? USER_PATH
+      Stella.stdout.info "Blasting #{USER_PATH}"
+      FileUtils.rm_rf File.dirname(USER_PATH)
+    end
+    if File.exists? PROJECT_PATH
+      Stella.stdout.info "Blasting #{PROJECT_PATH}"
+      FileUtils.rm_rf File.dirname(PROJECT_PATH)
+    end
+  end
+ 
+  def self.project_dir
+    File.join(Dir.pwd, DIR_NAME)
+  end
+  
+  private 
+  
+  def self.find_project_config
+    dir = Dir.pwd.split File::SEPARATOR
+    path = nil
+    while !dir.empty?
+      tmp = File.join(dir.join(File::SEPARATOR), DIR_NAME, 'config')
+      Stella.ld " -> looking for #{tmp}"
+      path = tmp and break if File.exists? tmp
+      dir.pop
+    end
+    path ||= File.join(Dir.pwd, DIR_NAME, 'config')
+    path
+  end
+  
+  
+  unless defined?(DIR_NAME)
+    DIR_NAME = Stella.sysinfo.os == :windows ? 'Stella' : '.stella'
+    USER_PATH = File.join(Stella.sysinfo.home, DIR_NAME, 'config')
+    PROJECT_PATH = Stella::Config.find_project_config
+    DEFAULT_CONFIG = <<CONF
+apikey: ''
+secret: ''
+remote: stella.solutious.com:443
+CONF
+    DEFAULT_CONFIG_HASH = YAML.load(DEFAULT_CONFIG).gibbler
+  end
+    
+  class AlreadyInitialized < Stella::Error; end
+end
+
+
+
+module Stella
+  class Hand
+    attr_accessor :force_stop
+    attr_reader :dthread
+    
+    def initialize(freq=4, rest=1, &routine)
+      @freq, @rest, @routine = freq, rest, routine
+    end
+  
+    def stop()  
+      @force_stop = true  
+      @dthread.join
+      @routine.call
+    end
+    def stop?() @force_stop == true end
+  
+    # Execute yield every FREQUENCY seconds.
+    def start
+      @dthread ||= Thread.new do
+        prev_ptime = Time.now
+        loop do
+          break if Stella.abort? || stop?
+          if (Time.now - prev_ptime).to_i >= @freq
+            @routine.call
+            prev_ptime = Time.now
+          end
+          sleep @rest
+        end
+      end
+      @dthread.abort_on_exception = true
+    end
+  end
+end
+
+

data/lib/stella/data.rb

@@ -1,5 +1,6 @@
 
 module Stella::Data
+  extend self
     
   module Helpers
     
@@ -126,10 +127,11 @@ module Stella::Data
           end
           digest = value.object_id
           if value.is_a?(Array)
-            index = Stella::Client::Container.sequential_offset(digest, value.size-1)
-            value = value[ index ] 
+            idx = Stella::Client::Container.sequential_offset(digest, value.size-1)
+            value = value[ idx ] 
+            Stella.ld "SELECTED(SEQ): #{value} #{idx} #{input} #{digest}"
           end
-          Stella.ld "SELECTED(SEQ): #{value} #{index} #{input} #{digest}"
+          
           # I think this needs to be updated for global_sequential:
           @sequential_value[input.object_id] = value
         end
@@ -178,7 +180,7 @@ module Stella::Data
     ##        size = value.size
     ##        @sequential_offset[digest] = 0 if @sequential_offset[digest] >= size
     ##        value = value[ @sequential_offset[digest] ] 
-    ##        Stella.li "WHAY: #{value} (#{@sequential_offset[digest]})"
+    ##        Stella.stdout.info "WHAY: #{value} (#{@sequential_offset[digest]})"
     ##        @sequential_offset[digest] += 1
     ##      end
     ##      Stella.ld "SELECTED: #{value}"

data/lib/stella/data/http.rb

@@ -1,4 +1,128 @@
 
-module Stella::Data::HTTP; end
 
-Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'data', 'http', '*.rb')
+module Stella::Data::HTTP
+  class Request < Storable
+    include Gibbler::Complex
+    include Stella::Data::Helpers
+    
+      # A hash containing blocks to be executed depending on the HTTP response status.
+      # The hash keys are numeric HTTP Status Codes. 
+      #
+      #     200 => { ... }
+      #     304 => { ... }
+      #     500 => { ... }
+      #
+    attr_accessor :response_handler
+    
+    field :desc
+    field :header 
+    field :uri
+    field :wait
+    field :params
+    field :body 
+    field :http_method
+    field :http_version
+    field :content_type
+    field :http_auth
+    
+    def has_body?
+      !@body.nil?
+    end
+    
+    def initialize (method, uri_str, version="1.1", &definition)
+      @uri = uri_str
+      @http_method, @http_version = method, version
+      @headers, @params, @response_handler = {}, {}, {}
+      @resources = {}
+      @wait = 0
+      @desc = "Request"
+      instance_eval &definition unless definition.nil?
+    end
+    
+    def auth(user=nil, pass=nil, kind=:basic)
+      @http_auth ||= Stella::Testplan::Usecase::Auth.new
+      @http_auth.user, @http_auth.pass, @http_auth.kind = user, pass, kind
+    end
+    
+    def desc(*args)
+      @desc = args.first unless args.empty?
+      @desc
+    end
+    
+    def content_type(*args)
+      @content_type = args.first unless args.empty?
+      @content_type
+    end
+    
+    def wait(*args)
+      @wait = args.first unless args.empty?
+      @wait
+    end
+    alias_method :sleep, :wait
+    
+    def headers(*args)
+      unless args.empty?
+        h = Hash === args[0] ? args[0] : {args[0]=> args[1]}
+        @headers.merge! h unless h.empty?
+      end
+      @headers
+    end
+    alias_method :header, :headers
+    
+    # Set a resource key value pair in the get, post block.
+    # These will be process later in Stella::Client
+    def set(*args)
+      unless args.empty?
+        h = Hash === args[0] ? args[0] : {args[0]=> args[1]}
+        @resources.merge! h unless h.empty?
+      end
+      @resources
+    end
+    alias_method :resources, :set
+    
+    def params(*args)
+      unless args.empty?
+        h = Hash === args[0] ? args[0] : {args[0]=> args[1]}
+        @params.merge! h unless h.empty?
+      end
+      @params
+    end
+    alias_method :param, :params
+    
+    def response(*args, &definition)
+      if definition.nil?
+        @response_handler
+      else
+        args << /.+/ if args.empty?
+        args.each do |status|
+          @response_handler[status] = definition
+        end
+      end
+    end
+    
+    # +content+ can be literal content or a file path
+    def body(*args)
+      return @body if args.empty?
+      @body = args.first
+    end
+    
+    def inspect
+      str = "%s %s" % [http_method, uri.to_s, http_version]
+      #str << $/ + headers.join($/) unless headers.empty?
+      #str << $/ + $/ + body.to_s if body
+      str
+    end
+    
+    def to_s
+      str = "%s %s" % [http_method, uri.to_s, http_version]
+      str
+    end
+    
+    def cookies
+      return [] if !header.is_a?(Hash) || header[:Cookie].empty?
+      header[:Cookie] 
+    end
+    
+  end
+  
+end

data/lib/stella/engine.rb

@@ -17,8 +17,23 @@ module Stella::Engine
       end
     end
     
-    def runid
-      
+    def runid(plan)
+      args = [Stella.sysinfo.hostname, Stella.sysinfo.user]
+      args.push Stella::START_TIME, plan
+      args.digest
+    end
+    
+    def log_dir(plan, file=nil)
+      stamp = Stella::START_TIME.strftime("%Y%m%d-%H-%M-%S")
+      stamp <<"-#{plan.digest.short}"
+      #stamp << "STAMP"
+      l = File.join Stella::Config.project_dir, 'log', stamp
+      FileUtils.mkdir_p l unless File.exists? l
+      l
+    end
+    
+    def log_path(plan, file)
+      File.join log_dir(plan), file
     end
     
     def process_options!(plan, opts={})
@@ -31,13 +46,12 @@ module Stella::Engine
         :repetitions    => 1
       }.merge! opts
       
-      Stella.li3 " Options: #{opts.inspect}"
-      Stella.lflush
+      Stella.stdout.info2 " Options: #{opts.inspect}"
       
       opts[:clients] = plan.usecases.size if opts[:clients] < plan.usecases.size
       
       if opts[:clients] > @@client_limit
-        Stella.li2 "Client limit is #{@@client_limit}"
+        Stella.stdout.info2 "Client limit is #{@@client_limit}"
         opts[:clients] = @@client_limit
       end
       
@@ -48,13 +62,13 @@ module Stella::Engine
       
       opts[:duration] = opts[:duration].in_seconds
       
-      Stella.li3 " Hosts: " << opts[:hosts].join(', ')
+      Stella.stdout.info3 " Hosts: " << opts[:hosts].join(', ')
       opts
     end
     
     def run; raise; end
-    def update_quit_usecase(client_id, msg) raise end
-    def update_repeat_request(client_id, counter, total) raise end
+    def update_usecase_quit(client_id, msg) raise end
+    def update_request_repeat(client_id, counter, total) raise end
     def update_stats(client_id, http_client, usecase, req) raise end
     def update_prepare_request(*args) raise end
     def update_send_request(*args) raise end
@@ -62,6 +76,8 @@ module Stella::Engine
     def update_execute_response_handler(*args) raise end
     def update_error_execute_response_handler(*args) raise end
     def update_request_error(*args) raise end
+    def request_unhandled_exception(*args) raise end
+    def update_request_fail(*args) raise end
     
   end
   
@@ -70,6 +86,7 @@ module Stella::Engine
   autoload :LoadPackage, 'stella/engine/load_package'
   autoload :LoadCreate, 'stella/engine/load_create'
   autoload :LoadQueue, 'stella/engine/load_queue'
+  autoload :LoadRedis, 'stella/engine/load_redis'
   
   # These timers are interesting from a reporting perspective.
   Benelux.add_counter    Stella::Client, :execute_response_handler