stella 0.6.0 → 0.7.0.002

data/lib/stella/data/http.rb

@@ -1,259 +1,4 @@
 
-require 'storable'
-require 'util/httputil'
-require 'base64'
+module Stella::Data::HTTP; end
 
-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 < Storable
-    attr_reader :raw_data
-    
-    def to_s
-      @raw_data
-    end
-    
-  end
-  
-  class HTTPBody < Storable
-    field :content_type
-    field :form_param
-    field :content
-    
-    def has_content?
-      !@content.nil?
-    end
-    
-  end
-  
-  class HTTPRequest < Storable
-    # A string representing a raw HTTP request
-    attr_reader :raw_data
-    
-    # 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 :name
-    field :stella_id
-    field :unique_id
-    field :time => DateTime
-    field :client_ip 
-    field :server_ip 
-    field :header 
-    field :uri
-    field :params
-    field :body 
-    field :http_method
-    field :http_version
-    
-    
-    def has_body?
-      !@body.nil? && !@body.empty?
-    end
-    def has_request?
-      false
-    end
-
-    def initialize (uri_str, method="GET", version="1.1")
-      @uri = (uri_str.is_a? String) ? URI.parse(uri_str) : uri
-      @http_method = method
-      @http_version = version
-      @headers = {}
-      @params = {}
-      @response_handler = {}
-      @time = Time.now
-      @stella_id = Stella::Crypto.sign(time.to_i.to_s, "#{@http_method}/#{@uri}/#{@params}")
-      @unique_id = nil
-      @body = HTTPBody.new
-    end
-    
-    def set_unique_id(seasoning=rand)
-      @unique_id = Stella::Crypto.sign(rand.to_s + seasoning.to_s, "#{@http_method}/#{@uri}/#{@params}")
-    end
-
-    
-    def from_raw(raw_data=nil)
-      @raw_data = raw_data
-      @http_method, @http_version, @uri, @header, @body = self.parse(@raw_data)
-      @time = DateTime.now
-    end
-    
-    def self.parse(raw)
-      return unless raw
-      HTTPUtil::parse_http_request(raw, @uri.host, @uri.port) 
-    end
-
-    
-    def add_header(*args)
-      name, value = (args[0].is_a? Hash) ? args[0].to_a.flatten : args
-      @headers[name.to_s] ||= []
-      @headers[name.to_s] << value
-    end
-    def add_param(*args)
-      name, value = (args[0].is_a? Hash) ? args[0].to_a.flatten : args
-      
-      # BUG: This auto-array shit is causing a problem where the one request
-      # will set the param and then next will set it again and it becomes
-      # an array. 
-      #if @params[name.to_s] && !@params[name.to_s].is_a?(Array)
-      #  @params[name.to_s] = [@params[name.to_s]]
-      #else
-      #  @params[name.to_s] = ""
-      #end
-      
-      @params[name.to_s] = value.to_s
-    end
-    
-    def add_response_handler(*args, &b)
-      args << 200 if args.empty?
-      args.each do |status|
-        @response_handler[status] = b
-      end
-    end
-    
-    # +content+ can be literal content or a file path
-    def add_body(content, form_param=nil, content_type=nil)
-      @body = Stella::Data::HTTPBody.new
-      
-      @body.form_param = form_param if form_param
-      @body.content_type = content_type if content_type
-      
-      if File.exists?(content)
-        @body.content = File.new(content)
-        @body.content_type ||= "application/x-www-form-urlencoded"
-      else
-        @body.content = content
-      end
-      
-    end
-    
-    
-    def body
-      return nil unless @body
-      @body
-      #(!header || header[:Content_Type] || header[:Content_Type] !~ /text/) ? Base64.encode64(@body) : @body
-    end
-    
-
-    def headers
-      return [] unless header
-      headers = []
-      header.each_pair do |n,v|
-        headers << [n.to_s.gsub('_', '-'), v[0]]
-      end
-      headers
-    end
-    
-    def inspect
-      str = "%s %s HTTP/%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 %s HTTP/%s" % [time.strftime(NICE_TIME_FORMAT), http_method, uri.to_s, http_version]
-      str
-    end
-    
-    def cookies
-      return [] if !header.is_a?(Hash) || header[:Cookie].empty?
-      header[:Cookie] 
-    end
-    
-  end
-  
-  class HTTPResponse < Storable
-    attr_reader :raw_data
-    
-    field :time => DateTime
-    field :client_ip => String
-    field :server_ip => String
-    field :header => String
-    field :body => String
-    field :status => String
-    field :message => String
-    field :http_version => String
-    
-    def initialize(raw_data=nil)
-      @raw_data = raw_data
-      parse(@raw_data)
-    end
-    
-    def parse(raw)
-      return unless raw
-      @status, @http_version, @message, @header, @body = HTTPUtil::parse_http_response(raw)
-    end
-    
-    def has_body?
-      !@body.nil? && !@body.empty?
-    end
-    def has_request?
-      false
-    end
-    def has_response?
-      false
-    end
-    
-    
-    def body
-      return nil unless @body
-      #TODO: Move to HTTPResponse::Body.to_s
-      if is_binary?
-       "[skipping binary content]"
-      elsif is_gzip?
-        #require 'zlib'
-        #Zlib::Inflate.inflate(@body)
-         "[skipping gzip content]"
-      else
-        @body
-      end
-    end
-    
-    def headers
-      headers = []
-      header.each_pair do |n,v|
-        headers << [n.to_s.gsub('_', '-'), v[0]]
-      end
-      headers
-    end
-    
-    def is_binary?
-      (!is_text?) == true
-    end
-    
-    def is_text?
-      (!header[:Content_Type].nil? && (header[:Content_Type][0].is_a? String) && header[:Content_Type][0][/text/] != nil)
-    end
-    
-    def is_gzip?
-      (!header[:Content_Encoding].nil? && (header[:Content_Encoding][0].is_a? String) && header[:Content_Encoding][0][/gzip/] != nil)
-    end
-    
-    def inspect
-      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
-    
-    
-    def cookies
-      return [] unless header.is_a?(Array) && !header[:Set_Cookie].empty?
-      header[:Set_Cookie] 
-    end
-  end
-end 
+Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'data', 'http', '*.rb')

data/lib/stella/data.rb

@@ -0,0 +1,85 @@
+
+module Stella::Data
+  
+  module Helpers
+    
+    
+    def random(input=nil)
+      
+      Proc.new do
+        value = case input.class.to_s
+        when "Symbol"
+          resource(input)
+        when "Array"
+          input
+        when "Range"
+          input.to_a
+        when "Fixnum"
+          Stella::Utils.strand( input )
+        when "NilClass"
+          Stella::Utils.strand( rand(100) )
+        end
+        Stella.ld "RANDVALUES: #{input} #{value.inspect}"
+        value = value[ rand(value.size) ] if value.is_a?(Array)
+        Stella.ld "SELECTED: #{value}"
+        value
+      end
+    end
+    
+    def sequential(input=nil)
+      digest = input.gibbler
+      Proc.new do
+        value = case input.class.to_s
+        when "Symbol"
+          ret = resource(input)
+          ret
+        when "Array"
+          input
+        when "Range"
+          input.to_a
+        end
+        Stella.ld "SEQVALUES: #{input} #{value.inspect}"
+        @sequential_offset ||= {}
+        @sequential_offset[digest] ||= 0
+        if value.is_a?(Array)
+          size = value[ @sequential_offset[digest] ].size
+          value = value[ @sequential_offset[digest] ] 
+          @sequential_offset[digest] += 1
+          @sequential_offset[digest] = 0 if @sequential_offset[digest] > size
+        end
+        Stella.ld "SELECTED: #{value}"
+        value
+      end
+    end
+    
+    def rsequential(input=nil)
+      digest = input.gibbler
+      Proc.new do
+        value = case input.class.to_s
+        when "Symbol"
+          ret = resource(input)
+          ret
+        when "Array"
+          input
+        when "Range"
+          input.to_a
+        end
+        Stella.ld "RSEQVALUES: #{input} #{value.inspect}"
+        @rsequential_offset ||= {}
+        @rsequential_offset[digest] ||= value.size-1 rescue 1
+        if value.is_a?(Array)
+          size = value[ @rsequential_offset[digest] ].size
+          value = value[ @rsequential_offset[digest] ] 
+          @rsequential_offset[digest] -= 1
+          @rsequential_offset[digest] = size if @rsequential_offset[digest] < 0
+        end
+        Stella.ld "SELECTED: #{value}"
+        value
+      end
+    end
+    
+  end
+      
+end
+
+Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'data', '*.rb')

data/lib/stella/dsl.rb

@@ -0,0 +1,5 @@
+
+
+module Stella::DSL; end
+
+Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'dsl', '*.rb')

data/lib/stella/engine/functional.rb

@@ -0,0 +1,39 @@
+
+module Stella::Engine
+  module Functional
+    extend Stella::Engine::Base
+    extend self
+    
+    def run(plan, opts={})
+      opts = {
+        :hosts        => [],
+        :benchmark    => false,
+        :repetitions  => 1
+      }.merge! opts
+      Stella.ld "OPTIONS: #{opts.inspect}"
+      Stella.li2 "Hosts: " << opts[:hosts].join(', ') if !opts[:hosts].empty?
+      
+      client = Stella::Client.new opts[:hosts].first
+      client.add_observer(self)
+      client.enable_benchmark_mode if opts[:benchmark]
+      
+      plan.usecases.each_with_index do |uc,i|
+        desc = (uc.desc || "Usecase ##{i+1}")
+        Stella.li ' %-65s '.att(:reverse).bright % [desc]
+        Stella.rescue { client.execute uc }
+      end
+      
+      Drydock::Screen.flush
+    end
+    
+  end
+end
+
+__END__
+
+
+$ stella verify -p examples/basic/plan.rb http://localhost:3114
+$ stella load -p examples/basic/plan.rb http://localhost:3114
+$ stella remote-load -p examples/basic/plan.rb http://localhost:3114
+$ stella remote-verify -p examples/basic/plan.rb http://localhost:3114
+

data/lib/stella/engine/load.rb

@@ -0,0 +1,106 @@
+
+module Stella::Engine
+  module Load
+    extend Stella::Engine::Base
+    extend self
+    
+    def run(plan, opts={})
+      opts = {
+        :hosts        => [],
+        :users        => 1,
+        :time         => nil,
+        :benchmark    => false,
+        :repetitions  => 1
+      }.merge! opts
+      opts[:users] = plan.usecases.size if opts[:users] < plan.usecases.size
+      opts[:users] = 1000 if opts[:users] > 1000
+      
+      Stella.ld "OPTIONS: #{opts.inspect}"
+      Stella.li2 "Hosts: " << opts[:hosts].join(', ')
+      
+      packages = build_thread_package plan, opts
+      Drydock::Screen.flush
+      
+      Thread.ify packages, :threads => opts[:users] do |package|
+        (1..opts[:repetitions]).to_a.each do |rep|
+          # We store client specific data in the usecase
+          # so we clone it here so each thread is unique.
+          Stella.rescue { package.client.execute package.usecase }
+          Drydock::Screen.flush
+        end
+      end
+      
+      Drydock::Screen.flush
+    end
+    
+  protected
+    class ThreadPackage
+      attr_accessor :index
+      attr_accessor :client
+      attr_accessor :usecase
+      def initialize(i, c, u)
+        @index, @client, @usecase = i, c, u
+      end
+    end
+  
+    def build_thread_package(plan, opts)
+      packages, pointer = Array.new(opts[:users]), 0
+      plan.usecases.each_with_index do |usecase,i|
+        
+        count = case opts[:users]
+        when 0..9
+          if (opts[:users] % plan.usecases.size > 0) 
+            raise Stella::Testplan::WackyRatio, "User count does not match usecase count evenly"
+          else
+            (opts[:users] / plan.usecases.size)
+          end
+        else
+          (opts[:users] * usecase.ratio).to_i
+        end
+        
+        Stella.ld "THREAD PACKAGE: #{usecase.desc} #{pointer} #{(pointer+count)} #{count}"
+        # Fill the thread_package with the contents of the block
+        packages.fill(pointer, count) do |index|
+          Stella.li2 "Creating client ##{index+1} "
+          client = Stella::Client.new opts[:hosts].first, index+1
+          client.add_observer(self)
+          client.enable_benchmark_mode if opts[:benchmark]
+          ThreadPackage.new(index+1, client, usecase.clone)
+        end
+        pointer += count
+      end
+      packages
+    end
+    
+    def update_send_request(client_id, usecase, meth, uri, req, params, counter)
+      
+    end
+    
+    def update_receive_response(client_id, usecase, meth, uri, req, params, container)
+      desc = "#{usecase.desc} > #{req.desc}"
+      Stella.li '  Client%-3s %3d %-6s %-45s %s' % [client_id, container.status, req.http_method, desc, uri]
+    end
+    
+    def update_execute_response_handler(client_id, req, container)
+    end
+    
+    def update_error_execute_response_handler(client_id, ex, req, container)
+    end
+    
+    def update_request_error(client_id, usecase, meth, uri, req, params, ex)
+      desc = "#{usecase.desc} > #{req.desc}"
+      Stella.le '  Client%-3s %-45s %s' % [client_id, desc, ex.message]
+    end
+
+    
+  end
+end
+
+__END__
+
+
+$ stella verify -p examples/basic/plan.rb http://localhost:3114
+$ stella load -p examples/basic/plan.rb http://localhost:3114
+$ stella remote-load -p examples/basic/plan.rb http://localhost:3114
+$ stella remote-verify -p examples/basic/plan.rb http://localhost:3114
+

data/lib/stella/engine.rb

@@ -0,0 +1,55 @@
+
+
+module Stella::Engine
+  module Base
+    extend self
+    def run
+      raise "override the run method"
+    end
+    
+    def update(*args)
+      what, *args = args
+      Stella.ld "OBSERVER UPDATE: #{what}"
+      if !respond_to?("update_#{what}")
+        Stella.ld "NO UPDATE HANDLER FOR: #{what}" 
+      else
+        Stella.rescue {
+          self.send("update_#{what}", *args) 
+        }
+      end
+    end
+    
+    def update_send_request(client_id, usecase, meth, uri, req, params, counter)
+      notice = "repeat: #{counter-1}" if counter > 1
+      Stella.li2 ' ' << " %-46s %16s ".att(:reverse) % [req.desc, notice]
+    end
+    
+    def update_receive_response(client_id, usecase, meth, uri, req, params, container)
+      Stella.li '  %-59s %3d' % [uri, container.status]
+      Stella.li2 "  Method: " << req.http_method
+      Stella.li2 "  Params: " << params.inspect
+      Stella.li3 $/, "  Headers:"
+      container.headers.all.each do |pair|
+        Stella.li3 "    %s: %s" % pair
+      end
+      Stella.li3 $/, "  Content:"
+      Stella.li3 container.body.empty? ? '    [empty]' : container.body
+      Stella.li2 $/
+    end
+    
+    def update_execute_response_handler(client_id, req, container)
+    end
+    
+    def update_error_execute_response_handler(client_id, ex, req, container)
+      Stella.le ex.message
+    end
+    
+    def update_request_error(client_id, usecase, meth, uri, req, params, ex)
+      desc = "#{usecase.desc} > #{req.desc}"
+      Stella.le '  Client%-3s %-45s %s' % [client_id, desc, ex.message]
+    end
+    
+  end
+end
+
+Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'engine', '*.rb')

data/lib/stella/exceptions.rb

@@ -0,0 +1,15 @@
+
+
+module Stella
+  class Error < RuntimeError
+    def initialize(obj=nil); @obj = obj; end
+    def message; "#{self.class}: #{@obj}"; end
+  end
+  
+  class InvalidOption < Stella::Error
+  end
+  
+  class NoHostDefined < Stella::Error
+  end
+  
+end

data/lib/stella/guidelines.rb

@@ -0,0 +1,18 @@
+
+
+module Stella
+  module Guidelines
+    extend self
+    AFE = "Always fail early"
+    ABA = "Always be accurate"
+    CBC = "Consistency before cuteness"
+    NDP = "No defensive programming"
+    def inspect
+      all = Stella::Guidelines.constants
+      g = all.collect { |c| '%s="%s"' % [c, const_get(c)] }
+      %q{#<Stella::Guidelines:0x%s %s>} % [self.object_id, g.join(' ')]
+    end
+  end
+end
+
+p Stella::Guidelines if __FILE__ == $0

data/lib/stella/mixins.rb

@@ -0,0 +1,2 @@
+
+Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'mixins', '*.rb')

data/lib/stella/stats.rb

@@ -1,5 +1,4 @@
 
-
 module Stella
 # Based on Mongrel::Stats, Copyright (c) 2005 Zed A. Shaw
 class Stats    
@@ -17,12 +16,9 @@ class Stats
   
   # Resets the internal counters so you can start sampling again.
   def reset
-    @sum = 0.0
-    @sumsq = 0.0
+    @n, @sum, @sumsq = 0.0, 0.0, 0.0
     @last_time = Time.new
-    @n = 0.0
-    @min = 0.0
-    @max = 0.0
+    @min, @max = 0.0, 0.0
   end
 
   # Adds a sampling to the calculations.
@@ -81,4 +77,4 @@ class Stats
     @last_time = now
   end
 end
-end
+end

data/lib/stella/testplan/stats.rb

@@ -0,0 +1,26 @@
+
+module Stella
+class Testplan
+
+  class Stats
+    include Gibbler::Complex
+    attr_reader :requests
+
+    def initialize
+      @requests = OpenStruct.new
+      reset
+    end
+    
+    def total_requests
+      @requests.successful + @requests.failed
+    end
+    
+    def reset 
+      @requests.successful = 0
+      @requests.failed = 0
+    end
+    
+  end
+    
+end
+end