symphony 0.8.0 → 0.9.0

data/spec/symphony/queue_spec.rb

@@ -19,7 +19,7 @@ describe Symphony::Queue do
 	it "can build a Hash of AMQP options from its configuration" do
 		expect( described_class.amqp_session_options ).to include({
 			heartbeat: :server,
-			logger:    Loggability[ Symphony ],
+			logger:    Loggability[ Bunny ],
 		})
 	end
 
@@ -30,7 +30,7 @@ describe Symphony::Queue do
 			host: 'spimethorpe.com',
 			port: 23456,
 			heartbeat: :server,
-			logger:    Loggability[ Symphony ],
+			logger:    Loggability[ Bunny ],
 		})
 	end
 

data/spec/symphony/routing_spec.rb

@@ -2,6 +2,7 @@
 
 require_relative '../helpers'
 
+require 'ostruct'
 require 'symphony'
 require 'symphony/routing'
 
@@ -63,5 +64,301 @@ describe Symphony::Routing do
 		).to include( scheduled: '2 times an hour' )
 	end
 
+
+	describe "route-matching" do
+
+		let( :task_class ) do
+			Class.new( Symphony::Task ) do
+				include Symphony::Routing
+				def initialize( * )
+					super
+					@run_data = Hash.new {|h,k| h[k] = [] }
+				end
+				attr_reader :run_data
+			end
+		end
+
+
+		### Call the task's #work method with the same stuff Bunny would for the
+		### given eventname
+		def publish( eventname )
+			delivery_info = OpenStruct.new( routing_key: eventname )
+			properties = OpenStruct.new( content_type: 'application/json' )
+
+			metadata = {
+				delivery_info: delivery_info,
+				properties: properties,
+				content_type: properties.content_type,
+			}
+
+			payload = '[]'
+			return task.work( payload, metadata )
+		end
+
+
+		context "for one-segment explicit routing keys (`simple`)" do
+
+			let( :task ) do
+				task_class.on( 'simple' ) {|*args| self.run_data[:simple] << args }
+				task_class.new( :queue )
+			end
+
+
+			it "runs the job for routing keys that exactly match" do
+				expect {
+					publish( 'simple' )
+				}.to change { task.run_data[:simple].length }.by( 1 )
+			end
+
+
+			it "doesn't run the job for routing keys which don't exactly match" do
+				expect {
+					publish( 'notsimple' )
+				}.to_not change { task.run_data[:simple].length }
+			end
+
+
+			it "doesn't run the job for routing keys which contain additional segments" do
+				expect {
+					publish( 'simple.additional1' )
+				}.to_not change { task.run_data[:simple_splat].length }
+			end
+
+		end
+
+
+		context "for routing keys with one segment wildcard (`simple.*`)" do
+
+			let( :task ) do
+				task_class.on( 'simple.*' ) {|*args| self.run_data[:simple_splat] << args }
+				task_class.new( :queue )
+			end
+
+
+			it "runs the job for routing keys with the same first segment and one additional segment" do
+				expect {
+					publish( 'simple.additional1' )
+				}.to change { task.run_data[:simple_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with only the same first segment" do
+				expect {
+					publish( 'simple' )
+				}.to_not change { task.run_data[:simple_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with a different first segment" do
+				expect {
+					publish( 'notsimple.additional1' )
+				}.to_not change { task.run_data[:simple_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys which contain two additional segments" do
+				expect {
+					publish( 'simple.additional1.additional2' )
+				}.to_not change { task.run_data[:simple_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with a matching second segment" do
+				expect {
+					publish( 'prepended.simple.additional1' )
+				}.to_not change { task.run_data[:simple_splat].length }
+			end
+
+		end
+
+
+		context "for routing keys with two consecutive segment wildcards (`simple.*.*`)" do
+
+			let( :task ) do
+				task_class.on( 'simple.*.*' ) {|*args| self.run_data[:simple_splat_splat] << args }
+				task_class.new( :queue )
+			end
+
+
+			it "runs the job for routing keys which contain two additional segments" do
+				expect {
+					publish( 'simple.additional1.additional2' )
+				}.to change { task.run_data[:simple_splat_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with the same first segment and one additional segment" do
+				expect {
+					publish( 'simple.additional1' )
+				}.to_not change { task.run_data[:simple_splat_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with only the same first segment" do
+				expect {
+					publish( 'simple' )
+				}.to_not change { task.run_data[:simple_splat_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with a different first segment" do
+				expect {
+					publish( 'notsimple.additional1' )
+				}.to_not change { task.run_data[:simple_splat_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with a matching second segment" do
+				expect {
+					publish( 'prepended.simple.additional1' )
+				}.to_not change { task.run_data[:simple_splat_splat].length }
+			end
+
+		end
+
+
+		context "for routing keys with bracketing segment wildcards (`*.simple.*`)" do
+
+			let( :task ) do
+				task_class.on( '*.simple.*' ) {|*args| self.run_data[:splat_simple_splat] << args }
+				task_class.new( :queue )
+			end
+
+
+			it "runs the job for routing keys with a matching second segment" do
+				expect {
+					publish( 'prepended.simple.additional1' )
+				}.to change { task.run_data[:splat_simple_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys which contain two additional segments" do
+				expect {
+					publish( 'simple.additional1.additional2' )
+				}.to_not change { task.run_data[:splat_simple_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with the same first segment and one additional segment" do
+				expect {
+					publish( 'simple.additional1' )
+				}.to_not change { task.run_data[:splat_simple_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with only the same first segment" do
+				expect {
+					publish( 'simple' )
+				}.to_not change { task.run_data[:splat_simple_splat].length }
+			end
+
+
+			it "doesn't run the job for routing keys with a different first segment" do
+				expect {
+					publish( 'notsimple.additional1' )
+				}.to_not change { task.run_data[:splat_simple_splat].length }
+			end
+
+		end
+
+
+		context "for routing keys with a multi-segment wildcard (`simple.#`)" do
+
+			let( :task ) do
+				task_class.on( 'simple.#' ) {|*args| self.run_data[:simple_hash] << args }
+				task_class.new( :queue )
+			end
+
+
+			it "runs the job for routing keys with the same first segment and one additional segment" do
+				expect {
+					publish( 'simple.additional1' )
+				}.to change { task.run_data[:simple_hash].length }
+			end
+
+
+			it "runs the job for routing keys which contain two additional segments" do
+				expect {
+					publish( 'simple.additional1.additional2' )
+				}.to change { task.run_data[:simple_hash].length }
+			end
+
+
+			it "runs the job for routing keys with only the same first segment" do
+				expect {
+					publish( 'simple' )
+				}.to change { task.run_data[:simple_hash].length }
+			end
+
+
+			it "doesn't run the job for routing keys with a different first segment" do
+				expect {
+					publish( 'notsimple.additional1' )
+				}.to_not change { task.run_data[:simple_hash].length }
+			end
+
+
+			it "doesn't run the job for routing keys with a matching second segment" do
+				expect {
+					publish( 'prepended.simple.additional1' )
+				}.to_not change { task.run_data[:simple_hash].length }
+			end
+
+		end
+
+
+		context "for routing keys with bracketing multi-segment wildcards (`#.simple.#`)" do
+
+			let( :task ) do
+				task_class.on( '#.simple.#' ) {|*args| self.run_data[:hash_simple_hash] << args }
+				task_class.new( :queue )
+			end
+
+
+			it "runs the job for routing keys with the same first segment and one additional segment" do
+				expect {
+					publish( 'simple.additional1' )
+				}.to change { task.run_data[:hash_simple_hash].length }
+			end
+
+
+			it "runs the job for routing keys which contain two additional segments" do
+				expect {
+					publish( 'simple.additional1.additional2' )
+				}.to change { task.run_data[:hash_simple_hash].length }
+			end
+
+
+			it "runs the job for routing keys with only the same first segment" do
+				expect {
+					publish( 'simple' )
+				}.to change { task.run_data[:hash_simple_hash].length }
+			end
+
+
+			it "runs the job for three-segment routing keys with a matching second segment" do
+				expect {
+					publish( 'prepended.simple.additional1' )
+				}.to change { task.run_data[:hash_simple_hash].length }
+			end
+
+
+			it "runs the job for two-segment routing keys with a matching second segment" do
+				expect {
+					publish( 'prepended.simple' )
+				}.to change { task.run_data[:hash_simple_hash].length }
+			end
+
+
+			it "doesn't run the job for routing keys with a different first segment" do
+				expect {
+					publish( 'notsimple.additional1' )
+				}.to_not change { task.run_data[:hash_simple_hash].length }
+			end
+
+		end
+
+	end
+
 end
 

data/spec/symphony/statistics_spec.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../helpers'
+
+require 'symphony/statistics'
+
+
+describe Symphony::Statistics do
+
+
+	let( :including_class ) do
+		new_class = Class.new
+		new_class.instance_exec( described_class ) do |mixin|
+			include( mixin )
+		end
+	end
+
+	let( :object_with_statistics ) { including_class.new }
+
+
+	def make_samples( *counts )
+		start = 1414002605.0
+		offset = 0
+		return counts.each_with_object([]) do |count, accum|
+			accum << [ start + offset, count ]
+			offset += 1
+		end
+	end
+
+
+	it "can detect an upwards trend in a sample set" do
+		samples = make_samples( 1, 2, 2, 3, 3, 3, 4 )
+
+		object_with_statistics.sample_size = samples.size
+		object_with_statistics.samples.concat( samples )
+
+		expect( object_with_statistics.sample_values_increasing? ).to be_truthy
+	end
+
+
+	it "can detect a downwards trend in a sample set" do
+		samples = make_samples( 4, 3, 3, 2, 2, 2, 1 )
+
+		object_with_statistics.sample_size = samples.size
+		object_with_statistics.samples.concat( samples )
+
+		expect( object_with_statistics.sample_values_decreasing? ).to be_truthy
+	end
+
+
+	it "isn't fooled by transitory spikes" do
+		samples = make_samples( 1, 2, 222, 3, 2, 3, 2 )
+
+		object_with_statistics.sample_size = samples.size
+		object_with_statistics.samples.concat( samples )
+
+		expect( object_with_statistics.sample_values_increasing? ).to be_falsey
+	end
+
+
+	it "doesn't try to detect a trend with a sample set that's too small" do
+		upward_samples = make_samples( 1, 2, 2, 3, 3, 3, 4 )
+		object_with_statistics.samples.replace( upward_samples )
+		expect( object_with_statistics.sample_values_increasing? ).to be_falsey
+
+		downward_samples = make_samples( 4, 3, 3, 2, 2, 2, 1 )
+		object_with_statistics.samples.replace( downward_samples )
+		expect( object_with_statistics.sample_values_decreasing? ).to be_falsey
+	end
+end
+

data/spec/symphony/task_group/longlived_spec.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../../helpers'
+
+require 'symphony/task_group/longlived'
+
+describe Symphony::TaskGroup::LongLived do
+
+	let( :task ) do
+		Class.new( Symphony::Task ) do
+			extend Symphony::MethodUtilities
+
+			singleton_attr_accessor :has_before_forked, :has_after_forked, :has_run
+
+			def self::before_fork
+				self.has_before_forked = true
+			end
+			def self::after_fork
+				self.has_after_forked = true
+			end
+			def self::run
+				self.has_run = true
+			end
+		end
+	end
+
+	let( :task_group ) do
+		described_class.new( task, 2 )
+	end
+
+
+	# not enough samples
+	# trending up
+
+
+
+	it "doesn't start anything if it's throttled" do
+		# Simulate a child starting up and failing
+		task_group.instance_variable_set( :@last_child_started, Time.now )
+		task_group.adjust_throttle( 5 )
+
+		expect( Process ).to_not receive( :fork )
+		expect( task_group.adjust_workers ).to be_nil
+	end
+
+
+	context "when told to adjust its worker pool" do
+
+		it "starts an initial worker if it doesn't have any" do
+			expect( Process ).to receive( :fork ).and_return( 414 )
+			allow( Process ).to receive( :setpgid ).with( 414, 0 )
+
+			channel = double( Bunny::Channel )
+			queue = double( Bunny::Queue )
+			expect( Symphony::Queue ).to receive( :amqp_channel ).
+				and_return( channel )
+			expect( channel ).to receive( :queue ).
+				with( task.queue_name, passive: true, prefetch: 0 ).
+				and_return( queue )
+
+			task_group.adjust_workers
+
+			expect( task_group.started_one_worker? ).to be_truthy
+			expect( task_group.pids ).to include( 414 )
+		end
+
+
+		it "starts an additional worker if its work load is trending upward" do
+			samples = [ 1, 2, 2, 3, 3, 3, 4 ]
+			task_group.sample_size = samples.size
+
+			expect( Process ).to receive( :fork ).and_return( 525, 528 )
+			allow( Process ).to receive( :setpgid )
+
+			channel = double( Bunny::Channel )
+			queue = double( Bunny::Queue )
+			expect( Symphony::Queue ).to receive( :amqp_channel ).
+				and_return( channel )
+			expect( channel ).to receive( :queue ).
+				with( task.queue_name, passive: true, prefetch: 0 ).
+				and_return( queue )
+
+			allow( queue ).to receive( :consumer_count ).and_return( 1 )
+			expect( queue ).to receive( :message_count ).and_return( *samples )
+
+			start = 1414002605
+			start.upto( start + samples.size ) do |time|
+				Timecop.freeze( time ) do
+					task_group.adjust_workers
+				end
+			end
+
+			expect( task_group.started_one_worker? ).to be_truthy
+			expect( task_group.pids ).to include( 525, 528 )
+		end
+
+
+		it "starts an additional worker if its work load is holding steady at a non-zero value" do
+			pending "this being a problem we see in practice"
+			samples = [ 4, 4, 4, 5, 5, 4, 4 ]
+			task_group.sample_size = samples.size
+
+			expect( Process ).to receive( :fork ).and_return( 525, 528 )
+			allow( Process ).to receive( :setpgid )
+
+			channel = double( Bunny::Channel )
+			queue = double( Bunny::Queue )
+			expect( Symphony::Queue ).to receive( :amqp_channel ).
+				and_return( channel )
+			expect( channel ).to receive( :queue ).
+				with( task.queue_name, passive: true, prefetch: 0 ).
+				and_return( queue )
+
+			allow( queue ).to receive( :consumer_count ).and_return( 1 )
+			expect( queue ).to receive( :message_count ).and_return( *samples )
+
+			start = 1414002605
+			start.upto( start + samples.size ) do |time|
+				Timecop.freeze( time ) do
+					task_group.adjust_workers
+				end
+			end
+
+			expect( task_group.pids.size ).to eq( 2 )
+		end
+
+
+		it "doesn't start a worker if it's already running the maximum number of workers" do
+			samples =   [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]
+			consumers = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 2 ]
+			task_group.sample_size = samples.size - 3
+
+			expect( Process ).to receive( :fork ).and_return( 525, 528 )
+			allow( Process ).to receive( :setpgid )
+
+			channel = double( Bunny::Channel )
+			queue = double( Bunny::Queue )
+			expect( Symphony::Queue ).to receive( :amqp_channel ).
+				and_return( channel )
+			expect( channel ).to receive( :queue ).
+				with( task.queue_name, passive: true, prefetch: 0 ).
+				and_return( queue )
+
+			expect( queue ).to receive( :consumer_count ).and_return( *consumers )
+			expect( queue ).to receive( :message_count ).and_return( *samples )
+
+			start = 1414002605
+			start.upto( start + samples.size ) do |time|
+				Timecop.freeze( time ) do
+					task_group.adjust_workers
+				end
+			end
+
+			expect( task_group.pids.size ).to eq( 2 )
+		end
+
+
+		it "doesn't start anything if its work load is holding steady at zero" do
+			samples = [ 0, 1, 0, 0, 0, 0, 1, 0, 0 ]
+			task_group.sample_size = samples.size - 3
+
+			expect( Process ).to receive( :fork ).and_return( 525 )
+			allow( Process ).to receive( :setpgid )
+
+			channel = double( Bunny::Channel )
+			queue = double( Bunny::Queue )
+			expect( Symphony::Queue ).to receive( :amqp_channel ).
+				and_return( channel )
+			expect( channel ).to receive( :queue ).
+				with( task.queue_name, passive: true, prefetch: 0 ).
+				and_return( queue )
+
+			allow( queue ).to receive( :consumer_count ).and_return( 1 )
+			expect( queue ).to receive( :message_count ).and_return( *samples )
+
+			start = 1414002605
+			start.upto( start + samples.size ) do |time|
+				Timecop.freeze( time ) do
+					task_group.adjust_workers
+				end
+			end
+
+			expect( task_group.pids.size ).to eq( 1 )
+		end
+
+
+		it "doesn't start anything if its work load is trending downward" do
+			samples = [ 4, 3, 3, 2, 2, 2, 1, 1, 0, 0 ]
+			task_group.sample_size = samples.size
+
+			expect( Process ).to receive( :fork ).and_return( 525 )
+			allow( Process ).to receive( :setpgid )
+
+			channel = double( Bunny::Channel )
+			queue = double( Bunny::Queue )
+			expect( Symphony::Queue ).to receive( :amqp_channel ).
+				and_return( channel )
+			expect( channel ).to receive( :queue ).
+				with( task.queue_name, passive: true, prefetch: 0 ).
+				and_return( queue )
+
+			allow( queue ).to receive( :consumer_count ).and_return( 1 )
+			expect( queue ).to receive( :message_count ).and_return( *samples )
+
+			start = 1414002605
+			start.upto( start + samples.size ) do |time|
+				Timecop.freeze( time ) do
+					task_group.adjust_workers
+				end
+			end
+
+			expect( task_group.started_one_worker? ).to be_truthy
+			expect( task_group.pids.size ).to eq( 1 )
+		end
+
+	end
+
+end
+