solutious-stella 0.5.5 → 0.6.0

data/lib/{stella/logger.rb → logger.rb}

@@ -8,9 +8,9 @@ module Stella
     # * <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)
+    # * <tt>:debug_level</tt> An integer from 0 to 4 which determines the amount of debugging output. Default: 0.
     def initialize(args={})
-      @debug_level        = args[:debug] || false
+      @debug_level        = args[:debug_level] || false
       @info_logger  = args[:info_logger]
       @error_logger = args[:error_logger]
       @debug_logger = args[:debug_logger]
@@ -20,14 +20,9 @@ module Stella
     # 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
+      msgs.each do |m|
+        info_logger.puts m
+      end  
       info_logger.flush
     end
     
@@ -75,7 +70,7 @@ module Stella
     def error(ex, prefix="ERR: ")
       msg = (ex.kind_of? String) ? ex : ex.message
       error_logger.puts "#{prefix}#{msg}"
-      return unless @debug_level && ex.kind_of?(Exception)
+      return unless @debug_level > 0 && ex.kind_of?(Exception)
       error_logger.puts("#{prefix}------------------------------------------")
       error_logger.puts("#{prefix}#{ex.backtrace.join("\n")}")
       error_logger.puts("#{prefix}------------------------------------------")

data/lib/stella.rb

@@ -1,74 +1,46 @@
 
-
 require 'date'
 require 'time'
-require 'tempfile'
-require 'socket'
-require 'ostruct'
-require 'optparse'
 require 'rubygems'
+require 'logger'
+require 'uri'
+require 'httpclient'
 
+require 'storable'
+require 'stella/stats'
+require 'threadify'
+require 'timeunits'
 
-# Common utilities
-require 'utils/domainutil'
-require 'utils/httputil'
-require 'utils/fileutil'
-require 'utils/mathutil'
-require 'utils/escape'
-require 'utils/stats'
-
-# Common dependencies
-$: << File.join(STELLA_HOME, 'vendor', 'useragent', 'lib')
-require 'user_agent'
+require 'stella/crypto'
 
-# Common Stella dependencies
-require 'stella/support'
-require 'stella/storable'
+require 'stella/common'
 
-# Common Stella Data Objects
 require 'stella/data/http'
 require 'stella/data/domain'
 
-# Common Stella objects
-require 'stella/text'
+require 'stella/environment'
+require 'stella/clients'
+require 'stella/testrunner'
+require 'stella/testplan'
+require 'stella/loadtest'
+require 'stella/functest'
 
-require 'stella/logger'
-require 'stella/response'
-require 'stella/sysinfo'
-require 'stella/test/definition'
-require 'stella/test/run/summary'
-require 'stella/test/stats'
+srand
 
-# Commands
-require 'stella/command/base'
-require 'stella/command/localtest'
+# Common dependencies
+STELLA_HOME = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$: << File.join(STELLA_HOME, 'vendor', 'useragent', 'lib')
 
-# Adapters
-require 'stella/adapter/base'
-require 'stella/adapter/ab'
-require 'stella/adapter/siege'
-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 
-    # 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=>false) unless defined? LOGGER
-    # A global resource for all interface text. 
-  TEXT = Stella::Text.new('en') unless defined? TEXT
+
+  LOGGER = Logger.new(:debug_level=>0) unless defined? LOGGER
   
   module VERSION #:nodoc:
     MAJOR = 0.freeze unless defined? MAJOR
-    MINOR = 5.freeze unless defined? MINOR
-    TINY  = 5.freeze unless defined? TINY
+    MINOR = 6.freeze unless defined? MINOR
+    TINY  = 0.freeze unless defined? TINY
     def self.to_s
       [MAJOR, MINOR, TINY].join('.')
     end
@@ -77,16 +49,13 @@ module Stella
     end
   end
   
-  def self.debug=(enable=false)
-    Stella::LOGGER.debug_level = enable
-  end
   
-  def self.text(*args)
-    TEXT.msg(*args)
+  def self.debug_level
+    Stella::LOGGER.debug_level
   end
   
-  def self.sysinfo
-    SYSINFO
+  def self.debug_level=(level)
+    Stella::LOGGER.debug_level = level
   end
   
   def self.info(*args)
@@ -97,5 +66,54 @@ module Stella
     LOGGER.error(*args)
   end
   
+  def self.fatal(*args)
+    LOGGER.error(*args)
+    exit 1
+  end
+  
+  def self.debug(*args)
+    LOGGER.debug(*args)
+  end
+end
+
+module Stella
+  module DSL
+    include Stella::DSL::TestPlan
+    include Stella::DSL::FunctionalTest
+    include Stella::DSL::LoadTest
+    include Stella::DSL::Environment
+    # For Modules
+    #extend Stella::DSL::TestPlan
+    #extend Stella::DSL::FunctionalTest
+  end
 end
 
+class Object #:nodoc: all
+# The hidden singleton lurks behind everyone
+   def metaclass; class << self; self; end; end
+   def meta_eval &blk; metaclass.instance_eval &blk; end
+
+   # Adds methods to a metaclass
+   def meta_def name, &blk
+     meta_eval { define_method name, &blk }
+   end
+
+   # Defines an instance method within a class
+   def class_def name, &blk
+     class_eval { define_method name, &blk }
+   end
+
+end
+
+class Array
+  # create a hash from an array of [key,value] tuples
+  # you can set default or provide a block just as with Hash::new
+  # Note: if you use [key, value1, value2, value#], hash[key] will
+  # be [value1, value2, value#]
+  # From: http://www.ruby-forum.com/topic/138218#615260
+  def stella_to_hash(default=nil, &block)
+    hash = block_given? ? Hash.new(&block) : Hash.new(default)
+    each { |(key, *value)| hash[key]=*value }
+    hash
+  end
+end

data/lib/stella/clients.rb

@@ -0,0 +1,161 @@
+
+require "observer"
+require "tempfile"
+
+
+module Stella
+  class Client
+    include Observable
+    
+    @@IDS = {}
+    
+    attr_reader :request_stats
+    attr_accessor :client_id
+    def initialize(client_id=1)
+      @client_id = client_id
+      @request_stats = {
+      }
+    end
+    
+    def execute_testplan(request_stats, http_client, machine, namespace, plan, verbose=1)
+      changed
+      notify_observers(:start, machine, plan.name)
+      
+      if plan.auth
+        auth_domain = "#{plan.protocol}://#{machine.to_s}/"
+        http_client.set_auth(auth_domain, plan.auth.user, plan.auth.pass)
+        changed
+        notify_observers(:authorized, auth_domain, plan.auth.user, plan.auth.pass)
+      end
+      
+      tf = Tempfile.new('stella-cookie')
+      http_client.set_cookie_store(tf.to_s)
+    
+      request_methods = namespace.methods.select { |meth| meth =~ /\d+\s[A-Z]/ }
+      
+      retry_count = 1
+      previous_methname = nil
+      request_methods.each do |methname|
+        retry_count = 1 unless previous_methname == methname
+        previous_methname = methname
+        
+        # We need to define the request only the first time it's run. 
+        req = namespace.send(methname) unless retry_count > 1 
+        req.set_unique_id(self.object_id)
+        
+        request_stats[req.stella_id.to_sym] ||= {
+          :name => req.name,
+          :stats => Stats.new( req.name )
+        }
+        
+        uri = req.uri.is_a?(URI) ? req.uri : URI.parse(req.uri.to_s)
+        uri.scheme ||= plan.protocol
+        uri.host ||= machine.host
+        uri.port ||= machine.port
+        
+        query = {}.merge!(req.params)
+        
+        
+        
+        begin
+          
+          if req.http_method =~ /POST|PUT/
+            
+            if req.body.has_content?
+              body = req.body.content
+              param = req.body.form_param || 'file'  # How do we handle bodies with no form name?
+              query[param] = body # NOTE: HTTPClient prefers a file handle rather than reading in the file
+            end
+
+          end
+          
+          # Make the request. 
+          time_started = Time.now
+          res = http_client.send(req.http_method.downcase, uri.to_s, query)
+          request_stats[req.stella_id.to_sym][:stats].sample(Time.now - time_started)
+          
+          id1 = (query || {})['id']
+          id2 = YAML.load(res.body.content || '')[:id]
+          if id1          
+            #puts "#{id1} (#{req.unique_id}): #{@@IDS[id1].join(', ')}" if @@IDS.has_key?(id1) && @@IDS[id1].size > 1
+            @@IDS[id1] ||= []
+            @@IDS[id1] << @client_id
+            @@IDS[id1].uniq!
+          end
+          
+        rescue => ex
+          changed
+          notify_observers(:request_exception, req.http_method, uri, query, ex)
+          next
+        end
+        
+        
+        response_headers = res.header.all.stella_to_hash
+        
+
+        
+        unless req.response_handler.has_key?(res.status)
+          changed
+          notify_observers(:request_unexpected_response, req.http_method, uri, query, res.status, response_headers, res.body.content)
+        else
+          
+          changed
+          notify_observers(:request, req.http_method, uri, query, res.status, response_headers, res.body.content)
+          
+          response_handler_ret = req.response_handler[res.status].call(response_headers, res.body.content, @client_id, req.unique_id)
+        
+          if response_handler_ret.is_a?(Stella::TestPlan::ResponseHandler) && response_handler_ret.action == :repeat
+            retry_count ||= 1
+          
+            if retry_count > response_handler_ret.times
+              retry_count = 1
+              next
+            else  
+              changed
+              notify_observers(:retrying, uri, retry_count, response_handler_ret.times)
+              run_sleeper(response_handler_ret.wait)
+              retry_count += 1
+              redo
+            end
+          end
+        end
+        
+      end
+      
+      http_client.save_cookie_store
+      changed
+      notify_observers(:done)
+      
+    end
+  
+    def run_sleeper(duration, quiet=true)
+      remainder = duration % 1 
+      duration.to_i.times {
+        print '.' unless duration <= 1 || quiet
+        sleep 1
+      }
+      sleep remainder if remainder > 0
+    end  
+  end
+end
+
+#module Stella
+#  class Clients
+#
+#      # The default authentication, a Stella::Common::Auth object
+#    attr_accessor :auth
+#    
+#  end
+#end
+
+#module Stella
+#  module DSL
+#    module Clients
+#      
+#      def clients(name = :anonymous, &define)
+#        @stella_clients ||= {}
+#        @stella_clients[name] = []
+#      end
+#    end
+#  end
+#end

data/lib/stella/command/base.rb

@@ -1,28 +1,11 @@
 
       
 module Stella::Command
-  class Base
-    
-    
-    # TODO: See EC2::Platform for example to improve/generalize platform
-    # discovery. We'll need this for monitoring. 
-    IMPLEMENTATIONS = [
-      [/darwin/i,  :unix,    :macosx ]
-    ]
-    ARCHITECTURES = [
-      [/(i\d86)/i,  :i386             ]
-    ]
-    
-    # When using Stella::CLI this will contain the string used to call this command
-    # i.e. ab, siege, help, etc...
-    attr_accessor :shortname
-    
-    
-    def initialize()
-      
-      #agent = find_agent(*expand_str(v)) 
-      #@logger.info(:cli_print_agent, agent) if @options.verbose >= 1
+  module Base
 
+    
+    def run
+      raise "Override 'run'"
     end
     
     def run_sleeper(duration)
@@ -33,8 +16,5 @@ module Stella::Command
       }
       sleep remainder if remainder > 0
     end
-    
-
-
   end
 end

data/lib/stella/command/form.rb

@@ -0,0 +1,36 @@
+
+require 'httpclient'
+
+require 'util/httputil'
+
+require 'stella/command/base'
+require 'stella/data/http'
+
+
+module Stella::Command #:nodoc: all
+  class Form < Drydock::Command #:nodoc: all
+    include Stella::Command::Base
+    
+    
+    
+  end
+end
+
+
+
+
+__END__
+
+headers = { 'Content-Type' => 'text/xml' }
+                       
+@client = HTTPClient.new('http://localhost:3114')
+@url = URI.parse "http://solutious.com/"
+#@url = URI.parse 'https://delaagsterekening.nl/api/suggestions/status.json?token=253'
+#@client.set_auth("https://delaagsterekening.nl/", "stella", "stella")
+@client.set_cookie_store("/tmp/cookie.dat")
+body, resp = @client.get @url, headers
+body.header.all.each do |h|
+  puts "#{h[0]}: #{h[1]}"
+end
+#puts @client
+@client.save_cookie_store