rereplay 0.1 → 0.2

data/.infinity_test

@@ -0,0 +1,25 @@
+infinity_test do
+
+    notifications :lib_notify do
+      show_images# :mode => :mario_bros
+    end
+
+    use :rubies => %w(1.8.7 1.9.2 ruby-head jruby), :test_framework => :rspec
+
+    before(:each_ruby) do |environment|
+      # ...
+    end
+
+    after(:each_ruby) do |environment|
+      # ...
+    end        
+
+    before_run do
+      clear :terminal
+    end
+
+    after_run do
+      # ...
+    end
+
+end

data/Gemfile

@@ -1,13 +1,7 @@
 source "http://rubygems.org"
 
-gem "eventmachine", "~>0.12.10"
-gem "em-http-request", "~>0.2.14"
-
-group :test do
-	gem "rspec", "~>2.0"
-	gem "webmock", "~>1.4.0"
-	gem "activesupport", "~>3.0.1"
-#	gem "autotest"
-#	gem "test_notifier"
-end
+gem "infinity_test", :git => "git://github.com/tomas-stefano/infinity_test.git"
+gem "rspec", "~>2.0"
+gem "webmock", "~>1.4.0"
+gem "activesupport", "~>3.0.1"
 

data/Gemfile.lock

@@ -1,3 +1,11 @@
+GIT
+  remote: git://github.com/tomas-stefano/infinity_test.git
+  revision: c732c6bcc54e8745fba4dbd4565e068a2a329e1a
+  specs:
+    infinity_test (0.2.0)
+      notifiers (>= 1.1.0)
+      watchr (>= 0.7)
+
 GEM
   remote: http://rubygems.org/
   specs:
@@ -5,10 +13,7 @@ GEM
     addressable (2.2.2)
     crack (0.1.8)
     diff-lcs (1.1.2)
-    em-http-request (0.2.14)
-      addressable (>= 2.0.0)
-      eventmachine (>= 0.12.9)
-    eventmachine (0.12.10)
+    notifiers (1.1.0)
     rspec (2.0.1)
       rspec-core (~> 2.0.1)
       rspec-expectations (~> 2.0.1)
@@ -19,16 +24,17 @@ GEM
     rspec-mocks (2.0.1)
       rspec-core (~> 2.0.1)
       rspec-expectations (~> 2.0.1)
+    watchr (0.7)
     webmock (1.4.0)
       addressable (>= 2.2.2)
       crack (>= 0.1.7)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
   activesupport (~> 3.0.1)
-  em-http-request (~> 0.2.14)
-  eventmachine (~> 0.12.10)
+  infinity_test!
   rspec (~> 2.0)
   webmock (~> 1.4.0)

data/README.md

@@ -14,17 +14,17 @@ There are a couple other main features as well.  You can provide Request Monitor
     	[0.5, :get, "http://www.microsoft.com/"],
     	[0.9, :get, "http://www.amazon.com/"]
     ]
-    r = ReReplay.new(input)
+    r = ReReplay::Runner.new(input)
     r.run
     # and done!    
 
 Of course, this doesn't actually track any output, so...let's monitor the request time using the request_time_monitor:
 
 ## Request Monitor
-    require "rereplay/monitors/request_time_monitor"
+    require "rereplay/monitors"
     input = [same as in Simple]
-    mon = RequestTimeMonitor.new
-    r = ReReplay.new(input)
+    mon = ReReplay::RequestTimeMonitor.new
+    r = ReReplay::Runner.new(input)
     r.request_monitors << mon
     r.run
     puts mon.results.inspect

data/lib/rereplay.rb

@@ -1,5 +1 @@
-require 'ostruct'
-require 'eventmachine'
-require 'em-http'
-
-require 'rereplay/runner'
+require 'rereplay/ruby_runner'

data/lib/rereplay/monitors/request_time_monitor.rb

@@ -7,7 +7,7 @@ module ReReplay
 		end
 	
 		def finish(request)
-			@results[request.index] = [request.url, request.finish - request.actual_start, request.scheduled_start, request.actual_start]
+			@results[request.index] = {:url => request.url, :duration => request.finish - request.actual_start, :scheduled_start => request.scheduled_start, :actual_start => request.actual_start}
 		end
 	end
 end

data/lib/rereplay/monitors/timeout_failer.rb

@@ -1,5 +1,6 @@
 module ReReplay
 	class TimeoutFailer
+		class Timeout < StandardError; end
 		def initialize(max_timeouts=1)
 			@max_timeouts = max_timeouts
 			@timeouts = 0
@@ -10,7 +11,7 @@ module ReReplay
 				@timeouts += 1
 			end
 			if(@timeouts >= @max_timeouts)
-				raise "TimeoutFailer triggered because timeout limit #{@max_timeouts} was reached"
+				raise Timeout, "TimeoutFailer triggered because timeout limit #{@max_timeouts} was reached"
 			end
 		end
 	end

data/lib/rereplay/ruby_runner.rb

@@ -0,0 +1,250 @@
+require 'ostruct'
+require 'thread'
+require 'net/http'
+require 'uri'
+require 'monitor'
+
+module ReReplay
+	class TestDurationExceeded < StandardError; end
+	class Runner
+	
+		attr_accessor :periodic_monitors
+		attr_accessor :request_monitors
+
+		def initialize(input=nil)
+			if(!input.nil?)
+				self.input = input
+			end
+			@periodic_monitors = []
+			@request_monitors = []
+		end
+		
+		def input=(input)
+			if(input.is_a? Array)
+				@input = input
+			elsif(input.respond_to? :readlines)
+				@input = input.readlines
+			elsif(input.respond_to? :split)
+				@input = input.split("\n").map do |i| 
+					i = i.strip.split(",").map {|j| j.strip}
+					i[0] = i[0].to_f
+					i[1] = i[1].to_sym
+					i
+				end
+			else
+				raise "Invalid input, expected Array, #readlines, or #split"
+			end
+		end
+	
+		def validate_input
+			if(@input.nil? || @input.empty?)
+				raise ArgumentError, "Nothing to process (input was empty)"
+			end
+			valid_methods = [:get, :head]
+			@input.each_with_index do |a, i|
+				if(!a[0].is_a? Numeric)
+					raise ArgumentError, "Expected element at index 0 of input #{i+1} to be Numeric; was #{a[0]}"
+				end
+				if(!a[1].is_a?(Symbol) || !valid_methods.include?(a[1]))
+					raise ArgumentError, "Expected element at index 1 of input #{i+1} to be a symbol in #{valid_methods.inspect}; was #{a[1].inspect}"
+				end
+				if(!a[2].is_a? String)
+					raise ArgumentError, "Expected element at index 2 of input #{i+1} to be a String; was #{a[2]}"
+				end
+				if(!a[3].nil? && !a[3].is_a?(Hash))
+					raise ArgumentError, "Expected element at index 3 of input #{i+1} to be nil or a Hash; was #{a[3]}"
+				end
+				# TODO post data
+			end
+		end
+		
+		def prepare
+			p = profile
+		
+			max_time = @input.max {|a, b| a[0] <=> b[0]}[0]
+			
+			loop_count = 1
+			if(p[:when_input_consumed] == :loop)
+				if(max_time < p[:run_for])
+					loop_count = (p[:run_for].to_f / max_time).ceil
+				end
+			end
+			if(loop_count > 1)
+				new_inputs = []
+				2.upto(loop_count) do |loop|
+					new_input = @input.map do |i|
+						new_i = i.dup
+						new_i[0] += max_time * (loop - 1)
+						new_i
+					end
+					new_inputs << new_input
+				end
+				new_inputs.each {|input| @input += input}
+			end
+			real_max_time = [max_time * loop_count, p[:run_for]].min
+			if(p[:rampup][0] != p[:rampup][1] || p[:rampup][0] != 1.0)
+				case p[:rampup_method]
+				when :linear
+					sr = 1.0 / p[:rampup][0]
+					fr = 1.0 / p[:rampup][1]
+					prev_time = 0
+					new_prev_time = 0
+					@input.map! do |a|
+						time = a[0].to_f
+						percent = time / real_max_time
+						fraction = sr + (fr - sr)*(time / real_max_time)
+						tmp = a[0]
+						a[0] = (time - prev_time)*fraction + new_prev_time
+						prev_time = tmp
+						new_prev_time = a[0]
+						a
+					end
+				end
+			end
+		end
+	
+		def run
+			validate_input
+			p = profile
+			done_count = 0
+			# request monitors with a start method
+			request_monitors_start = request_monitors.select {|mon| mon.respond_to? :start}
+			# request monitors with a finish method
+			request_monitors_finish = request_monitors.select {|mon| mon.respond_to? :finish}
+			tg = ThreadGroup.new
+			q = Queue.new
+			q.extend MonitorMixin
+			waiters_cond = q.new_cond
+			
+			prepare
+			start_time = nil
+			index = 0
+			requests_to_make = @input.map do |r| 
+				a = r.dup
+				a[3] = index
+				index += 1
+				a
+			end
+			thread_count = 20
+			done = 0
+			total_requests = @input.length
+			max_delay = 0
+			parent_thread = Thread.current
+			Thread.abort_on_exception = true
+			ready_for_processing = false
+			gatekeeper = Thread.new do
+				q.synchronize do
+					waiters_cond.wait_until { ready_for_processing }
+				end
+				until requests_to_make.empty?
+					task = requests_to_make.shift
+					since_start = Time.new - start_time
+					time_until_next_task = task[0] - since_start
+				
+					if(time_until_next_task > 0)
+						sleep time_until_next_task
+					end
+					
+					q << task
+				end
+			end
+			
+			thread_count.times do
+				t = Thread.new do
+					while true
+						task = q.pop
+						now = Time.new
+						since_start = now - start_time
+						delay = since_start - task[0]
+						if(delay > max_delay) then max_delay = delay; end
+						url = URI.parse(task[2])
+						req = Net::HTTP::Get.new(url.path)
+						request = OpenStruct.new(:url => task[2], :scheduled_start => task[0], :index => task[3], :http_method => task[1])
+						# this connection can actually take ~300ms...is there a better way?
+						Net::HTTP.start(url.host, url.port) do |http|
+							http.read_timeout = p[:timeout]
+							status = nil
+							begin
+								#request.actual_start = Time.now - start_time
+								request.actual_start = now - start_time
+								resp = http.request(req)
+								request_monitors_start.each {|mon| mon.start(request)}
+							rescue Timeout::Error
+								status = :timeout
+							end
+							if status.nil?
+								status = resp.code
+							end
+							time_finished = Time.now - start_time
+							request.finish = time_finished
+							request.status = status
+							begin
+								request_monitors_finish.each {|mon|	mon.finish(request)}
+							rescue => e
+								parent_thread.raise e
+							end
+							q.synchronize do
+								done += 1
+								waiters_cond.broadcast
+							end
+						end
+					end
+				end
+				tg.add t
+			end
+			test_duration_exceeded = false
+			q.synchronize do
+				ready_for_processing = true
+				start_time = Time.now
+				waiters_cond.broadcast
+			end
+			timeout_thread = Thread.new do
+				sleep_duration = start_time + p[:run_for] - Time.now
+				sleep sleep_duration
+				q.synchronize do
+					test_duration_exceeded = true
+					waiters_cond.broadcast
+				end
+			end
+			periodic_monitor_threads = []
+			periodic_monitors.each do |mon|
+				interval = mon.respond_to?(:interval) ? mon.interval : 5
+				periodic_monitor_threads << Thread.new do
+					i = 0
+					while true
+						mon.tick(Time.now - start_time)
+						i += 1
+						time_to_next = start_time + (interval * i) - Time.now
+						sleep time_to_next if time_to_next > 0
+					end
+				end
+			end
+			q.synchronize do
+				waiters_cond.wait_while {	done < total_requests && !test_duration_exceeded }
+			end
+		ensure
+			gatekeeper.kill if gatekeeper
+			tg.list.each {|t| t.kill} if tg
+			periodic_monitor_threads.each {|t| t.kill} if periodic_monitor_threads
+		end
+
+		def profile=(new_profile)
+			@profile = {
+				:run_for => 5,
+				:when_input_consumed => :stop,
+				:timeout => 1,
+				:rampup => [1.0, 1.0],
+				:rampup_method => :linear
+			}
+			if(new_profile.is_a? Hash)
+				@profile.merge!(new_profile)
+			end
+		end
+		def profile
+			if(@profile.nil?)
+				self.profile = {}
+			end
+			@profile
+		end
+	end
+end

data/lib/rereplay/version.rb

@@ -1,3 +1,3 @@
 module ReReplay
-	VERSION = "0.1"
+	VERSION = "0.2"
 end

data/rereplay.gemspec

@@ -15,9 +15,6 @@ Gem::Specification.new do |s|
 
   s.required_rubygems_version = ">= 1.3.6"
 
-  s.add_runtime_dependency "eventmachine", ">= 0.12.10", "< 0.13"
-  s.add_runtime_dependency "em-http-request", ">= 0.2.14", "< 0.3"
-	
   s.add_development_dependency "rspec", ">= 2.0", "< 3"
   s.add_development_dependency "webmock", ">= 1.4.0", "< 1.5"
   s.add_development_dependency "active_support", ">= 3.0.1", "< 3.1"

data/spec/{advanced.rb → advanced_spec.rb}

@@ -1,4 +1,4 @@
-require 'spec/spec_helper'
+require 'spec_helper'
 
 describe ReReplay, "advanced functions" do
 	it "should support linear rampup" do
@@ -9,7 +9,7 @@ describe ReReplay, "advanced functions" do
 			:rampup => [1.0, 2.0]
 		}
 		r.profile = profile
-		lambda { r.run }.should take_between(1.65.seconds).and(1.8.seconds)
+		lambda { r.run }.should take_between(0.65.seconds).and(0.8.seconds)
 		validate_input(10)
 	end
 	
@@ -21,7 +21,7 @@ describe ReReplay, "advanced functions" do
 			:rampup => [0.5, 2]
 		}
 		r.profile = profile
-		lambda { r.run }.should take_between(2.05.seconds).and(2.2.seconds)
+		lambda { r.run }.should take_between(1.05.seconds).and(1.2.seconds)
 		validate_input(10)
 	end
 	
@@ -35,7 +35,7 @@ describe ReReplay, "advanced functions" do
 			:when_input_consumed => :loop
 		}
 		r.profile = profile
-		lambda { r.run }.should take_between(3.seconds).and(3.1.seconds)
+		lambda { r.run }.should take_between(2.seconds).and(2.2.seconds)
 		validate_input(10, 2)
 	end
 end

data/spec/{basic.rb → basic_spec.rb}

@@ -1,4 +1,4 @@
-require 'spec/spec_helper'
+require 'spec_helper'
 
 describe ReReplay, "basic functions" do
 	it "should process input from array" do
@@ -10,7 +10,7 @@ describe ReReplay, "basic functions" do
 		input = urls.map {|i| [interval += 0.1, :get, i]}
 		
 		r = ReReplay::Runner.new(input)
-		lambda { r.run }.should take_between(1.second).and(2.seconds)
+		lambda { r.run }.should take_between(0.seconds).and(1.second)
 		
 		urls.each {|url| WebMock.should have_requested(:get, url)}
 	end
@@ -25,7 +25,7 @@ EOF
 		stub_request(:get, "http://www.amazon.com/")
 		
 		r = ReReplay::Runner.new(input)
-		lambda { r.run }.should take_between(1.second).and(2.seconds)
+		lambda { r.run }.should take_between(0.seconds).and(1.second)
 		
 		WebMock.should have_requested(:get, "http://www.google.com/")
 		WebMock.should have_requested(:get, "http://www.amazon.com/")

data/spec/{monitor.rb → monitor_spec.rb}

@@ -1,4 +1,4 @@
-require 'spec/spec_helper'
+require 'spec_helper'
 
 describe ReReplay, "periodic monitors" do
 	it "should work" do
@@ -9,9 +9,6 @@ describe ReReplay, "periodic monitors" do
 		r = ReReplay::Runner.new(input)
 		r.periodic_monitors << mem_monitor
 		
-		# the periodic monitor will start around `time_for_setup` (1 second)
-		# and run once every ~0.23s thereafter.
-		# Because the final request will finish around 1.75, this run four times
 		r.run
 		validate_input(3)
 		mem_monitor.results.length.should == 4
@@ -26,9 +23,7 @@ describe ReReplay, "request monitors" do
 		input = generate_input(3, :interval => 0.25)
 		r = ReReplay::Runner.new(input)
 		r.request_monitors << req_mon << delay_mon
-		# the periodic monitor will start around `time_for_setup` (1 second)
-		# and run once every ~0.23s thereafter.
-		# Because the final request will finish around 1.75, this run four times
+
 		r.run
 		validate_input(3)
 		req_mon.results.length.should == 3
@@ -48,7 +43,8 @@ started request 1:\\(http://microsoft.com/\\) at [\\d\\.]+
 started request 2:\\(http://amazon.com/\\) at [\\d\\.]+
  - finished request 2, status 200
 EOF
-			capture_stdout { r.run }.should match(expected)
+			output = capture_stdout { r.run }
+			output.should match(expected)
 			validate_input(3)
 		end
 	end

data/spec/profile_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe ReReplay, "profile options" do
+	it "respects 'run_for' parameter" do
+		input = generate_input(3, :interval => 0.3)
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:run_for => 0.5
+		}
+		r.profile = profile
+		
+		lambda { r.run }.should take_between(0.5.seconds).and(0.6.seconds)
+		validate_input(1)
+	end
+	
+	it "respects 'when_input_consumed' parameter when :stop" do
+		input = generate_input(3, :interval => 0.1)
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:run_for => 10,
+			:when_input_consumed => :stop
+		}
+		r.profile = profile
+		
+		lambda { r.run }.should take_between(0.3.seconds).and(0.5.seconds)
+		validate_input(3)
+	end
+	
+	it "respects 'when_input_consumed' parameter when :loop" do
+		input = generate_input(1, :interval => 0.25)
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:run_for => 0.6,
+			:when_input_consumed => :loop
+		}
+		r.profile = profile
+		req_mon = ReReplay::RequestTimeMonitor.new
+		r.request_monitors << req_mon
+		
+		# normally this would take 1.5 seconds with :stop, but we're forcing it to loop and take 2 seconds
+		lambda { r.run }.should take_between(0.6.seconds).and(0.7.seconds)
+		req_mon.results.length.should == 2
+		validate_input(1, 2)
+	end
+	
+	# eh, this isn't that good a test because WebMock causes #to_timeout requests to timeout immediately
+	# but it tests that timeout works
+	it "works with timeouts" do
+		input = generate_input(1, :interval => 0.25, :timeout => true)
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:timeout => 10
+		}
+		r.profile = profile
+		r.request_monitors << ReReplay::TimeoutFailer.new
+		
+		lambda { lambda { r.run }.should raise_error(StandardError, /TimeoutFailer/) }.should take_between(0.25.seconds).and(0.5.seconds)
+		validate_input(1)
+	end
+
+end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: rereplay
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 1
-  version: "0.1"
+  - 2
+  version: "0.2"
 platform: ruby
 authors: 
 - Max Aller
@@ -14,59 +14,13 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-25 00:00:00 -07:00
+date: 2010-10-30 00:00:00 -07:00
 default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: eventmachine
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 59
-        segments: 
-        - 0
-        - 12
-        - 10
-        version: 0.12.10
-    - - <
-      - !ruby/object:Gem::Version 
-        hash: 17
-        segments: 
-        - 0
-        - 13
-        version: "0.13"
-  type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: em-http-request
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 0
-        - 2
-        - 14
-        version: 0.2.14
-    - - <
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 0
-        - 3
-        version: "0.3"
-  type: :runtime
-  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -83,11 +37,11 @@ dependencies:
         - 3
         version: "3"
   type: :development
-  version_requirements: *id003
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: webmock
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -106,11 +60,11 @@ dependencies:
         - 5
         version: "1.5"
   type: :development
-  version_requirements: *id004
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: active_support
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -129,7 +83,7 @@ dependencies:
         - 1
         version: "3.1"
   type: :development
-  version_requirements: *id005
+  version_requirements: *id003
 description: Replay or script traffic in order to track performance of your site over time.
 email: 
 - nanodeath@gmail.com
@@ -141,6 +95,7 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- .infinity_test
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -153,13 +108,13 @@ files:
 - lib/rereplay/monitors/request_time_monitor.rb
 - lib/rereplay/monitors/timeout_failer.rb
 - lib/rereplay/monitors/verbose_monitor.rb
-- lib/rereplay/runner.rb
+- lib/rereplay/ruby_runner.rb
 - lib/rereplay/version.rb
 - rereplay.gemspec
-- spec/advanced.rb
-- spec/basic.rb
-- spec/monitor.rb
-- spec/profile.rb
+- spec/advanced_spec.rb
+- spec/basic_spec.rb
+- spec/monitor_spec.rb
+- spec/profile_spec.rb
 - spec/spec_custom_matchers.rb
 - spec/spec_helper.rb
 has_rdoc: true

data/lib/rereplay/runner.rb

@@ -1,200 +0,0 @@
-module ReReplay
-	class Runner
-		attr_accessor :periodic_monitors
-		attr_accessor :request_monitors
-
-		def initialize(input=nil)
-			if(!input.nil?)
-				self.input = input
-			end
-			@periodic_monitors = []
-			@request_monitors = []
-		end
-
-		def input=(input)
-			if(input.is_a? Array)
-				@input = input
-			elsif(input.respond_to? :readlines)
-				@input = input.readlines
-			elsif(input.respond_to? :split)
-				@input = input.split("\n").map do |i| 
-					i = i.strip.split(",").map {|j| j.strip}
-					i[0] = i[0].to_f
-					i[1] = i[1].to_sym
-					i
-				end
-			else
-				raise "Invalid input, expected Array, #readlines, or #split"
-			end
-		end
-	
-		def validate_input
-			if(@input.nil? || @input.empty?)
-				raise ArgumentError, "Nothing to process (input was empty)"
-			end
-			valid_methods = [:get, :head]
-			@input.each_with_index do |a, i|
-				if(!a[0].is_a? Numeric)
-					raise ArgumentError, "Expected element at index 0 of input #{i+1} to be Numeric; was #{a[0]}"
-				end
-				if(!a[1].is_a?(Symbol) || !valid_methods.include?(a[1]))
-					raise ArgumentError, "Expected element at index 1 of input #{i+1} to be a symbol in #{valid_methods.inspect}; was #{a[1].inspect}"
-				end
-				if(!a[2].is_a? String)
-					raise ArgumentError, "Expected element at index 2 of input #{i+1} to be a String; was #{a[2]}"
-				end
-				if(!a[3].nil? && !a[3].is_a?(Hash))
-					raise ArgumentError, "Expected element at index 3 of input #{i+1} to be nil or a Hash; was #{a[3]}"
-				end
-				# TODO post data
-			end
-		end
-	
-		def run
-			validate_input
-			p = profile
-			done_count = 0
-			# request monitors with a start method
-			request_monitors_start = request_monitors.select {|mon| mon.respond_to? :start}
-			# request monitors with a finish method
-			request_monitors_finish = request_monitors.select {|mon| mon.respond_to? :finish}
-			EM::run do
-				EM.set_quantum(p[:timer_granularity])
-				start = Time.now
-				setup_time = p[:time_for_setup]
-				actual_start = start + setup_time
-			
-				loop_count = 1
-			
-				max_time = @input.max {|a,b| a[0] <=> b[0]}[0]
-				#avg_time = @input.inject(0){|memo, i| i[0] + memo}.to_f / @input.length
-				if(p[:when_input_consumed] == :loop)
-					if(max_time < p[:run_for])
-						loop_count = (p[:run_for].to_f / max_time).ceil
-					end
-				end
-			
-				if(loop_count > 1)
-					# If we need to have multiple iterations of the data,
-					# we pad that on here
-					new_inputs = []
-					2.upto(loop_count) do |loop|
-						new_input = @input.map do |i|
-							new_i = i.dup
-							new_i[0] += max_time * (loop - 1)
-							new_i
-						end
-						new_inputs << new_input
-					end
-					new_inputs.each {|input| @input += input}
-				end
-				real_max_time = [max_time * loop_count, p[:run_for]].min
-				if(p[:rampup][0] != p[:rampup][1] || p[:rampup][0] != 1.0)
-					case p[:rampup_method]
-					when :linear
-						sr = 1.0 / p[:rampup][0]
-						fr = 1.0 / p[:rampup][1]
-						prev_time = 0
-						new_prev_time = 0
-						@input.map! do |a|
-							time = a[0].to_f
-							percent = time / real_max_time
-							fraction = sr + (fr - sr)*(time / real_max_time)
-							tmp = a[0]
-							a[0] = (time - prev_time)*fraction + new_prev_time
-							prev_time = tmp
-							new_prev_time = a[0]
-							a
-						end
-					end
-				end
-				total_urls = @input.length
-				
-				requests = []
-				# pregenerate requests
-				@input.each do |a|
-					requests << EventMachine::HttpRequest.new(a[2])
-				end
-
-				@input.each_with_index do |a, i|
-					scheduled_start = a[0]
-					request = OpenStruct.new(:url => a[2], :scheduled_start => scheduled_start, :index => i, :http_method => a[1])
-					delay = actual_start + scheduled_start
-					if(delay < Time.now)
-						raise "Not enough time allotted for setup!  Try increasing time_for_setup in your profile."
-					end
-					delay -= Time.now
-					EM::add_timer(delay) do
-						EM.defer do
-							begin
-								request.actual_start = Time.now - actual_start
-								http = requests[i].send(request.http_method, :timeout => p[:timeout])
-								request_monitors_start.each {|mon| mon.start(request)}
-							rescue => e
-								EM.next_tick do
-									raise e
-								end
-							end
-							callback = lambda {
-								time_finished = Time.now - actual_start
-								request.finish = time_finished
-								request.status = http.response_header.status
-								if(request.status == 0)
-									request.status = :timeout
-								end
-								begin
-									request_monitors_finish.each {|mon|	mon.finish(request)}
-								rescue => e
-									EM.next_tick do
-										raise e
-									end
-								end
-								done_count += 1
-								if(done_count == total_urls && p[:when_input_consumed] == :stop)
-									EM.stop
-								end
-							}
-							http.errback { callback.call }
-							http.callback { callback.call }
-						end
-					end
-				end
-				periodic_monitors.each do |mon|
-					interval = mon.respond_to?(:interval) ? mon.interval : 5
-					EM::add_timer(actual_start - Time.now - interval) do
-						EM::add_periodic_timer(interval) do
-							mon.tick(Time.now - actual_start)
-						end
-					end
-				end
-				run_for = actual_start + p[:run_for] - Time.now
-				EM::add_timer(run_for) do
-					#puts "run_for hit (#{run_for})"
-					EM.stop
-				end
-			end
-		end
-
-		def profile=(new_profile)
-			@profile = {
-				:time_for_setup => 1,
-				:timer_granularity => 50,
-				:run_for => 5,
-				:when_input_consumed => :stop,
-				:timeout => 1,
-				:rampup => [1.0, 1.0],
-				:rampup_method => :linear
-			}
-			if(new_profile.is_a? Hash)
-				@profile.merge!(new_profile)
-			end
-			# TODO validate profile
-		end
-		def profile
-			if(@profile.nil?)
-				self.profile = {}
-			end
-			@profile
-		end
-	end
-end

data/spec/profile.rb

@@ -1,90 +0,0 @@
-require 'spec/spec_helper'
-
-describe ReReplay, "profile options" do
-	it "respects 'time_for_setup' parameter" do
-		input = generate_input(2)
-		
-		r = ReReplay::Runner.new(input)
-		profile = {
-			:time_for_setup => 0.25
-		}
-		r.profile = profile
-		lambda { r.run }.should take_between(0.45.seconds).and(0.6.seconds)
-		validate_input(2)
-	end
-	it "respects 'timer_granularity' parameter" do
-		input = generate_input(2)
-		
-		r = ReReplay::Runner.new(input)
-		profile = {
-			:timer_granularity => 1000
-		}
-		r.profile = profile
-		
-		# normally this would finish at around 1.2 seconds, but with such a high
-		# timer resolution, it rounds up from 0.1 to 1
-		lambda { r.run }.should take_between(2.seconds).and(3.seconds)
-		validate_input(2)
-	end
-	it "respects 'run_for' parameter" do
-		input = generate_input(3, :interval => 1)
-		r = ReReplay::Runner.new(input)
-		profile = {
-			:run_for => 1
-		}
-		r.profile = profile
-		
-		# normally this would run for the full 4 seconds, but with run_for fixed at 2,
-		# it will stop then
-		lambda { r.run }.should take_between(2.seconds).and(2.1.seconds)
-		validate_input(1)
-	end
-	
-	it "respects 'when_input_consumed' parameter when :stop" do
-		input = generate_input(3, :interval => 0.5)
-		r = ReReplay::Runner.new(input)
-		profile = {
-			:run_for => 10,
-			:when_input_consumed => :stop
-		}
-		r.profile = profile
-		
-		lambda { r.run }.should take_between(2.5.seconds).and(2.7.seconds)
-		validate_input(3)
-	end
-	
-	it "respects 'when_input_consumed' parameter when :loop" do
-		input = generate_input(1, :interval => 0.5)
-		r = ReReplay::Runner.new(input)
-		profile = {
-			:run_for => 1.1,
-			:when_input_consumed => :loop
-		}
-		r.profile = profile
-		req_mon = ReReplay::RequestTimeMonitor.new
-		r.request_monitors << req_mon
-		
-		# normally this would take 1.5 seconds with :stop, but we're forcing it to loop and take 2 seconds
-		lambda { r.run }.should take_between(2.seconds).and(2.2.seconds)
-		req_mon.results.length.should == 2
-		validate_input(1, 2)
-	end
-	
-	# eh, this isn't that good a test because WebMock causes #to_timeout requests to timeout immediately
-	it "respects 'timeout' parameter" do
-		input = generate_input(1, :interval => 0.25, :timeout => true)
-		r = ReReplay::Runner.new(input)
-		profile = {
-			:timeout => 10,
-			:time_for_setup => 0.25
-		}
-		r.profile = profile
-		r.request_monitors << ReReplay::TimeoutFailer.new
-		
-		# normally this would take 4 seconds with :stop, but after 2 seconds we hit the timeout
-		
-		lambda { lambda { r.run }.should raise_error(StandardError, /TimeoutFailer/) }.should take_between(0.5.seconds).and(0.7.seconds)
-		validate_input(1)
-	end
-
-end