solutious-stella 0.6.0 → 0.7.0.001

data/lib/stella/data/http/request.rb

@@ -0,0 +1,116 @@
+
+
+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
+    
+    def has_body?
+      !@body.nil? && !@body.empty?
+    end
+    
+    def initialize (method, uri_str, version="1.1", &definition)
+      @uri = uri_str
+      @http_method, @http_version = method, version
+      @headers, @params, @response_handler = {}, {}, {}
+      @wait = 0
+      @desc = "Request"
+      @body = Stella::Data::HTTP::Body.new
+      instance_eval &definition unless definition.nil?
+    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)
+      @headers.merge! args.first unless args.empty?
+      @headers
+    end
+    alias_method :header, :headers
+    
+    def params(*args)
+      @params.merge! args.first unless args.empty?
+      @params
+    end
+    alias_method :param, :params
+    
+    def response(*args, &definition)
+      if definition.nil?
+        @response_handler
+      else
+        args << 200 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?
+      content, form_param, content_type = *args
+      
+      @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 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 HTTP/%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/data/http/response.rb

@@ -0,0 +1,92 @@
+
+
+module Stella::Data::HTTP
+  
+  class Response < Storable
+    include Gibbler::Complex
+    
+    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

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.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/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/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