solutious-stella 0.5.5 → 0.6.0

data/lib/stella/adapter/proxy_watcher.rb

@@ -1,76 +0,0 @@
-
-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

@@ -1,341 +0,0 @@
-
-
-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

@@ -1,258 +0,0 @@
-
-# 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
-
-