stella 0.3.2

data/lib/stella/cli.rb

@@ -0,0 +1,291 @@
+
+require 'optparse'
+require 'ostruct'
+
+require 'stella/cli/base'
+
+module Stella
+  
+  # Stella::Config
+  #
+  # This Config class manages the content of ENV['HOME]/.stella. The functionality 
+  # is currently disabled so stella is stateless. 
+  class Config < Storable
+    DEFAULT_HOME = File.join(ENV['HOME'], '.stella').freeze unless defined? DEFAULT_HOME
+    DEFAULT_DATA_HOME = File.join(Dir.getwd, 'stella').freeze unless defined? DEFAULT_DATA_HOME
+    
+    attr_accessor :conf_path, :data_path
+    attr_accessor :agents
+    
+    def initialize(args={:conf_path => DEFAULT_HOME})
+      
+    end
+    
+    def working_directory
+      'stella'
+    end
+    
+    # Copy the default useragents file to the config directory. 
+    #unless File.exists? uafile_path
+    #  default_uafile = File.join(STELLA_HOME, 'support', 'useragents.txt')
+    #  STDERR.puts "There's no useragents.txt file. Supplied agents will be ignored" unless File.exists?(default_uafile)
+    #  File.copy(default_uafile, @config.uafile_path, true)
+    #end
+    
+    #def load
+    #    puts self.methods
+    #  loaded_config = Config.undump('yaml', FileUtil.read_file_to_array(@config_filepath))
+    #  current_config = @config.marshal_dump
+    #  current_config.merge! loaded_config if loaded_config.is_a? Hash
+    #
+    #  @config = OpenStruct.new(current_config)
+    #end
+      
+  end
+    
+  # 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 :options
+    attr_reader :logger
+    
+
+    
+    def initialize(arguments=[], stdin=nil)
+      @arguments = arguments
+      @stdin = stdin
+      
+      @config = Stella::Config.new
+      @options = OpenStruct.new
+      @options.verbose = 0
+      @options.data_path = @config.working_directory
+      @options.agents = []
+      
+    end
+    
+    def commands
+      @@commands
+    end
+    
+    def run
+      process_arguments
+      process_options
+      
+      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 config and runtime options
+      #command.global_config = @config 
+      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
+
+          @command_arguments = [] if @command_arguments.nil? 
+          @stella_arguments = [] if @stella_arguments.nil?
+
+          # 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.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('-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', '--testreps=N', Integer, Stella::TEXT.msg(:option_help_testreps)) do |v| 
+            @options.testreps = MathUtil.enforce_limit(v,1,10)
+          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
+
+          # The following options are considered "repeatable" so they're stored in 
+          # the config file and used as defaults for the next run. 
+          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("Configs: ")
+          #@config.to_hash.each_pair do |n,v|
+          #  Stella::LOGGER.debug("  #{n}=#{v}")
+          #end
+          
+          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
+  cli_classes = Dir.glob(File.join(STELLA_HOME, 'lib', 'stella', 'cli', "*.rb"))
+  cli_classes.each do |path|
+    require path
+  end
+rescue LoadError => ex
+  Stella::LOGGER.info("Error loading #{path}: #{ex.message}")
+end

data/lib/stella/cli/agents.rb

@@ -0,0 +1,73 @@
+
+
+
+module Stella 
+  class CLI
+    
+    class Agents < Stella::CLI::Base
+      
+      attr_accessor :full
+      attr_accessor :list
+      attr_accessor :search
+      attr_accessor :help
+      
+      def initialize(adapter)
+        super(adapter)
+        @full = false
+        @list = false
+        @help = false
+      end
+      
+      def run
+        process_options
+        
+        if @help
+          process_options(:display)
+          return
+        end
+        
+        # The LocalTest command is the keeper of the user agents
+        localtest = Stella::LocalTest.new
+        
+        agents = []
+        all_agents = localtest.available_agents
+        all_agents.each_pair do |key,value|
+          if (@full) 
+            value.each do |full_value|
+              agent = full_value.join(' ')
+              agents << agent if (!@search || agent.to_s.match(/#{search}/i))
+            end
+          else
+            agents << key.to_s if (!@search || key.to_s.match(/#{search}/i))
+          end
+        end
+ 
+        puts (@list) ? agents.uniq.sort.join("\n") : Stella::TEXT.msg(:agents_count_message, agents.uniq.size)
+
+      end
+      
+      def process_options(display=false)
+
+        opts = OptionParser.new
+        opts.banner = Stella::TEXT.msg(:option_help_usage)
+        opts.on('-h', '--help', Stella::TEXT.msg(:option_help_help)) { @help = true }
+        opts.on('-f', '--full', Stella::TEXT.msg(:agents_option_full)) { @full = true }
+        opts.on('-l', '--list', Stella::TEXT.msg(:agents_option_list)) { @list = true }
+        # TODO: display agents based on shortnames. This is important to maintain continuity with the stella option. 
+        #opts.on('-a', '--agent', Stella::TEXT.msg(:agents_option_list)) { @list = true } 
+        opts.on('-s', '--search=S', String, Stella::TEXT.msg(:agents_option_search)) { |v| @search = v }
+        
+        opts.parse!(@arguments)
+        
+        if display
+          Stella::LOGGER.info opts
+          return
+        end
+        
+      end
+      
+    end
+    
+    @@commands['agents'] = Stella::CLI::Agents
+  end
+end

data/lib/stella/cli/base.rb

@@ -0,0 +1,19 @@
+module Stella
+  class CLI
+    # Stella::CLI::Base
+    #
+    # A base case for the command line interface classes. All Stella::CLI 
+    # classes should be based on this class. Otherwise great destruction could occur.
+    class Base
+      attr_reader :adapter
+      attr_accessor :stella_options
+      attr_accessor :arguments
+      attr_accessor :working_directory
+      
+      def initialize(adapter)
+        @adapter_name = adapter
+        @options = OpenStruct.new
+      end
+    end
+  end
+end

data/lib/stella/cli/language.rb

@@ -0,0 +1,18 @@
+
+
+
+module Stella 
+  class CLI
+    class Language < Stella::CLI::Base
+      
+      
+      def run
+        languages = Stella::TEXT.available_languages 
+        puts Stella::TEXT.msg(:text_available_languages, languages.map { |l| "#{l[:language]} " })
+      end
+      
+    end
+    
+    @@commands['lang'] = Stella::CLI::Language
+  end
+end

data/lib/stella/cli/localtest.rb

@@ -0,0 +1,80 @@
+
+
+module Stella
+  class CLI
+    # Stella::CLI::LocalTest
+    #
+    # A wrapper that takes the command line input and makes it appropriate for 
+    # calling an instance of Stella::LocalTest. Then it calls that instance!
+    class LocalTest < Stella::CLI::Base
+      
+      attr_reader :testdef
+      
+      def initialize(adapter)
+        super(adapter)
+        @testdef = Stella::Test::Definition.new
+        
+        if (adapter == 'ab')
+          @adapter = Stella::Adapter::ApacheBench.new
+        elsif (adapter == 'siege')
+          @adapter = Stella::Adapter::Siege.new
+        elsif (adapter == 'httperf')
+          @adapter = Stella::Adapter::Httperf.new
+        else
+          raise UnknownValue.new(adapter)
+        end
+        
+        @driver = Stella::LocalTest.new
+      end
+      
+
+      def run
+        process_stella_options
+        
+        options = @adapter.process_options(@arguments)
+        
+        @adapter.options = options
+        @adapter.arguments = @arguments
+        
+        @testdef.vusers = @adapter.vusers
+        @testdef.requests = @adapter.requests
+        
+        @driver.adapter = @adapter
+        @driver.testdef = @testdef
+        
+        @driver.working_directory = @working_directory
+        
+        @driver.run
+        
+      end
+
+
+      
+      # process_stella_options
+      # 
+      # Populates @testdef with values from @stella_options
+      def process_stella_options
+        @testdef.repetitions = @stella_options.testreps
+        @testdef.sleep = @stella_options.sleep
+        @testdef.warmup = @stella_options.warmup
+        @testdef.rampup = @stella_options.rampup
+        @testdef.agents = @stella_options.agents
+        @testdef.message = @stella_options.message
+        
+        
+        @driver.quiet = @stella_options.quiet
+        @driver.verbose = @stella_options.verbose
+        @driver.format = @stella_options.format || 'yaml'
+        
+      end
+      
+
+      
+    end
+  
+    
+    @@commands['ab'] = Stella::CLI::LocalTest
+    @@commands['siege'] = Stella::CLI::LocalTest
+    @@commands['httperf'] = Stella::CLI::LocalTest
+  end
+end