crusher 0.0.1

data/Rakefile

@@ -0,0 +1,4 @@
+task :gem do
+  `gem build crusher.gemspec`
+  `mv crusher-*.gem tmp/`
+end

data/bin/crush

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join( File.dirname(__FILE__) + "/../lib" )
+require 'crusher'
+require 'eventmachine'
+require 'active_support/core_ext'
+
+config = Crusher::Configurator::Configuration.new('Crushfile')
+
+target_name = ARGV[0].to_sym
+scenario_name = ARGV[1].to_sym
+
+target = config.targets[target_name]
+scenario = config.scenarios[scenario_name]
+
+puts "Fatal Error: Unknown target '#{target_name}'" unless target
+puts "Fatal Error: Unknown scenario '#{scenario_name}'" unless scenario 
+exit(1) unless target && scenario
+
+options = {}
+options[:log_file] = ARGV[2]
+
+Crusher::CrushSession.new(target, scenario, options)

data/lib/crusher/configurator.rb

@@ -0,0 +1,65 @@
+module Crusher
+  module Configurator
+        
+    class Configuration
+      
+      attr_reader :targets, :scenarios
+      
+      def initialize(config_path)
+        @targets = {}
+        @scenarios = {}
+        eval File.open(config_path).read
+      end
+            
+      def target target_name, &block
+        @targets[target_name] = Crusher::Configurator::Target.new(&block)
+      end
+      
+      def scenario scenario_name, &block
+        @scenarios[scenario_name] = Crusher::Configurator::Scenario.new(&block)
+      end
+      
+    end
+    
+    class Target
+      
+      def initialize(*args, &block)
+        block.call self, *args
+      end      
+      
+      def uri(new_uri = nil)
+        return @uri unless new_uri
+        @uri = new_uri
+      end
+      
+    end
+    
+    class Scenario
+      
+      attr_reader :launch_jobs, :phases
+      
+      def initialize(*args, &block)
+        @launch_jobs = []
+        @phases = []
+        @duration = nil
+        block.call self, *args
+      end
+      
+      def launch(count, type, &block)
+        @launch_jobs.push :type => type, :count => count, :proc => block
+      end
+      
+      def phase(name, options = {}, &block)
+        @phases << options.merge( :name => name.to_s, :proc => block )
+      end
+
+      def duration(new_duration = nil)
+        return @duration unless new_duration
+        @duration = new_duration
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/crusher/cookie.rb

@@ -0,0 +1,562 @@
+# cookie.rb is redistributed file which is originally included in Webagent
+# version 0.6.2 by TAKAHASHI `Maki' Masayoshi.  And it contains some bug fixes.
+# You can download the entire package of Webagent from
+# http://www.rubycolor.org/arc/.
+
+
+# Cookie class
+#
+# I refered to w3m's source to make these classes. Some comments
+# are quoted from it. I'm thanksful for author(s) of it.
+#
+#    w3m homepage:  http://ei5nazha.yz.yamagata-u.ac.jp/~aito/w3m/eng/
+
+require 'uri'
+require 'time'
+require 'monitor'
+
+class WebAgent
+
+  module CookieUtils
+
+    def head_match?(str1, str2)
+      str1 == str2[0, str1.length]
+    end
+
+    def tail_match?(str1, str2)
+      if str1.length > 0
+	str1 == str2[-str1.length..-1].to_s
+      else
+	true
+      end
+    end
+
+    def domain_match(host, domain)
+      domainname = domain.sub(/\.\z/, '').downcase
+      hostname = host.sub(/\.\z/, '').downcase
+      case domain
+      when /\d+\.\d+\.\d+\.\d+/
+	return (hostname == domainname)
+      when '.' 
+	return true
+      when /^\./
+        # allows; host == rubyforge.org, domain == .rubyforge.org
+	return tail_match?(domainname, '.' + hostname)
+      else
+	return (hostname == domainname)
+      end
+    end
+
+    def total_dot_num(string)
+      string.scan(/\./).length()
+    end
+
+  end
+
+  class Cookie
+    include CookieUtils
+
+    attr_accessor :name, :value
+    attr_accessor :domain, :path
+    attr_accessor :expires      ## for Netscape Cookie
+    attr_accessor :url
+    attr_writer :use, :secure, :discard, :domain_orig, :path_orig, :override
+
+    USE = 1
+    SECURE = 2
+    DOMAIN = 4
+    PATH = 8
+    DISCARD = 16
+    OVERRIDE = 32
+    OVERRIDE_OK = 32
+
+    def initialize()
+      @name = @value = @domain = @path = nil
+      @expires = nil
+      @url = nil
+      @use = @secure = @discard = @domain_orig = @path_orig = @override = nil
+    end
+
+    def discard?
+      @discard
+    end
+
+    def use?
+      @use
+    end
+
+    def secure?
+      @secure
+    end
+
+    def domain_orig?
+      @domain_orig
+    end
+
+    def path_orig?
+      @path_orig
+    end
+
+    def override?
+      @override
+    end
+
+    def flag
+      flg = 0
+      flg += USE  if @use
+      flg += SECURE  if @secure
+      flg += DOMAIN  if @domain_orig
+      flg += PATH  if @path_orig
+      flg += DISCARD if @discard
+      flg += OVERRIDE if @override
+      flg
+    end
+
+    def set_flag(flag)
+      flag = flag.to_i
+      @use = true      if flag & USE > 0
+      @secure = true   if flag & SECURE > 0
+      @domain_orig = true if flag & DOMAIN > 0
+      @path_orig = true if flag & PATH > 0
+      @discard  = true if flag & DISCARD > 0
+      @override = true if flag & OVERRIDE > 0
+    end
+
+    def match?(url)
+      domainname = url.host
+      if (!domainname ||
+	  !domain_match(domainname, @domain) ||
+	  (@path && !head_match?(@path, url.path)) ||
+	  (@secure && (url.scheme != 'https')) )
+	return false
+      else
+	return true
+      end
+    end
+
+    def join_quotedstr(array, sep)
+      ret = Array.new()
+      old_elem = nil
+      array.each{|elem|
+	if (elem.scan(/"/).length % 2) == 0
+	  if old_elem
+	    old_elem << sep << elem
+	  else
+	    ret << elem
+	    old_elem = nil
+	  end  
+	else
+	  if old_elem
+	    old_elem << sep << elem
+	    ret << old_elem
+	    old_elem = nil
+	  else
+	    old_elem = elem.dup
+	  end
+	end
+      }
+      ret
+    end
+
+    def parse(str, url)
+      @url = url
+      # TODO: should not depend on join_quotedstr. scan with escape like CSV.
+      cookie_elem = str.split(/;/)
+      cookie_elem = join_quotedstr(cookie_elem, ';')
+      cookie_elem -= [""] # del empty elements, a cookie might included ";;"
+      first_elem = cookie_elem.shift
+      if first_elem !~ /([^=]*)(\=(.*))?/
+	return
+	## raise ArgumentError 'invalid cookie value'
+      end
+      @name = $1.strip
+      @value = normalize_cookie_value($3)
+      cookie_elem.each{|pair|
+	key, value = pair.split(/=/, 2)  ## value may nil
+	key.strip!
+        value = normalize_cookie_value(value)
+	case key.downcase
+	when 'domain'
+	  @domain = value
+	when 'expires'
+          @expires = nil
+	  begin
+	    @expires = Time.parse(value).gmtime() if value
+	  rescue ArgumentError
+	  end
+	when 'path'
+	  @path = value
+	when 'secure'
+	  @secure = true  ## value may nil, but must 'true'.
+	else
+	  ## ignore
+	end
+      }
+    end
+
+    def normalize_cookie_value(value)
+      if value
+        value = value.strip.sub(/\A"(.*)"\z/) { $1 }
+        value = nil if value.empty?
+      end
+      value
+    end
+    private :normalize_cookie_value
+  end
+
+  class CookieManager
+    include CookieUtils
+
+    ### errors
+    class Error < StandardError; end
+    class ErrorOverrideOK < Error; end
+    class SpecialError < Error; end
+
+    attr_reader :cookies
+    attr_accessor :cookies_file
+    attr_accessor :accept_domains, :reject_domains
+
+    # for conformance to http://wp.netscape.com/newsref/std/cookie_spec.html
+    attr_accessor :netscape_rule
+    SPECIAL_DOMAIN = [".com",".edu",".gov",".mil",".net",".org",".int"]
+
+    def initialize(file=nil)
+      @cookies = Array.new()
+      @cookies.extend(MonitorMixin)
+      @cookies_file = file
+      @is_saved = true
+      @reject_domains = Array.new()
+      @accept_domains = Array.new()
+      @netscape_rule = false
+    end
+
+    def cookies=(cookies)
+      @cookies = cookies
+      @cookies.extend(MonitorMixin)
+    end
+
+    def save_all_cookies(force = nil, save_unused = true, save_discarded = true)
+      @cookies.synchronize do
+        check_expired_cookies()
+        if @is_saved and !force
+          return
+        end
+        File.open(@cookies_file, 'w') do |f|
+          @cookies.each do |cookie|
+            if (cookie.use? or save_unused) and
+                (!cookie.discard? or save_discarded)
+              f.print(cookie.url.to_s,"\t",
+                      cookie.name,"\t",
+                      cookie.value,"\t",
+                      cookie.expires.to_i,"\t",
+                      cookie.domain,"\t",
+                      cookie.path,"\t",
+                      cookie.flag,"\n")
+            end
+          end
+        end
+      end
+      @is_saved = true
+    end
+
+    def save_cookies(force = nil)
+      save_all_cookies(force, false, false)
+    end
+
+    def check_expired_cookies()
+      @cookies.reject!{|cookie|
+        is_expired = (cookie.expires && (cookie.expires < Time.now.gmtime))
+        if is_expired && !cookie.discard?
+          @is_saved = false
+        end
+        is_expired
+      }
+    end
+
+    def parse(str, url)
+      cookie = WebAgent::Cookie.new()
+      cookie.parse(str, url)
+      add(cookie)
+    end
+
+    def make_cookie_str(cookie_list)
+      if cookie_list.empty?
+	return nil
+      end
+
+      ret = ''
+      c = cookie_list.shift
+      ret += "#{c.name}=#{c.value}"
+      cookie_list.each{|cookie|
+	ret += "; #{cookie.name}=#{cookie.value}"
+      }
+      return ret
+    end
+    private :make_cookie_str
+
+
+    def find(url)
+      return nil if @cookies.empty?
+
+      cookie_list = Array.new()
+      @cookies.each{|cookie|
+        is_expired = (cookie.expires && (cookie.expires < Time.now.gmtime))
+        if cookie.use? && !is_expired && cookie.match?(url)
+          if cookie_list.select{|c1| c1.name == cookie.name}.empty?
+            cookie_list << cookie
+          end
+        end
+      }
+      return make_cookie_str(cookie_list)
+    end
+
+    def find_cookie_info(domain, path, name)
+      @cookies.find{|c|
+	c.domain == domain && c.path == path && c.name == name
+      }
+    end
+    private :find_cookie_info
+
+    # not tested well; used only netscape_rule = true.
+    def cookie_error(err, override)
+      if !err.kind_of?(ErrorOverrideOK) || !override
+	raise err
+      end
+    end
+    private :cookie_error
+
+    def add(cookie)
+      url = cookie.url
+      name, value = cookie.name, cookie.value
+      expires, domain, path = 
+	cookie.expires, cookie.domain, cookie.path
+      secure, domain_orig, path_orig = 
+	cookie.secure?, cookie.domain_orig?, cookie.path_orig?
+      discard, override = 
+	cookie.discard?, cookie.override?
+
+      domainname = url.host
+      domain_orig, path_orig = domain, path
+      use_security = override
+
+      if domain
+
+	# [DRAFT 12] s. 4.2.2 (does not apply in the case that
+	# host name is the same as domain attribute for version 0
+	# cookie)
+	# I think that this rule has almost the same effect as the
+	# tail match of [NETSCAPE].
+	if domain !~ /^\./ && domainname != domain
+	  domain = '.'+domain
+	end
+
+        # [NETSCAPE] rule
+        if @netscape_rule
+          n = total_dot_num(domain)
+          if n < 2
+            cookie_error(SpecialError.new(), override)
+          elsif n == 2
+            ## [NETSCAPE] rule
+            ok = SPECIAL_DOMAIN.select{|sdomain|
+              sdomain == domain[-(sdomain.length)..-1]
+            }
+            if ok.empty?
+              cookie_error(SpecialError.new(), override)
+            end
+          end
+        end
+
+        # this implementation does not check RFC2109 4.3.2 case 2;
+        # the portion of host not in domain does not contain a dot.
+        # according to nsCookieService.cpp in Firefox 3.0.4, Firefox 3.0.4
+        # and IE does not check, too.
+      end
+
+      path ||= url.path.sub(%r|/[^/]*|, '')
+      domain ||= domainname
+      @cookies.synchronize do
+        cookie = find_cookie_info(domain, path, name)
+        if !cookie
+          cookie = WebAgent::Cookie.new()
+          cookie.use = true
+          @cookies << cookie
+        end
+        check_expired_cookies()
+      end
+
+      cookie.url = url
+      cookie.name = name
+      cookie.value = value
+      cookie.expires = expires
+      cookie.domain = domain
+      cookie.path = path
+
+      ## for flag
+      cookie.secure = secure
+      cookie.domain_orig = domain_orig
+      cookie.path_orig = path_orig
+      if discard || cookie.expires == nil
+	cookie.discard = true
+      else
+	cookie.discard = false
+	@is_saved = false
+      end
+    end
+
+    def load_cookies()
+      return if !File.readable?(@cookies_file)
+      @cookies.synchronize do
+        @cookies.clear
+        File.open(@cookies_file,'r'){|f|
+          while line = f.gets
+            cookie = WebAgent::Cookie.new()
+            @cookies << cookie
+            col = line.chomp.split(/\t/)
+            cookie.url = URI.parse(col[0])
+            cookie.name = col[1]
+            cookie.value = col[2]
+            if col[3].empty? or col[3] == '0'
+              cookie.expires = nil
+            else
+              cookie.expires = Time.at(col[3].to_i).gmtime
+            end
+            cookie.domain = col[4]
+            cookie.path = col[5]
+            cookie.set_flag(col[6])
+          end
+        }
+      end
+    end
+
+    def check_cookie_accept_domain(domain)
+      unless domain
+	return false
+      end
+      @accept_domains.each{|dom|
+	if domain_match(domain, dom)
+	  return true
+	end
+      }
+      @reject_domains.each{|dom|
+	if domain_match(domain, dom)
+	  return false
+	end
+      }
+      return true
+    end
+  end
+end
+
+__END__
+
+=begin
+
+== WebAgent::CookieManager Class
+
+Load, save, parse and send cookies.
+
+=== Usage
+
+  ## initialize
+  cm = WebAgent::CookieManager.new("/home/foo/bar/cookie")
+
+  ## load cookie data
+  cm.load_cookies()
+
+  ## parse cookie from string (maybe "Set-Cookie:" header)
+  cm.parse(str)
+
+  ## send cookie data to url
+  f.write(cm.find(url))
+
+  ## save cookie to cookiefile
+  cm.save_cookies()
+
+
+=== Class Methods
+
+ -- CookieManager::new(file=nil)
+
+     create new CookieManager. If a file is provided,
+     use it as cookies' file.
+
+=== Methods
+
+ -- CookieManager#save_cookies(force = nil)
+
+     save cookies' data into file. if argument is true,
+     save data although data is not modified.
+
+ -- CookieManager#parse(str, url)
+
+     parse string and store cookie (to parse HTTP response header).
+
+ -- CookieManager#find(url)
+
+     get cookies and make into string (to send as HTTP request header).
+
+ -- CookieManager#add(cookie)
+
+     add new cookie.
+
+ -- CookieManager#load_cookies()
+
+     load cookies' data from file.
+
+
+== WebAgent::CookieUtils Module
+
+ -- CookieUtils::head_match?(str1, str2)
+ -- CookieUtils::tail_match?(str1, str2)
+ -- CookieUtils::domain_match(host, domain)
+ -- CookieUtils::total_dot_num(str)
+
+
+== WebAgent::Cookie Class
+
+=== Class Methods
+
+ -- Cookie::new()
+
+      create new cookie.
+
+=== Methods
+
+ -- Cookie#match?(url)
+
+       match cookie by url. if match, return true. otherwise,
+       return false.
+
+ -- Cookie#name
+ -- Cookie#name=(name)
+ -- Cookie#value
+ -- Cookie#value=(value)
+ -- Cookie#domain
+ -- Cookie#domain=(domain)
+ -- Cookie#path
+ -- Cookie#path=(path)
+ -- Cookie#expires
+ -- Cookie#expires=(expires)
+ -- Cookie#url
+ -- Cookie#url=(url)
+
+      accessor methods for cookie's items.
+
+ -- Cookie#discard?
+ -- Cookie#discard=(discard)
+ -- Cookie#use?
+ -- Cookie#use=(use)
+ -- Cookie#secure?
+ -- Cookie#secure=(secure)
+ -- Cookie#domain_orig?
+ -- Cookie#domain_orig=(domain_orig)
+ -- Cookie#path_orig?
+ -- Cookie#path_orig=(path_orig)
+ -- Cookie#override?
+ -- Cookie#override=(override)
+ -- Cookie#flag
+ -- Cookie#set_flag(flag_num)
+
+      accessor methods for flags.
+
+=end

data/lib/crusher/crush_session.rb

@@ -0,0 +1,106 @@
+module Crusher
+  class CrushSession
+    
+    attr_reader :target, :scenario, :log_file
+    
+    def initialize(target, scenario, options = {})
+      @target = target
+      @scenario = scenario
+      @queued_jobs = []
+      @running_jobs = []
+      @options = options
+      @current_phase = "booting"
+      
+      @scenario.launch_jobs.each do |job|
+        job_id = 0
+        puts job.keys.inspect
+        puts "Launching #{job[:count]} #{job[:type]}(s)..."
+        job[:count].times do
+          queue_job(job, job_id)
+          job_id += 1
+        end
+      end
+
+      launch_queued_jobs
+      
+    end
+    
+    def log(message)
+      log_message = Time.now.strftime('%Y-%m-%d %H:%M:%S') + ' ' + @current_phase + ' ' +  message + "\n"
+      if @log_file
+        @log_file.syswrite(log_message)
+      else
+        puts log_message
+      end
+      nil
+    end
+    
+    private 
+    
+    def queue_job(job, id)
+      @queued_jobs << [job, id]
+    end
+
+    def run_next_phase
+      if @scenario.phases.length == 0
+        shutdown 
+      else
+        next_phase = @scenario.phases.shift
+        @current_phase = next_phase[:name].to_s
+
+        if next_phase[:wait]
+          EM::Timer.new(next_phase[:wait].to_i) do
+            run_next_phase
+          end
+        elsif next_phase[:over]
+          seconds_per_job = next_phase[:over].to_f / @running_jobs.count.to_f
+          next_job = 0
+
+          slow_iterator = EM::PeriodicTimer.new(seconds_per_job) do
+            next_phase[:proc].call(@running_jobs[next_job])
+            next_job += 1
+
+            if next_job >= @running_jobs.length
+              slow_iterator.cancel
+              run_next_phase
+            end
+          end
+        end
+      end
+    end
+
+
+    def launch_queued_jobs
+      return nil if @queued_jobs.length == 0
+
+      fork do
+        
+        @log_file = File.open(@options.delete(:log_file), 'a') if @options[:log_file]
+        
+        # Reseed the pseudorandom number generator with the process's PID file, otherwise
+        # we'll inherit our sequence of random numbers from the parent process
+        Kernel.srand(Process.pid)
+
+        EM.run do
+          @queued_jobs.each do |settings|
+            job, job_id = settings
+            options = @options.merge(:process_name => "#{job[:type]} #{job_id}")
+            @running_jobs << job[:proc].call(self, options, job_id)
+          end
+          run_next_phase
+        end
+
+      end
+
+      @queued_jobs = []
+
+      nil
+    end
+    
+    def shutdown
+      EM::stop_event_loop
+    end
+    
+  end
+  
+end

data/lib/crusher/http_load_generator.rb

@@ -0,0 +1,54 @@
+module Crusher
+  
+  class HttpLoadGenerator < LoadGenerator
+    
+    
+    def initialize(crush_session, options)
+      super(crush_session, options)
+      @cookies = ::WebAgent::CookieManager.new 
+    end
+    
+    def request(method, path, content = {}, &block)
+
+      uri = URI.parse(path)
+
+      http_args = content.keys.map do |key| 
+        content[key] ? "#{URI.escape(key.to_s)}=#{URI.escape(content[key].to_s)}" : nil
+      end
+      
+      qs, content = if method == :get
+        [((uri.query || '').split('&') + http_args.compact).join("&"), nil]
+      else
+        [uri.query, http_args.join("&")] 
+      end
+
+      options = {
+        :verb => method,
+        :host => uri.host,
+        :port => uri.port,
+        :request => uri.path,
+        :query_string => qs,
+        :content => content,
+        :contenttype => 'application/x-www-form-urlencoded',
+        :cookie => @cookies.find(uri),
+        :ssl => (uri.scheme == "https" ? true : false)
+      }
+      
+      start_time = Time.now
+      EM::Protocols::HttpClient.request(options).callback do |response|
+        duration = Time.now - start_time
+        
+        response[:headers].each do |header|
+          matcher = /Set-Cookie:\s*(.*)/i.match(header)
+          @cookies.parse(matcher[1], uri) if matcher
+        end
+        
+        block.call(response, duration) if block
+      end
+
+    end
+    
+    
+  end
+  
+end

data/lib/crusher/load_generator.rb

@@ -0,0 +1,25 @@
+module Crusher
+  
+  class LoadGenerator
+  
+    def initialize(crush_session, options)
+      @crush_session = crush_session
+      @options = options
+      begin
+        @log_file = File.open(options[:log_file], 'a') if options[:log_file] 
+      rescue Errno::ENOENT
+        log("Log file #{options[:log_file]} couldn't be opened; logging to STDOUT")
+      end    
+    end
+    
+    def act!; end
+  
+    def prepare; end
+        
+    def log(message)
+      @crush_session.log(message)
+    end
+  
+  end
+  
+end

data/lib/crusher/util.rb

@@ -0,0 +1,14 @@
+module Crusher::Util
+  DUMMY_WORDS = %w( Vivamus condimentum mi vel massa blandit ut pretium risus cursus Pellentesque eu mollis turpis Cum sociis natoque penatibus et magnis dis parturient montes nascetur ridiculus mus Phasellus lobortis bibendum lectus Suspendisse suscipit sem in arcu tempor at malesuada lectus facilisis Sed euismod pretium gravida Ut feugiat tortor a erat mattis a eleifend est rutrum Ut est elit accumsan ut lacinia ac dignissim tincidunt elit Duis nisi mauris ornare eget laoreet vel euismod at sem Donec in neque nec odio ornare vestibulum Pellentesque ut turpis erat nec sollicitudin nulla Nulla varius fringilla porta Fusce sit amet orci eget sem iaculis porttitor Proin pulvinar sodales odio in dapibus erat viverra in Donec fringilla lacus et lacus tincidunt ut laoreet dolor tristique Nullam vulputate iaculis condimentum Mauris et ligula id erat auctor adipiscing Nulla luctus interdum consequatProin vehicula egestas leo a feugiat velit fermentum quis Morbi mattis dignissim tincidunt Nunc sed dignissim leo Mauris vitae mi sollicitudin eros elementum interdum non quis velit Nam eleifend aliquam lobortis Maecenas in metus non libero porttitor tincidunt vitae molestie augue Lorem ipsum dolor sit amet consectetur adipiscing elit Vestibulum blandit erat ac urna gravida ac aliquam nulla scelerisque Fusce ante purus rhoncus auctor molestie vel tincidunt sit amet orci Sed viverra augue ut quam condimentum dictum Duis ullamcorper elit in erat ullamcorper eget rhoncus velit blandit Morbi ultrices lacus id suscipit tempor turpis dolor placerat ante tempor mollis turpis leo et augue Phasellus augue dolor ultrices luctus rhoncus nec sollicitudin sit amet nequeVestibulum interdum nibh sed mauris vulputate sed tincidunt magna rhoncus Etiam sapien metus ultricies in eleifend a aliquet eget nibh Duis in est nibh eu tincidunt enim Vivamus suscipit felis a velit dignissim et fringilla mi laoreet Duis metus odio porta vitae dictum in rutrum ut quam Donec tristique adipiscing nisl non iaculis Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas Nulla eget pulvinar nulla Cum sociis natoque penatibus et magnis dis parturient montes nascetur ridiculus mus Donec venenatis justo eu vulputate venenatis leo ante varius enim ac laoreet lacus elit id ipsum Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas Etiam euismod lorem quis faucibus vehicula nisi lorem mattis felis in imperdiet urna magna non dolor Aenean sed eros eu odio pretium blandit In hac habitasse platea dictumst Vestibulum nisi orci malesuada eu adipiscing eget posuere nec orci Curabitur bibendum orci non felis faucibus lobortisSuspendisse imperdiet pellentesque magna sit amet commodo odio hendrerit vitae Duis dapibus tempor nunc interdum vulputate Curabitur fringilla erat ut magna viverra pulvinar sed eu nunc Phasellus sit amet aliquam nulla Donec aliquam nibh in ullamcorper dictum nibh risus pellentesque nunc eu laoreet nulla elit sed justo Donec blandit justo eu mi ultricies eu tempus turpis fringilla Proin ligula elit varius vel egestas et hendrerit sed metus Phasellus nec tortor nunc eu auctor quam Nulla quis ultricies felis Proin iaculis felis non ultrices ) 
+
+  srand Time.now.seconds # Seeds rng on boot
+
+  def self.nrand(min, max)
+    (1..6).map{ rand(min,max) }.sum / 6
+  end
+
+  def self.lipsum(words)
+    (1..words).map{ DUMMY_WORDS[ rand(DUMMY_WORDS.length) ] }.join(' ')
+  end
+  
+end

data/lib/crusher.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'crusher/crush_session'
+require 'crusher/load_generator'
+require 'crusher/cookie'
+require 'crusher/http_load_generator'
+require 'crusher/util'
+require 'crusher/configurator'
+
+
+module Crusher
+  
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: crusher
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- phene
+- thatothermitch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-08 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httpclient
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: crusher-eventmachine
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: A scriptable, multiprocessing load generator designed to bring web applications to their knees
+email: 
+executables: 
+- crush
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/crusher/configurator.rb
+- lib/crusher/cookie.rb
+- lib/crusher/crush_session.rb
+- lib/crusher/http_load_generator.rb
+- lib/crusher/load_generator.rb
+- lib/crusher/util.rb
+- lib/crusher.rb
+- bin/crush
+- Rakefile
+has_rdoc: false
+homepage: http://github.com/socialcast/crusher
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A scriptable load generator
+test_files: []
+