solutious-stella 0.5.5 → 0.6.0

data/lib/stella/cli/agents.rb

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

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

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

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

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

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