symphony 0.8.0 → 0.9.0

data/lib/symphony/task_group/longlived.rb

@@ -0,0 +1,98 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'set'
+require 'symphony/task_group' unless defined?( Symphony::TaskGroup )
+require 'symphony/statistics'
+
+
+# A task group for the 'longlived' work model.
+class Symphony::TaskGroup::LongLived < Symphony::TaskGroup
+	include Symphony::Statistics
+
+
+	### Create a LongLived task group for the specified +task_class+ that will
+	### run a maximum of +max_workers+.
+	def initialize( task_class, max_workers )
+		super
+
+		@queue              = nil
+		@pids               = Set.new
+		@started_one_worker = false
+	end
+
+
+	######
+	public
+	######
+
+	# The PIDs of the child this task group manages
+	attr_reader :pids
+
+
+	### Return +true+ if the task group should scale up by one.
+	def needs_a_worker?
+		return true unless self.started_one_worker?
+		return false unless @queue
+		return false if @queue.consumer_count >= self.max_workers
+		return self.sample_values_increasing?
+	end
+
+
+	### Returns +true+ if the group has started at least one worker. Used to avoid
+	### racing to start workers when one worker has started, but we haven't yet connected
+	### to AMQP to get consumer count yet.
+	def started_one_worker?
+		return @started_one_worker
+	end
+
+
+	### If the number of workers is not at the maximum, start some.
+	def adjust_workers
+		self.sample_queue_status
+
+		return nil if self.throttled?
+
+		if self.needs_a_worker?
+			self.log.info "Too few workers for (%s); spinning one up." % [ self.task_class.name ]
+			pid = self.start_worker( @started_one_worker )
+			self.pids.add( pid )
+			return [ pid ]
+		end
+
+		return nil
+	end
+
+
+	### Add the current number of workers to the samples.
+	def sample_queue_status
+		return unless @queue
+		self.add_sample( @queue.message_count )
+	end
+
+
+	### Overridden to grab a Bunny::Queue for monitoring when the first
+	### worker starts.
+	def start_worker( exit_on_idle=false )
+		@started_one_worker = true
+
+		pid = super
+		self.log.info "Start a new worker at pid %d" % [ pid ]
+
+		unless @queue
+			begin
+				channel = Symphony::Queue.amqp_channel
+				@queue = channel.queue( self.task_class.queue_name, passive: true, prefetch: 0 )
+				self.log.debug "  got the 0-prefetch queue"
+			rescue Bunny::NotFound => err
+				self.log.info "Child hasn't created the queue yet; deferring"
+				Symphony::Queue.reset
+			end
+		end
+
+		return pid
+	end
+
+end # class Symphony::TaskGroup::LongLived
+
+

data/lib/symphony/task_group/oneshot.rb

@@ -0,0 +1,25 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'symphony/task_group' unless defined?( Symphony::TaskGroup )
+
+
+# A task group for the 'oneshot' work model.
+class Symphony::TaskGroup::Oneshot < Symphony::TaskGroup
+
+	### If the number of workers is not at the maximum, start some.
+	def adjust_workers
+		return nil if self.throttled?
+
+		missing_workers = []
+		missing_count = self.max_workers - self.workers.size
+		missing_count.times do
+			missing_workers << self.start_worker
+		end
+
+		return missing_workers.empty? ? nil : missing_workers
+	end
+
+end # class Symphony::TaskGroup::Oneshot
+
+

data/lib/symphony/tasks/oneshot_simulator.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require 'tmpdir'
+require 'symphony/task' unless defined?( Symphony::Task )
+require 'symphony/metrics'
+
+# A spike to test out various task execution outcomes.
+class OneshotSimulator < Symphony::Task
+	prepend Symphony::Metrics
+
+	# Simulate processing all events
+	subscribe_to '#'
+
+	# Fetch 100 events at a time
+	prefetch 100
+
+	# Only allow 2 seconds for work to complete before rejecting or retrying.
+	timeout 2.0, action: :retry
+
+	# Run once per job
+	work_model :oneshot
+
+
+
+	######
+	public
+	######
+
+	#
+	# Task API
+	#
+
+	# Do the ping.
+	def work( payload, metadata )
+		if metadata[:properties][:headers] &&
+		   metadata[:properties][:headers]['x-death']
+			puts "Deaths! %p" % [ metadata[:properties][:headers]['x-death'] ]
+		end
+
+		val = Random.rand
+		case
+		when val < 0.33
+			$stderr.puts "Simulating an error in the task (reject)."
+			raise "OOOOOPS!"
+		when val < 0.66
+			$stderr.puts "Simulating a soft failure in the task (reject+requeue)."
+			return false
+		when val < 0.88
+			$stderr.puts "Simulating a timeout case"
+			sleep( self.class.timeout + 1 )
+		else
+			$stderr.puts "Simulating a successful task run (accept)"
+			puts( payload.inspect )
+			return true
+		end
+	end
+
+
+end # class OneshotSimulator
+

data/lib/symphony/tasks/simulator.rb

@@ -13,10 +13,10 @@ class Simulator < Symphony::Task
 	subscribe_to '#'
 
 	# Fetch 100 events at a time
-	prefetch 100
+	prefetch 10
 
 	# Only allow 2 seconds for work to complete before rejecting or retrying.
-	timeout 2.0, action: :retry
+	# timeout 2.0, action: :retry
 
 
 	######
@@ -34,22 +34,26 @@ class Simulator < Symphony::Task
 			puts "Deaths! %p" % [ metadata[:properties][:headers]['x-death'] ]
 		end
 
-		val = Random.rand
-		case
-		when val < 0.33
-			$stderr.puts "Simulating an error in the task (reject)."
-			raise "OOOOOPS!"
-		when val < 0.66
-			$stderr.puts "Simulating a soft failure in the task (reject+requeue)."
-			return false
-		when val < 0.88
-			$stderr.puts "Simulating a timeout case"
-			sleep( self.class.timeout + 1 )
-		else
-			$stderr.puts "Simulating a successful task run (accept)"
-			puts( payload.inspect )
-			return true
-		end
+		sleep rand( 0.0 .. 2.0 )
+
+		# val = Random.rand
+		# case
+		# when val < 0.33
+		# 	$stderr.puts "Simulating an error in the task (reject)."
+		# 	raise "OOOOOPS!"
+		# when val < 0.66
+		# 	$stderr.puts "Simulating a soft failure in the task (reject+requeue)."
+		# 	return false
+		# when val < 0.88
+		# 	$stderr.puts "Simulating a timeout case"
+		# 	sleep( self.class.timeout + 1 )
+		# else
+		# 	$stderr.puts "Simulating a successful task run (accept)"
+		# 	puts( payload.inspect )
+		# 	return true
+		# end
+
+		true
 	end
 
 

data/spec/helpers.rb

@@ -8,14 +8,79 @@ require 'loggability'
 require 'loggability/spechelpers'
 require 'configurability'
 require 'configurability/behavior'
+require 'timecop'
 
+require 'symphony'
+require 'symphony/task'
 require 'rspec'
 
 Loggability.format_with( :color ) if $stdout.tty?
 
 
 ### RSpec helper functions.
-module Loggability::SpecHelpers
+module Symphony::SpecHelpers
+
+	class TestTask < Symphony::Task
+
+		# Don't ever really try to handle messages.
+		def start_handling_messages
+		end
+	end
+
+
+	class DummySession
+
+		class Queue
+			def initialize( channel )
+				@channel = channel
+			end
+			attr_reader :channel
+			def name
+				return 'dummy_queue_name'
+			end
+			def subscribe_with( * )
+			end
+			def message_count
+				return 1
+			end
+		end
+		class Channel
+			def initialize
+				@queue = nil
+				@exchange = nil
+			end
+			def queue( name, opts={} )
+				return @queue ||= DummySession::Queue.new( self )
+			end
+			def topic( * )
+				return @exchange ||= DummySession::Exchange.new
+			end
+			def prefetch( * )
+			end
+			def number
+				return 1
+			end
+			def close; end
+		end
+
+		class Exchange
+		end
+
+		def initialize
+			@channel = nil
+		end
+
+		def start
+			return true
+		end
+
+		def create_channel
+			return @channel ||= DummySession::Channel.new
+		end
+
+		def close; end
+	end
+
 end
 
 
@@ -30,6 +95,7 @@ RSpec.configure do |config|
 	end
 
 	config.include( Loggability::SpecHelpers )
+	config.include( Symphony::SpecHelpers )
 end
 
 # vim: set nosta noet ts=4 sw=4:

data/spec/symphony/daemon_spec.rb

@@ -1,29 +1,42 @@
 # -*- ruby -*-
 #encoding: utf-8
+# vim: set noet nosta sw=4 ts=4 :
+
 
 require_relative '../helpers'
 
 require 'symphony/daemon'
+require 'symphony/task'
 
-class TestTask < Symphony::Task
-
-	# Don't ever really try to handle messages.
-	def start_handling_messages
-	end
-
+class Test1Task < Symphony::Task
+	subscribe_to '#'
+end
+class Test2Task < Symphony::Task
+	subscribe_to '#'
+end
+class Test3Task < Symphony::Task
+	subscribe_to '#'
 end
 
 
 describe Symphony::Daemon do
 
+	before( :all ) do
+		@pids = ( 200..65534 ).cycle
+	end
+
 	before( :each ) do
-		allow( Process ).to receive( :fork ).and_yield
+		allow( Process ).to receive( :fork ).and_yield.and_return( @pids.next )
 		allow( Process ).to receive( :setpgid )
-		Symphony::Daemon.configure( tasks: ['test', 'test'] )
+		allow( Process ).to receive( :kill )
+		Symphony.configure( tasks: ['test', 'test'] )
+
+		dummy_session = Symphony::SpecHelpers::DummySession.new
+		allow( Bunny::Session ).to receive( :new ).and_return( dummy_session )
 	end
 
 
-	let( :daemon ) { described_class.new }
+	let!( :daemon ) { described_class.new }
 
 
 	it "can report what version it is" do
@@ -38,28 +51,8 @@ describe Symphony::Daemon do
 		).to match( /\(build \p{Xdigit}+\)/i )
 	end
 
-	it "loads a task class for each configured task" do
-		expect( daemon.tasks.size ).to eq( 2 )
-		expect( daemon.tasks ).to include( TestTask )
-	end
-
-	it "forks a child for each task" do
-		expect( Process ).to receive( :fork ).twice.and_yield
-		expect( TestTask ).to receive( :after_fork ).twice
-		expect( TestTask ).to receive( :run ).and_return( 118, 119 ) # pids
-
-		daemon.simulate_signal( :TERM )
-
-		status = double( Process::Status, :success? => true )
-		expect( Process ).to receive( :waitpid2 ).
-			with( -1, Process::WNOHANG|Process::WUNTRACED ).
-			and_return( [118, status], [119, status], nil )
-
-		daemon.run_tasks
-	end
-
 	it "exits gracefully on one SIGINT" do
-		daemon.tasks.clear
+		Symphony.tasks.clear
 		thr = Thread.new { daemon.run_tasks }
 		sleep 0.1 until daemon.running? || !thr.alive?
 
@@ -70,7 +63,7 @@ describe Symphony::Daemon do
 	end
 
 	it "exits gracefully on one SIGQUIT" do
-		daemon.tasks.clear
+		Symphony.tasks.clear
 		thr = Thread.new { daemon.run_tasks }
 		sleep 0.1 until daemon.running? || !thr.alive?
 
@@ -80,5 +73,64 @@ describe Symphony::Daemon do
 		}.to change { daemon.running? }.from( true ).to( false )
 	end
 
+	it "re-reads its configuration on a SIGHUP" do
+		Symphony.tasks.clear
+		thr = Thread.new { daemon.run_tasks }
+		sleep 0.1 until daemon.running? || !thr.alive?
+
+		config = double( Configurability::Config )
+		expect( Symphony ).to receive( :config ).at_least( :once ).and_return( config )
+		expect( config ).to receive( :reload )
+
+		daemon.simulate_signal( :HUP )
+		daemon.stop
+		thr.join( 2 )
+	end
+
+	it "adjusts its tasks when its config is reloaded" do
+		config = Configurability.default_config
+		config.symphony.tasks = [ 'test1', 'test2' ]
+		# config.logging.__default__ = 'debug'
+		config.install
+
+		allow( Symphony::Task ).to receive( :exit )
+		allow( Process ).to receive( :kill ) do |sig, pid|
+			status = instance_double( Process::Status, :success? => true )
+			daemon.task_pids[ pid ].on_child_exit( pid, status )
+			daemon.task_pids.delete( pid )
+		end
+
+		begin
+			thr = Thread.new { daemon.run_tasks }
+			sleep 0.1 until daemon.running? || !thr.alive?
+
+			daemon.task_groups.each do |task_class, task_group|
+				case task_class
+				when Test1Task
+					expect( task_group ).to receive( :restart_workers ) do
+						daemon.task_pids.clear
+					end
+				when Test2Task
+					expect( task_group ).to receive( :stop_workers ) do
+						daemon.task_pids.clear
+					end
+				end
+			end
+
+			expect( config ).to receive( :reload ) do
+				config.symphony.tasks = [ 'test1', 'test3' ]
+				config.install
+			end
+
+			expect {
+				daemon.reload_config
+			}.to change { daemon.task_groups }
+
+		ensure
+			daemon.stop
+			thr.join( 2 )
+		end
+	end
+
 end