stella 0.3.2

data/lib/stella/command/base.rb

@@ -0,0 +1,111 @@
+
+
+module Stella::Command
+  class Base
+    
+    BrowserNicks = {
+      'ff' => 'firefox',
+      'ie' => 'internetexplorer'
+    }.freeze unless defined? BrowserNicks
+
+    OperatingSystemNicks = {
+      'win' => 'windows',
+      'lin' => 'linux',
+      'osx' => 'osx',
+      'freebsd' => 'bsd',
+      'netbsd' => 'bsd',
+      'openbsd' => 'bsd'
+    }.freeze unless defined? OperatingSystemNicks
+    
+    # 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
+
+    end
+    
+    def run_sleeper(duration)
+      remainder = duration % 1 
+      duration.to_i.times {
+        Stella::LOGGER.info_print('.') unless @quiet
+        sleep 1
+      }
+      sleep remainder if remainder > 0
+    end
+    
+    # find_agent
+    #
+    # Takes an input string which can be either a shortname or a complete
+    # user agent string. If the string matches the shortname format, it
+    # will select an agent string from useragents.txt based on the shortname.
+    # Shortname takes the following format: browser-version-os. 
+    # Examples: ff-3-linux, ie-5, opera-10-win, chrome-0.2-osx, random
+    # If os doesn't match, it will look for the browser and version. If it can't
+    # find the version it will look for the browser and apply the version given. 
+    # If browser doesn't match a known browser, it assumes the string is a 
+    # complete user agent and simply returns that value. 
+    def find_agent(name,second=nil,third=nil)
+      name = (BrowserNicks.has_key?(name)) ? BrowserNicks[name] : name
+      return name unless @available_agents.has_key?(name) || name == "random"
+
+      index = name
+      if (second && third)                # i.e. opera-9-osx
+        os = (OperatingSystemNicks.has_key?(third)) ? OperatingSystemNicks[third] : third
+        index = "#{name}-#{second}-#{os}"
+      elsif(second && second.to_i > 0)    # i.e. opera-9
+        index = "#{name}-#{second}"
+      elsif(second)                       # i.e. opera-osx
+        os = (OperatingSystemNicks.has_key?(second)) ? OperatingSystemNicks[second] : second
+        index = "#{name}-#{os}"
+      elsif(name == "random")
+        index = @available_agents.keys[ rand(@available_agents.keys.size) ]
+      end
+
+      # Attempt to find a pool of user agents that match the supplied index
+      ua_pool = @available_agents[index]
+
+      # In the event we don't find an agent above (which will only happen
+      # when the user provided a version), we'll take a random agent for 
+      # the same browser and apply the version supplied by the user. We 
+      # create the index using just the major version number so if the user
+      # supplies a specific verswion number, they will always end up here.
+      unless ua_pool
+        os = (OperatingSystemNicks.has_key?(third)) ? OperatingSystemNicks[third] : third
+        index = (os) ? "#{name}-#{os}" : name
+        ua_tmp = @available_agents[index][ rand(@available_agents[index].size) ]
+        ua_tmp.version = second if second.to_i > 0
+        ua_pool = [ua_tmp]
+      end
+
+      ua = ua_pool[ rand(ua_pool.size) ]
+
+      ua.to_s
+
+    end
+
+
+    # 
+    # Generates a string of random alphanumeric characters
+    # These are used as IDs throughout the system
+    def strand( len )
+       chars = ("a".."z").to_a + ("0".."9").to_a
+       newpass = ""
+       1.upto(len) { |i| newpass << chars[rand(chars.size-1)] }
+       return newpass
+    end
+  end
+end

data/lib/stella/command/localtest.rb

@@ -0,0 +1,339 @@
+
+
+module Stella
+  class LocalTest < Stella::Command::Base
+    
+    
+    
+      # A container for the test parameters
+    attr_accessor :testdef
+      # The load tool adapter
+    attr_accessor :adapter
+    
+    attr_accessor :test_path
+    
+    attr_accessor :quiet
+    attr_accessor :guid
+    attr_accessor :verbose
+    attr_accessor :format
+    
+      # list of all filesystem paths for each run in a single test
+    attr_reader :test_runpaths
+      # same as above, expect for all tests
+    attr_reader :all_runpaths
+      # list of all hostname:port in the test
+    attr_reader :hosts
+      # list of all /paths in the test
+    attr_reader :paths
+    
+    attr_accessor :working_directory
+    attr_reader :available_agents
+    
+    def initialize(testdef=nil, adapter=nil)
+      @testdef = testdef if testdef
+      @adapter = adapter if adapter
+      
+      @guid = Crypto.sign(rand.to_s, rand.to_s)
+      
+      @test_runpaths = []       
+      @all_runpaths = []        
+      @hosts = []               
+      @paths = []
+      @format = 'yaml'
+      @agents = []
+      
+      @available_agents = index_available_agents(File.join(STELLA_HOME, 'support', 'useragents.txt'))
+    end
+    
+    def index_available_agents(path)
+      Stella::LOGGER.debug("LOADING #{path}")
+      return [] unless File.exists?(path)
+      Stella::Util.process_useragents(FileUtil.read_file_to_array(path))
+    end
+    
+    def translate_requested_agents(possible_agents=[])
+      agents = []
+      possible_agents.each do |a|
+        agents << find_agent(*a)
+      end
+      agents
+    end
+    
+    def run
+      
+      
+      raise UnavailableAdapter.new(@adapter.name) unless @adapter.available?
+      
+      unless @adapter.loadtest?
+        system(@adapter.command)
+
+        return
+      end
+            
+      @agents = translate_requested_agents(@testdef.agents)
+      
+      test_path = _generate_test_path
+      
+      prepare_test(test_path)       
+      
+        threshold = (@testdef.rampup) ? @testdef.rampup.ceiling : @adapter.vusers
+        
+        runnum = "00"
+        while(@adapter.vusers <= threshold) do
+          
+          # Make sure the load factor is set to 1. If there was a warmup, 
+          # then this value will be less than 1.
+          testrun = maker_of_testruns(1)
+          
+          # We empty test_runpaths so we can keep track of the runpaths for each
+          # level of virtual users. This is useful during a rampup test so we can
+          # collect the stats for the repetitions at each virtual user level. 
+          @test_runpaths = []
+          
+          # Execute each test run in turn. All of the steps are the same for each
+          # run. This is important because the purpose of the test runs is to 
+          # create a statistical certainty of performance. 
+          @testdef.repetitions.times do 
+            
+            # This value is used to create the run directory and show which run we're on
+            runnum.succ!
+            
+            # Generate the filesystem path to store the run data.
+            runpath = File.join(test_path, "run#{runnum}")
+
+            # Keep track of every run path. We use this in postpare to 
+            # do some stuff after all the tests have run
+            @all_runpaths << runpath
+            
+            # test_runpaths will be identical to all_runpaths except when there is a
+            # rampup. In that case, test_runpaths will contain the runpaths for all
+            # repetitions of each level of virtual users. 
+            @test_runpaths << runpath
+            
+            testrun.call("Run #{runnum}", runpath)
+            
+            # Only sleep if requested and there is more than 1 test run
+            if @testdef.sleep && @testdef.sleep.to_f > 0 && @testdef.repetitions > 1 
+              run_sleeper(@testdef.sleep)
+            end
+            Stella::LOGGER.info('') unless @quiet # We want the newline
+          end
+          
+          # Rampup tests produce multiple summary files which include the batch
+          # number. Regular runs have just one file we set here as the default. 
+          summary_name = "SUMMARY"
+        
+          # It's possible for the interval to not divide evenly into the ceiling
+          # If we have room between the current number of virtual users and the
+          # ceiling, we'll add the difference for the final test run. 
+          if (@testdef.rampup)
+            final_total = @adapter.vusers + @testdef.rampup.interval
+            if final_total > threshold && (threshold - @adapter.vusers) > 0
+              @adapter.vusers += (threshold - @adapter.vusers)
+            else
+              @adapter.vusers += @testdef.rampup.interval
+            end
+            padded_users = @adapter.vusers.to_s.rjust(4, '0')
+            summary_name = "SUMMARY-#{padded_users}"
+          end
+        
+          # Read the run summaries for this batch and produce totals, averages, 
+          # and standard deviations.
+          test_stats = process_test_stats(@test_runpaths)
+          print_summary(test_stats) if (@testdef.repetitions > 1)
+          save_summary(File.join(test_path, "#{summary_name}.#{@format}"), test_stats)
+          
+          
+          # Non-rampup tests only need to run through the loop once. 
+          break if (!@testdef.rampup && @adapter.vusers == threshold)
+        
+      end
+
+      if @testdef.rampup
+        # Notice the difference between these test stats and the ones above?
+        # These stats are based on the entire rampup test, across all levels
+        # of virtual users.
+        test_stats = process_test_stats(@all_runpaths)
+        save_summary(File.join(test_path, "SUMMARY-RAMPUP.#{@format}"), test_stats)
+        print_summary(test_stats) if (@testdef.repetitions > 1)
+      end
+    end
+    
+    def latest_test_symlink_path
+      return unless @working_directory
+      File.join(@working_directory, 'latest') 
+    end
+    
+    private
+      
+      # prepare_test
+      #
+      # Execute the group of testruns associated to this test. This includes
+      # zero or one warmup and one or more testruns. 
+      #
+      # INPUT:
+      # +test_path+ filesystem path to store all test data
+      #
+      def prepare_test(test_path)
+
+        Stella::LOGGER.info("Writing test data to: #{test_path}\n\n") unless @quiet
+
+        # Make sure the test storage directory is created along with the
+        # latest symlink
+        FileUtil.create_dir(test_path)
+        File.unlink(latest_test_symlink_path) if File.exists?(latest_test_symlink_path)
+        File.symlink(File.expand_path(test_path), latest_test_symlink_path)
+        
+        # Write the test ID to the storage directory
+        FileUtil.write_file(test_path + "/ID.txt", @guid, true)
+
+        # And the test run message
+        FileUtil.write_file(test_path + "/MESSAGE.txt", @testdef.message, true) if @testdef.message
+
+        @adapter.user_agent = @agents unless @agents.empty?
+
+        # The warmup is identical to a testrun except for two things:
+        # - we don't make note of the runpath
+        # - there is a one second sleep after the run. 
+        # Everything else is identical. 
+        if @testdef.warmup
+
+          testrun = maker_of_testruns(@testdef.warmup)
+
+          # Generate the filesystem path to store the run data.
+          # NOTE: We don't keep the warmup path in @test_runpaths because we
+          # include it in the final calculation for the test. 
+          runpath = File.join(test_path, "warmup")
+
+          # Run the warmpup round
+          testrun.call("Warmup", runpath)
+
+          run_sleeper(@testdef.sleep || 1)
+          
+          Stella::LOGGER.info('', '') unless @quiet # We just need the newline
+          
+        end
+        
+        print_title unless @quiet
+
+      end
+        
+      # maker_of_testruns
+      #
+      # Generator of test runs. Everything that happens during a test
+      # run is defined here. We use a Proc so we can toss the functionality
+      # around like something that's dirty and loves a good tossing. 
+      # It's important that all output be on a single line without a
+      # line terminator. Otherwise great descruction could occur.  
+      def maker_of_testruns(factor)
+        testrun = Proc.new do |name,runpath|
+          # Make sure the test run storage directory is created
+          FileUtil.create_dir(runpath)
+        
+          @adapter.load_factor = factor
+          @adapter.working_directory = runpath
+          @adapter.before
+          
+          Stella::LOGGER.info_printf("%8s: %10d@%-6s ", name, @adapter.requests, @adapter.vuser_rate) unless @quiet
+        
+          # Here we record the command arguments. This needs to be last because we modify 
+          # some of the arguments above.
+          FileUtil.write_file(runpath + "/COMMAND.txt", @adapter.command, true)
+        
+          # Execute the command, send STDOUT and STDERR to separate files. 
+          command = "#{@adapter.command} 1> '#{@adapter.stdout_path}' 2> '#{@adapter.stderr_path}'"
+          Stella::LOGGER.info(" COMMAND: #{command}") if @verbose >= 2
+        
+          # Call the load tool
+          # for Windows, see: http://blog.crankybit.com/redirecting-output-to-a-file-in-windows-batch-scripts/
+          #                   http://weblogs.asp.net/lorenh/archive/2006/03/24/441004.aspx
+          system(command)
+        
+          stats = @adapter.stats
+      
+          save_summary(@adapter.summary_path(@format), stats)
+      
+
+          unless @quiet
+            Stella::LOGGER.info_print(sprintf("%3.0f%% %9.2f/s %8.3fs ", stats.availability, stats.transaction_rate, stats.response_time))
+            Stella::LOGGER.info_print(sprintf("%8.3fMB/s %8.3fMB %8.3fs  ", stats.throughput, stats.data_transferred, stats.elapsed_time))
+            # NOTE: We don't print a line terminator here
+          end
+          
+        end
+      end
+    
+    
+      # print_summary
+      #
+      # Called during the test after every batch of test runs. For a rampup test
+      # it's also called at the end of all the runs.  
+      #
+      # INPUT:
+      # stats:: Any object that extends Stella::Test::Base object
+      def print_summary(stats)
+        Stella::LOGGER.info(' ' << "-"*67) unless @quiet
+
+        Stella::LOGGER.info_printf("%8s: %10d@%-6d% 3.0f%% %9.2f/s ", "Total", stats.transactions_total, stats.vusers_avg, stats.availability, stats.transaction_rate_avg)
+        Stella::LOGGER.info_printf("%8.3fs %8.3fMB/s %8.3fMB %8.3fs", stats.response_time_avg, stats.throughput_avg, stats.data_transferred_total, stats.elapsed_time_total)
+        Stella::LOGGER.info('') # New line
+        Stella::LOGGER.info_printf("%8s: %22s %9.2f/s %8.3fs %8.3fMB/s %10s %8.3fs", "Std Dev", '', stats.transaction_rate_sdev, stats.response_time_sdev, stats.throughput_sdev, '', stats.elapsed_time_sdev)
+        Stella::LOGGER.info('') # New line
+        Stella::LOGGER.info('') unless @quiet # Extra new line
+      end
+      
+      # print_title
+      #
+      # Prints the column headers for the test run output. Field widths match those 
+      # in print_summary and test_maker
+      def print_title
+        Stella::LOGGER.info(' ' << "-"*67) unless @quiet
+
+        Stella::LOGGER.info_printf("%8s  %10s@%-5s %5s %11s", "", 'REQ', 'VU/s', 'AVAIL', 'REQ/s')
+        Stella::LOGGER.info_printf("%10s %12s %10s %9s", 'RTIME', 'DATA/s', 'DATA', 'TIME')
+        Stella::LOGGER.info('') # New line
+        Stella::LOGGER.info('') unless @quiet # Extra new line
+      end
+      
+      # save_summary
+      #
+      # Write a summary object to disk
+      # 
+      # INPUT:
+      # filepath:: the complete path for the file (string)
+      # stats:: Any object that extends Stella::Test::Base object
+      def save_summary(filepath, stats)
+        FileUtil.write_file(filepath, stats.dump(@format, :with_titles), true)
+      end
+      
+      # Load SUMMARY file for each run and create a summary with
+      # totals, averages, and standard deviations. 
+      def process_test_stats(paths)
+        test_stats = Stella::Test::Summary.new(@message)
+        all_stats_obj = []
+        paths.each do |path|
+          file_contents = FileUtil.read_file_to_array("#{path}/SUMMARY.#{@format}")
+          stats = Stella::Test::Run::Summary.undump(@format, file_contents)
+          stats_obj = Stella::Test::Run::Summary.from_hash(stats)
+          test_stats.add_run(stats_obj)
+        end
+
+        test_stats
+      end
+      
+      # This is the path where all test data will be stored
+      # The default is testruns/2008-12-31/test-001
+      def _generate_test_path
+        now = DateTime.now
+        time = Time.now
+        daystr = "#{now.year}-#{now.mon.to_s.rjust(2,'0')}-#{now.mday.to_s.rjust(2,'0')}"
+        testpath = File.join(@working_directory, 'testruns', daystr, 'test-')
+        testnum = 1.to_s.rjust(3,'0')
+        testnum.succ! while(File.directory? "#{testpath}#{testnum}")
+        "#{testpath}#{testnum}"
+      end
+
+      
+  end
+end
+