solutious-stella 0.5.5

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
+ 
+        msg = (@list) ? agents.uniq.sort.join("\n") : Stella::TEXT.msg(:agents_count_message, agents.uniq.size)
+        puts msg
+      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,55 @@
+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
+        
+        # There is a bug in Ruby 1.8.6 where a trapped SIGINT will hang. 
+        # This workaround is from: http://redmine.ruby-lang.org/issues/show/362 
+        # It works in Ruby 1.9 and JRuby as well. 
+        # NEW WARNING: This puts the process into a new thread which somehow 
+        # prevents Pcap from reporting on UDP/DNS packets (TCP/HTTP is unaffected).
+        # I left this here as an example of how not to it. Incidentally, 
+        # "rescue Interrupt" seems to be working fine now. 
+        # See also: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/220937
+        #@killer = Thread.new do
+        #  puts "#{$/}Exiting...#{$/}"
+        #  Thread.stop
+        #  Thread.main.join(1)
+        #  exit 0
+        #end
+        #
+        # Note that this is just a default. Any class that implements another
+        # Signal.trap will override this.
+        #Signal.trap('INT') do
+        #  @killer.call
+        #  exit 0
+        #end
+      end
+    end
+  end
+end
+
+__END__
+
+TODO: Investigate frylock style definition
+include Stella::CLI::Base
+
+before do
+  # stuff that would go in initialize
+end
+
+command 'sysinfo' do
+  puts Stella::SYSINFO.to_yaml(:headers)
+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,78 @@
+
+
+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
+        
+        @adapter.process_arguments(@arguments)
+
+        @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.repetitions
+        @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

data/lib/stella/cli/sysinfo.rb

@@ -0,0 +1,16 @@
+
+module Stella 
+  class CLI
+    class SystemInfo < Stella::CLI::Base
+      
+      
+      def run
+        puts Stella::SYSINFO
+      end
+      
+    end
+    
+    @@commands['sysinfo'] = Stella::CLI::SystemInfo
+  end
+end
+

data/lib/stella/cli/watch.rb

@@ -0,0 +1,278 @@
+
+# TODO: Record cookies. 
+# TODO: Investigate packetfu: http://code.google.com/p/packetfu/
+# TODO: Investigate Winpcap (http://www.winpcap.org/) and libpcap on Windows 
+
+module Stella 
+  class CLI
+    class Watch < Stella::CLI::Base
+      
+
+      def run
+        @options = process_arguments(@arguments)
+        
+        if can_pcap?(@options[:usepcap]) 
+          require 'stella/adapter/pcap_watcher'
+          @watcher = Stella::Adapter::PcapWatcher.new(@options)
+ 
+        else
+          require 'stella/adapter/proxy_watcher'
+          @watcher = Stella::Adapter::ProxyWatcher.new(@options)
+          
+          # if can_pcap? returned false, but pcap was requested then we'll
+          # call check_pcap to raise the reason why it didn't load. 
+          if @options[:usepcap]
+            check_pcap
+            exit 0
+          end
+        end
+        
+        # We use an observer model so the watcher class will notify us
+        # when they have new data. They call the update method below. 
+        @watcher.add_observer(self)
+        
+        if @options[:record]
+          
+          @record_filepath = generate_record_filepath 
+          Stella::LOGGER.info("Writing to #{@record_filepath}")
+        
+          if File.exists?(@record_filepath) 
+            Stella::LOGGER.error("#{@record_filepath} exists")
+            if @stella_options.force
+              Stella::LOGGER.error("But I'll overwrite it and continue because you forced me too!")
+            else
+              exit 1
+            end
+          end
+          
+        end
+        
+        Stella::LOGGER.info("Filter: #{@options[:filter]}") if @options[:filter]
+        Stella::LOGGER.info("Domain: #{@options[:domain]}") if @options[:domain]
+        
+        # Turn wildcards into regular expressions
+        @options[:filter].gsub!('*', '.*') if @options[:filter] 
+        @options[:domain].gsub!('*', '.*') if @options[:domain]
+        
+        # Used to calculated user think times for session output
+        @think_time = 0
+        
+        @watcher.run
+        
+      end
+      
+
+      
+      # update
+      #
+      # This method is called from the watcher class when data is updated. 
+      # +service+ is one of: domain, http_request, http_response
+      # +data+ is a string of TCP packet data. The format depends on the value of +service+.
+      def update(service, data_object)
+        
+        begin
+          if @options[:record] && !@file_created_already
+        
+            if File.exists?(@record_filepath) 
+              if @stella_options.force
+  		          @record_file = FileUtil.create_file(@record_filepath, 'w', '.', :force)
+              else
+                exit 1
+              end
+            else
+  		        @record_file = FileUtil.create_file(@record_filepath, 'w', '.')
+            end
+	        
+  	        raise StellaError.new("Cannot open: #{@record_filepath}") unless @record_file
+
+            @file_created_already = true
+          end
+        rescue => ex
+          raise StellaError.new("Error creating file: #{ex.message}")
+        end
+        
+        # TODO: combine requests and responses
+        # Disabled until we have a way to combine request and response objects (otherwise
+        # the requests are filters out but the responses are not).
+        #return if @options[:filter] && !(data_object.raw_data.to_s =~ /#{@options[:filter]}/i)
+        #return if @options[:domain] && !(data_object.uri.to_s =~ /(www.)?#{@options[:domain]}/i)
+        
+        if @stella_options.format && data_object.respond_to?("to_#{@stella_options.format}")
+          Stella::LOGGER.info(data_object.send("to_#{@stella_options.format}"))
+          
+          if data_object.has_response?
+            Stella::LOGGER.info(data_object.response.send("to_#{@stella_options.format}"))
+          end
+          
+        else 
+          if @stella_options.verbose > 1
+            Stella::LOGGER.info(data_object.inspect, '')
+            
+            if data_object.has_response?
+              Stella::LOGGER.info(data_object.response.inspect, '', '')
+            end
+            
+          elsif @stella_options.verbose > 0 
+            Stella::LOGGER.info(data_object.to_s)
+            Stella::LOGGER.info(data_object.body) if data_object.has_body?
+            
+            if data_object.has_response?
+              Stella::LOGGER.info(data_object.response.to_s) 
+              Stella::LOGGER.info(data_object.response.body) if data_object.response.has_body?
+            end
+            
+          else
+            Stella::LOGGER.info(data_object.to_s)
+            Stella::LOGGER.info(data_object.response.to_s) if data_object.has_response?
+            
+          end
+        end
+                
+      rescue Exception => ex
+        Stella::LOGGER.error(ex)
+        #exit 1
+      end
+      
+      
+      
+      # can_pcap?
+      #
+      # Returns true is pcap is available 
+      def can_pcap?(usepcap=false)
+        return false unless usepcap
+        begin
+          check_pcap
+        rescue
+          return false
+        end
+        return true
+      end
+      
+      # check_pcap
+      #
+      # The Pcap gauntlet. A number of conditions must be met to run the Pcap recorder:
+      # - The watch command must be called with -p
+      # - The OS must be a form of Unix
+      # - Cannot be running via JRuby or Java
+      # - The user must be root (or running through sudo)
+      # - The Ruby-Pcap library must be installed.
+      def check_pcap(usepcap=false)
+        raise MissingDependency.new('pcap', :error_sysinfo_notunix) unless Stella::SYSINFO.os === :unix # pcap not available on windows or java
+        raise MissingDependency.new('pcap', :error_sysinfo_notroot) unless ENV['USER'] === 'root' # Must run as root or sudo
+        begin 
+          require 'pcap'
+        rescue Exception, LoadError => ex
+          raise MissingDependency.new('pcap', :error_watch_norubypcap)
+        end
+        false
+      end
+      
+      def generate_record_filepath
+        filepath = nil
+        
+        if (@options[:record].is_a? String)
+          filepath = File.expand_path(@options[:record])
+        else
+          now = DateTime.now
+          daystr = "#{now.year}-#{now.mon.to_s.rjust(2,'0')}-#{now.mday.to_s.rjust(2,'0')}"
+          dirpath = File.join(@working_directory, 'stories', daystr)
+
+          FileUtil.create_dir(dirpath, ".")
+          filepath = File.join(dirpath, 'story')
+          testnum = 1.to_s.rjust(2,'0')
+          testnum.succ! while(File.exists? "#{filepath}-#{testnum}.txt")
+          filepath = "#{filepath}-#{testnum}.txt"
+        end
+          
+        return filepath
+      end
+      
+      def after
+        # Close Pcap / Shutdown Proxy
+        @watcher.after
+        
+        # We don't need to close or delete a file that wasn't created
+        return unless @record_file
+        
+        # And we don't want to delete a file that we're overwriting but may
+        # not have actually written anything to yet. IOW, original file will
+        # remain intact if we haven't written anything to it yet. 
+        @record_file.close if @forced_overwrite
+        
+        # Delete an empty file, otherwise close it
+        @record_file.stat.size == 0 ? File.unlink(@record_file.path) : @record_file.close
+      end
+      
+      def process_arguments(arguments, display=false)
+        opts = OptionParser.new
+        
+        opts.banner = "Usage: #{File.basename($0)} [global options] watch [command options] [http|dns]"
+        opts.on("#{$/}Example: #{File.basename($0)} -v watch -C http#{$/}")
+        opts.on('-h', '--help', "Display this message") do
+          Stella::LOGGER.info opts
+          exit 0
+        end
+        
+        opts.on("#{$/}Operating mode")
+        opts.on('-P', '--useproxy', "Use an HTTP proxy to filter requests (default)") do |v| v end
+        opts.on('-C', '--usepcap', "Use Pcap to filter TCP packets") do |v| v end
+        #opts.on('-F', '--usepacketfu', "Use Packetfu to filter TCP packets") do |v| v end
+          
+        opts.on("#{$/}Pcap-specific options")
+        opts.on('-i=S', '--interface=S', String, "Network device. eri0, en1, etc. (with --usepcap only)") do |v| v end
+        opts.on('-m=N', '--maxpacks=N', Integer, "Maximum number of packets to sniff (with --usepcap only)") do |v| v end
+        opts.on('-R=S', '--protocol=S', String, "Communication protocol to sniff. udp or tcp (with --usepcap only)") do |v| v end
+        
+        opts.on("#{$/}Common options")
+        opts.on('-p=N', '--port=N', Integer, "With --useproxy this is the Proxy port. With --usecap this is the TCP port to filter. ") do |v| v end
+        #opts.on('-f=S', '--filter=S', String, "Filter out requests which do not contain this string") do |v| v end
+        #opts.on('-d=S', '--domain=S', String, "Only display requests to the given domain") do |v| v end
+        #opts.on('-r=S', '--record=S', String, "Record requests to file with an optional filename") do |v| v || true end
+        #opts.on('-F=S', '--format=S', "Format of recorded file. One of: simple (for Siege), session (for Httperf)") do |v| v end
+            
+        options = opts.getopts(@arguments)  
+        options = options.keys.inject({}) do |hash, key|
+           hash[key.to_sym] = options[key]
+           hash
+        end
+                
+        # "interface" is more clear on the command line but we use "device" internally
+        options[:device] = options.delete(:interface) if options[:interface]
+        options[:service] = arguments.shift unless arguments.empty?
+        
+        options
+      end
+      
+    end
+    
+    @@commands['watch'] = Stella::CLI::Watch
+  end
+end
+
+
+__END__
+
+# pageload?
+#
+# Used while writing the session log file. Returns true when we
+# suspect a new page has loaded. Otherwise the resource is considered 
+# to be a dependency. 
+def pageload?(now, think_time, host, referer, content_type)
+  time_difference = (now.to_i - @think_time.to_i)
+  time_passed = (@think_time == 0 || time_difference > 4) 
+  non_html = (content_type !~ /text\/html/i) if content_type
+  #puts "POOO: #{content_type} #{referer}"
+  
+  case [time_passed, non_html]
+  when [true,false]
+    return true
+  when [true,true]
+    return false
+  when [true,nil]
+    return true
+  when [false,false]
+    return false
+  else
+    return false
+  end
+end