solutious-stella 0.5.5

data/lib/stella/adapter/proxy_watcher.rb

@@ -0,0 +1,76 @@
+
+require 'webrick/httpproxy'
+require 'observer'
+
+
+module Stella
+  module Adapter
+    
+    # Stella::Adapter::ProxyWatcher
+    #
+    # Starts up an HTTP proxy using WEBrick to record HTTP events. This is used
+    # when PcapRecorder is not available. 
+    class ProxyWatcher
+      include Observable
+      
+      attr_accessor :port
+      
+      def initialize(options={})
+        @port = options[:port]
+      end
+      require 'pp'
+      def run
+
+        @server = WEBrick::HTTPProxyServer.new(
+            :Port => @port || 3114,
+            :AccessLog => [],
+            :ProxyContentHandler => Proc.new do |req,res|
+              
+                begin
+                  res_obj = Stella::Data::HTTPResponse.new(res.to_s)
+                  res_obj.time = Time.now
+                  
+                  req_obj = Stella::Data::HTTPRequest.new(req.to_s)
+                  req_obj.time = Time.now
+                  req_obj.client_ip = '0.0.0.0'
+                  req_obj.server_ip = '0.0.0.0'
+
+                  req_obj.response = res_obj
+
+                  changed
+                  notify_observers(:http_request, req_obj)
+                  
+                rescue SystemExit => ex
+                  after
+                  
+                rescue Exception => ex
+                  # There are miscellaneous errors (mostly to do with
+                  # incorrect content-length) that we don't care about. 
+                  Stella::LOGGER.error(ex.message)
+                end
+                
+            end
+        )
+        
+        # We need to trap this INT to kill WEBrick. Unlike with Pcap, 
+        # rescuing Interrupt doesn't work. 
+        
+        trap('INT') do
+		      after
+	      end
+	      
+        @server.start
+	      after
+	      
+      rescue => ex  
+	      after
+      end
+      
+      def after
+        delete_observers
+        @server.shutdown
+      end
+      
+    end
+  end
+end

data/lib/stella/adapter/siege.rb

@@ -0,0 +1,341 @@
+
+
+module Stella
+  module Adapter
+
+    # SIEGE 
+    # Usage: siege [options]
+    #        siege [options] URL
+    #        siege -g URL
+    # Options:
+    #   -V, --version           VERSION, prints version number to screen.
+    #   -h, --help              HELP, prints this section.
+    #   -C, --config            CONFIGURATION, show the current configuration.
+    #   -v, --verbose           VERBOSE, prints notification to screen.
+    #   -g, --get               GET, pull down headers from the server and display HTTP
+    #                           transaction. Great for web application debugging.
+    #   -c, --concurrent=NUM    CONCURRENT users, default is 10
+    #   -u, --url="URL"         Deprecated. Set URL as the last argument.
+    #   -i, --internet          INTERNET user simulation, hits the URLs randomly.
+    #   -b, --benchmark         BENCHMARK, signifies no delay for time testing.
+    #   -t, --time=NUMm         TIME based testing where "m" is the modifier S, M, or H
+    #                           no space between NUM and "m", ex: --time=1H, one hour test.
+    #   -r, --reps=NUM          REPS, number of times to run the test, default is 25
+    #   -f, --file=FILE         FILE, change the configuration file to file.
+    #   -R, --rc=FILE           RC, change the siegerc file to file.  Overrides
+    #                           the SIEGERC environmental variable.
+    #   -l, --log               LOG, logs the transaction to PREFIX/var/siege.log
+    #   -m, --mark="text"       MARK, mark the log file with a string separator.
+    #   -d, --delay=NUM         Time DELAY, random delay between 1 and num designed
+    #                           to simulate human activity. Default value is 3
+    #   -H, --header="text"     Add a header to request (can be many)
+    #   -A, --user-agent="text" Sets User-Agent in request
+    class Siege < Stella::Adapter::Base
+      
+      attr_writer :reps, :concurrent, :version
+      attr_reader :user_agent
+      attr_accessor :help, :config, :verbose, :get, :log, :mark, :delay, :header
+      attr_accessor :rc, :file, :time, :benchmark, :internet
+      
+      def initialize(options={}, arguments=[])
+        
+        @name = 'siege'
+        @reps = 1
+        @concurrent = 1
+        @private_variables = ['private_variables', 'name', 'arguments', 'load_factor', 'working_directory', 'orig_logfile']
+        @load_factor = 1
+        
+        @rc = File.join(ENV['HOME'] || ENV['USERPROFILE'], '.siegerc')
+        
+        super(options, arguments)
+        
+        # Siege won't run unless there's a siegerc file. If the default one doesn't exist
+        # we need to call siege.config to create it. This should only happen once. 
+        # We use capture_output here so STDOUT and STDERR don't print to the screen. 
+        Stella::Util.capture_output("#{@name}.config") do 'nothing' end unless File.exists? @rc
+      end
+      
+      
+      
+      def error
+        (File.exists? stderr_path) ? FileUtil.read_file(stderr_path) : "Unknown error"
+      end
+      
+      def version
+        vsn = 0
+        Stella::Util.capture_output("#{@name} --version") do |stdout, stderr|
+           stderr.join.scan(/SIEGE (\d+?\.\d+)/) { |v| vsn = v[0] }
+        end
+        vsn
+      end
+      
+      # loadtest
+      #
+      # True or false: is the call to siege a load test? If it's a call to help or version or
+      # to display the config this with return false. It's no reason for someone to make this 
+      # call through Stella but it's here for goodness sake. 
+      def loadtest?
+        !@arguments.empty?  # The argument is a URI
+      end
+      
+      def ready?
+        @name && !instance_variables.empty? 
+      end
+      
+
+      # Before calling run
+      def before
+
+        # Keep a copy of the configuration file. 
+        copy_siegerc
+
+        # Keep a copy of the URLs file.
+        copy_urls_file if @file
+        
+        # TODO: Print message about neither --benchmark or --internet
+      end
+      def command
+        raise CommandNotReady.new(self.class.to_s) unless ready?
+
+        command = "#{@name} "
+
+        instance_variables.each do |name|
+          canon = name.tr('@', '')        # instance_variables returns '@name'
+          next if @private_variables.member?(canon)
+
+          # It's important that we take the value from the getter method
+          # because it applies the load factor. 
+          value = self.send(canon)
+          if (value.is_a? Array)
+            value.each { |el| command << "--#{canon.tr('_', '-')} #{EscapeUtil.shell_single_word(el.to_s)} " }
+          else
+            command << "--#{canon.tr('_', '-')} #{EscapeUtil.shell_single_word(value.to_s)} "
+          end
+
+        end
+
+        command << (@arguments.map { |uri| "'#{uri}'" }).join(' ') unless @arguments.empty?
+        command
+      end
+      
+      # After calling run
+      def after
+
+        update_orig_logfile if @orig_logfile
+
+      end
+
+
+      def process_arguments(arguments)
+        opts = OptionParser.new 
+        opts.on('-V', '--version') do |v| @version = v end
+        opts.on('-h', '--help') do |v| @help = v end
+        opts.on('-C', '--config') do |v| @config = v end
+        opts.on('-v', '--verbose') do |v| @verbose = v end
+        opts.on('-g', '--get') do |v| @get = v end
+        opts.on('-l', '--log') do |v| @log = v end
+        opts.on('-m S', '--mark=S', String) do |v| @mark = v end
+        opts.on('-d N', '--delay=N', Float) do |v| @delay = v end
+        opts.on('-H S', '--header=S', String) do |v| @header ||= []; @header << v end
+          
+        opts.on('-r N', '--reps=N', Integer) do |v| @reps = v.to_i end
+        opts.on('-c N', '--concurrent=N', Integer) do |v| @concurrent = v.to_i end
+        opts.on('-R S', '--rc=S', String) do |v| @rc = v end
+        opts.on('-f S', '--file=S', String) do |v| @file = v end
+        opts.on('-t S', '--time=S', String) do |v| @time = v end
+        opts.on('-b', '--benchmark') do |v| @benchmark = true;  end
+        opts.on('-i', '--internet') do |v| @internet = true; end
+        opts.on('-A S', '--user-agent=S', String) do |v| @user_agent ||= []; @user_agent << v end
+
+        
+        opts.on('-n N',Integer) do |v| 
+          Stella::LOGGER.error("-n is not a Siege parameter. You probably want -r.")
+          exit 1
+        end
+        
+        # parse! removes the options it finds.
+        # It also fails when it finds unknown switches (i.e. -X)
+        # Which should leave only the remaining arguments (URIs in this case)
+        opts.parse!(arguments)
+
+        unless @benchmark
+          Stella::LOGGER.warn('--benchmark (or -b) is not selected. Siege will include "think time" for all requests.') 
+        end
+                
+        self.arguments = arguments
+        
+      rescue OptionParser::InvalidOption => ex
+        # We want to replace this text so we grab just the name of the argument
+        badarg = ex.message.gsub('invalid option: ', '')
+        raise InvalidArgument.new(badarg)
+      end
+
+      
+      def add_header(name, value)
+        @header ||= []
+        @header << "#{name}: #{value}"
+      end
+      def user_agent=(list=[])
+        return unless list && !list.empty?
+        list = list.to_ary
+        @user_agent ||= []
+        @user_agent << list
+        @user_agent.flatten
+      end
+      
+      def vusers
+        concurrent || 0 
+      end
+      def vusers=(v)
+        @concurrent = v
+      end
+      def requests
+        (@reps * concurrent_f).to_i
+      end
+      def requests=(v)
+        @reps = (v / concurrent_f).to_i
+      end
+      def vuser_requests
+        @reps
+      end
+      
+      def concurrent
+        (@concurrent * @load_factor).to_i
+      end
+      def concurrent_f
+        (@concurrent * @load_factor).to_f
+      end
+      def reps
+        @reps
+      end
+      
+      
+      # Take the last line of the siege.log file and write it to the log file
+      # specified by the user. We don't this so running with Stella is 
+      # identical to running it standalone
+      def update_orig_logfile
+
+        return unless (@orig_logfile)
+        log_str = FileUtil.read_file_to_array(log_file) || ''
+        return if log_str.empty?
+
+        if File.exists?(@orig_logfile)
+          FileUtil.append_file(@orig_logfile, log_str[-1], true)
+        else  
+          FileUtil.write_file(@orig_logfile, log_str.join(''), true)
+        end
+
+      end
+
+      # We want to keep a copy of the configuration file and also
+      # modify it a little bit to make sure we get all the mad info from siege
+      def copy_siegerc
+
+        # Read in the siegerc file so we can manipulate it
+        siegerc_str = FileUtil.read_file(File.expand_path(@rc))
+
+        siegerc_vars = {
+          :verbose => [false, true],    # We want to maximize the data output by siege
+          :logging => [false, true], 
+          :csv => [false, true]
+        }
+
+        #if (@agent)
+        #  siegerc_vars['user-agent'] = ['.*', 'dogs2']
+        #end
+
+        # We'll set the variables in the siegerc file
+        siegerc_vars.each_pair do |var,value|
+          siegerc_str.gsub!(/#{var}\s*=\s*#{value[0]}/, "#{var} = #{value[1]}")  # make true
+          siegerc_str.gsub!(/^\#+\s*#{var}/, "#{var}")              # remove comment
+        end
+
+        # Look for the enabled logile path
+        # We will use this later to update it from the last line in our copy
+        siegerc_str =~ /^\s*logfile\s*=\s*(.+?)$/
+        @orig_logfile = $1 || nil
+
+        # Replace all environment variables with literal values
+        @orig_logfile.gsub!(/\$\{#{$1}\}/, ENV[$1]) while (@orig_logfile =~ /\$\{(.+?)\}/ && ENV.has_key?($1))
+
+        @orig_logfile = File.expand_path(@orig_logfile) if @orig_logfile
+        
+
+        siegerc_str.gsub!(/^\#*\s*logfile\s*=\s*.*?$/, "logfile = " + log_file)
+        
+        FileUtil.write_file(rc_file, siegerc_str, true)
+        @rc = rc_file
+      end
+
+      # We want to keep a copy of the URLs file too
+      def copy_urls_file
+        if @file
+          File.copy(File.expand_path(@file), uris_file) 
+          @file = uris_file
+        end
+      end
+
+      # Siege writes the summary to STDERR
+      def summary_file
+        File.new(stderr_path) if File.exists?(stderr_path)
+      end
+      
+      def rc_file
+        File.join(@working_directory, "siegerc")
+      end
+      
+      def log_file
+        File.join(@working_directory, "siege.log")
+      end
+      
+      def uris_file
+        File.join(@working_directory, File.basename(@file))
+      end
+          
+      def summary
+        return unless summary_file
+        raw = {}
+        summary_file.each_line { |l|
+          l.chomp!
+          nvpair = l.split(':')
+          next unless nvpair && nvpair.size == 2
+          n = nvpair[0].strip.tr(' ', '_').downcase[/\w+/]
+          v = nvpair[1].strip[/[\.\d]+/]
+          raw[n.to_sym] = v.to_f
+        }
+
+        stats = Stella::Test::Run::Summary.new
+        
+        # Transactions:		         750 hits
+        # Availability:		      100.00 %
+        # Elapsed time:		        2.33 secs
+        # Data transferred:	        0.07 MB
+        # Response time:		        0.21 secs
+        # Transaction rate:	      321.89 trans/sec
+        # Throughput:		        0.03 MB/sec
+        # Concurrency:		       67.49
+        # Successful transactions:         750
+        # Failed transactions:	           0
+        # Longest transaction:	        0.33
+        # Shortest transaction:	        0.10
+        
+        stats.vusers = raw[:concurrency]
+        stats.data_transferred = raw[:data_transferred]
+        stats.elapsed_time = raw[:elapsed_time]
+        stats.response_time = raw[:response_time]
+        stats.transactions = raw[:transactions].to_i
+        stats.transaction_rate = raw[:transaction_rate]
+        stats.failed = raw[:failed_transactions].to_i
+        stats.successful = raw[:successful_transactions].to_i
+        
+        #stats.shortest_transaction = raw[:shortest_transaction]
+        #stats.longest_transaction = raw[:longest_transaction]
+        
+        stats
+      end
+
+
+
+    end
+  end
+end

data/lib/stella/cli.rb

@@ -0,0 +1,258 @@
+
+# http://www.ruby-doc.org/stdlib/libdoc/observer/rdoc/index.html
+
+
+require 'stella/cli/base'
+
+module Stella
+  
+    
+  # Stella::CLI
+  #
+  # The is the front-end class for the command-line implementation. The stella script
+  # creates an instance of this class which is the glue between the command-line
+  # and the Stella command classes. 
+  # Note: All Stella::CLI classes are autoloaded and they add themselves to @@commands. 
+  class CLI
+    
+    # Auto populated with 'command' => Stella::CLI::[class] by each cli class on 'require'.
+    @@commands = {}
+    
+    attr_reader :command_name
+    attr_reader :options
+    attr_reader :logger
+    attr_reader :stella_arguments
+    attr_reader :command_arguments
+
+    
+    def initialize(arguments=[], stdin=nil)
+      @arguments = arguments
+      @stdin = stdin
+      
+      @options = OpenStruct.new
+      @options.verbose = 0
+      @options.data_path = 'stella'
+      @options.agents = []
+      
+      @stella_arguments = []
+      @command_arguments = []
+      
+      process_arguments
+      process_options
+      
+    end
+    
+    def commands
+      @@commands
+    end
+    
+    def run
+      
+      unless (@command_name)
+        process_options(:display)
+        exit 0
+      end
+          
+      # Pull the requested command object out of the list
+      # and tell it what shortname that was used to call it.
+      command = @@commands[@command_name].new(@command_name)
+      
+      # Give the command object access to the runtime options and arguments
+      command.stella_options = @options
+      command.arguments = @command_arguments
+      command.working_directory = @options.data_path
+      
+      command.run
+      
+    rescue => ex
+      Stella::LOGGER.error(ex)
+    end
+    
+    
+      protected
+        
+        
+        # process_arguments
+        #
+        # Split the arguments into stella args and command args
+        # i.e. stella -H push -f (-H is a stella arg, -f is a command arg)
+        # True if required arguments were provided
+        def process_arguments
+
+          @command_name = nil     
+          @arguments.each do |arg|
+            if (@@commands.has_key? arg)
+              @command_name = arg 
+              index = @arguments.index(@command_name)
+              @command_arguments = @arguments[index + 1..@arguments.size] 
+              @stella_arguments = @arguments[0..index - 1] if index > 0
+              break
+            end
+          end
+          
+          @stella_arguments = [] unless @stella_arguments
+          @command_arguments = [] unless @command_arguments 
+
+          # If there's no command we'll assume all the options are for Stella
+          unless @command_name
+            @stella_arguments = @arguments
+            @arguments = []
+          end
+
+        end
+
+        # process_options
+        #
+        # Handle the command-line options for stella. Note: The command specific
+        # options are handled by the command/*.rb classes
+        # display:: When true, it'll print out the options and not parse the arguments
+        def process_options(display=false)
+
+          opts = OptionParser.new 
+          opts.banner = Stella::TEXT.msg(:option_help_usage)
+          opts.on Stella::TEXT.msg(:option_help_preamble, @@commands.keys.sort.join(', '))
+
+          opts.on(Stella::TEXT.msg(:option_help_options_title))
+          opts.on('-V', '--version', Stella::TEXT.msg(:option_help_version)) do
+            output_version
+            exit 0
+          end
+          opts.on('-h', '--help', Stella::TEXT.msg(:option_help_help)) { puts opts; exit 0 }
+          opts.on('-F', '--force', Stella::TEXT.msg(:option_help_force)) { |v| @options.force = true }
+
+          opts.on('-v', '--verbose', Stella::TEXT.msg(:option_help_verbose)) do
+            
+            @options.verbose ||= 0
+            @options.verbose += 1 
+          end
+          opts.on('-q', '--quiet', Stella::TEXT.msg(:option_help_quiet))   do
+            @options.quiet = true 
+          end
+          
+          # Overhead is interesting for development and auditing but we're not
+          # currently tracking this. It needed to be re-implemented from scratch
+          # so we'll redo this soon. It's also useful for comparing Ruby/JRuby/IronRuby
+          #opts.on('--overhead', String, Stella::TEXT.msg(:option_help_overhead)) do
+          #  @options.showoverhead = true 
+          #end
+          
+          opts.on('-O', '--stdout', Stella::TEXT.msg(:option_help_stdout)) do
+            @options.stdout = true 
+          end
+          opts.on('-E', '--stderr', Stella::TEXT.msg(:option_help_stderr)) do
+            @options.stdout = true 
+          end
+          
+          opts.on('-m', '--message=M', String, Stella::TEXT.msg(:option_help_message)) do |v| 
+            @options.message = v.to_s 
+          end
+          opts.on('-s', '--sleep=N', Float, Stella::TEXT.msg(:option_help_sleep)) do |v|
+            @options.sleep = v.to_f 
+          end
+
+          # Ramp up, establish default and enforce limits
+          opts.on('-r [R,U]', '--rampup', String, Stella::TEXT.msg(:option_help_rampup)) do |v| 
+            amount = (v) ? Stella::Util::expand_str(v) : [10,100]
+            amount[0] = MathUtil.enforce_limit(amount[0].to_i, 1, 100)
+            amount[1] = MathUtil.enforce_limit((amount[1]) ? amount[1].to_i : 0, (amount[0]*2), 1000)
+            @options.rampup = amount
+          end
+
+          opts.on('-x', '--repetitions=N', Integer, Stella::TEXT.msg(:option_help_testreps)) do |v| 
+            @options.repetitions = MathUtil.enforce_limit(v,1,99)
+          end
+
+          opts.on('-w [N]', '--warmup', Float, Stella::TEXT.msg(:option_help_warmup, 0.1)) do |v|
+            @options.warmup = MathUtil.enforce_limit(((v) ? v : 0), 0.1, 1)
+          end
+
+          opts.on('-a', '--agent=[S]', String, Stella::TEXT.msg(:option_help_agent)) do |v| 
+            @options.agents ||= []
+            agent_ary = Stella::Util::expand_str(v || 'random')
+            @options.agents.push(agent_ary)
+          end
+ 
+          opts.on('-d', '--datapath=S', String, Stella::TEXT.msg(:option_help_datapath, ".#{File::SEPARATOR}stella")) do |v| 
+            @options.data_path = v.to_s 
+          end
+          opts.on('-f', '--format=S', String, Stella::TEXT.msg(:option_help_format)) do |v| 
+            @options.format = v.to_s 
+          end
+          
+          # This is used for printing the help from other parts of this class
+          if display
+            Stella::LOGGER.info opts
+            return
+          end
+
+          # This applies the configuration above to the arguments provided. 
+          # It also removes the discovered options from @stella_arguments
+          # leaving only the unnamed arguments. 
+          opts.parse!(@stella_arguments)
+
+          # Quiet supercedes verbose
+          @options.verbose = 0 if @options.quiet
+          
+          
+          # This outputs when debugging is enabled. 
+          dump_inputs
+          
+          
+        rescue OptionParser::InvalidOption => ex
+          # We want to replace this text so we grab just the name of the argument
+          badarg = ex.message.gsub('invalid option: ', '')
+          raise InvalidArgument.new(badarg)
+        end
+
+        #
+        # Process data sent to STDIN (a pipe for example). 
+        # We assume each line is a URI and add it to @arguments.
+        def process_standard_input
+          return if @stdin.tty?   # We only want piped data
+
+          while !@stdin.eof? do
+            line = @stdin.readline
+            line.chomp!
+            @arguments << line
+          end
+
+        end
+        
+        def output_version
+          Stella::LOGGER.info(:cli_print_version, Stella::VERSION.to_s)
+        end
+        
+        def dump_inputs
+
+          #ENV.each_pair do |n,v|
+          #  Stella::LOGGER.debug("ENV[#{n}]=#{v}")
+          #end
+
+          Stella::LOGGER.debug("Commands (#{@command_name}): #{@@commands.keys.join(',')}")
+
+          
+          Stella::LOGGER.debug("Options: ")
+          @options.marshal_dump.each_pair do |n,v|
+            v = [v] unless v.is_a? Array
+            Stella::LOGGER.debug("  #{n} = #{v.join(',')}")
+          end
+
+          Stella::LOGGER.debug("Stella Arguments: #{@stella_arguments.join(',')}")
+          Stella::LOGGER.debug("Command Arguments: #{@command_arguments.join(',')}" )
+        end
+  end
+end
+
+# Autoload CLI classes. These classes add themselves to the class variable @@commands. 
+begin
+  previous_path = ""
+  cli_classes = Dir.glob(File.join(STELLA_HOME, 'lib', 'stella', 'cli', "*.rb"))
+  cli_classes.each do |path|
+    previous_path = path
+    require path
+  end
+rescue LoadError => ex
+  Stella::LOGGER.info("Error loading #{previous_path}: #{ex.message}")
+end
+
+