symphony 0.3.0.pre20140327204419 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a18ff1610ed82fd8b70b2101553dd540b0855e7
-  data.tar.gz: 13658dcf21296bcb6fc7094cb68fddb263ace02f
+  metadata.gz: 2ba69bb4284905cfc71472c6b5629c3c063dd546
+  data.tar.gz: 2bf944cdfce3b98d5eaf91732a9ef62f093eef65
 SHA512:
-  metadata.gz: dccd19e742e0817f2de1a8555490aa193f20abde32ea2ecc120b330d1edc5fed2ee511ecbd6097ecd692af1c55b2e1e5028dcd1b7c1040429f6509db875b2049
-  data.tar.gz: 33c92a0f1a2a84b13982a25321af137b0c445d9ac2950372568066fcd4e8329e51af5be0ac5646408940cf32b047be7208b6124ca38604969eb916b63508e3da
+  metadata.gz: 3c656bb9f2ce03e943eda18baec1eac6e7d3c9aad80c771db522cc4c38984e9fdf214fe8ddb0379208775f050877badac843507c0a3cb575ac10c05b8ddbbda6
+  data.tar.gz: 2125f48a7132995aa9a60465e430b656cedf198f48c6e5688e7f317b911f63d0e45c1f2bc5bde4e8b69c7f057397536dcfe39acd60f65c31c2ebb232d16a2e4c

data/History.rdoc

@@ -1,6 +1,6 @@
-== v0.3.0 []
+== v0.3.0 [2014-03-28] Michael Granger <ged@FaerieMUD.org>
 
-Rewritten for AMQP (and possibly other similar message buses)
+Rewritten for AMQP and renamed to Symphony.
 
 
 == v0.1.0 [2012-09-19] Michael Granger <ged@FaerieMUD.org>

data/Manifest.txt

@@ -23,8 +23,9 @@ lib/symphony/tasks/pinger.rb
 lib/symphony/tasks/simulator.rb
 lib/symphony/tasks/ssh.rb
 lib/symphony/tasks/sshscript.rb
+spec/helpers.rb
+spec/symphony/daemon_spec.rb
 spec/symphony/mixins_spec.rb
 spec/symphony/queue_spec.rb
 spec/symphony/task_spec.rb
 spec/symphony_spec.rb
-spec/helpers.rb

data/Rakefile

@@ -15,7 +15,6 @@ Hoe.plugin :deveiate
 Hoe.plugin :bundler
 
 Hoe.plugins.delete :rubyforge
-Hoe.plugins.delete :gemcutter
 
 hoespec = Hoe.spec 'symphony' do |spec|
 	spec.readme_file = 'README.rdoc'

data/TODO.md

@@ -1,5 +1,6 @@
 
 [ ] Convert routing / metrics to 'plugins' syntax (inside/outside for prepend/include)
-[ ] Process management w/ Daemon
 [ ] Update pinger/ssh/sshscript
-
+[ ] Per Task throttling for daemon
+[ ] Task scaling (min/max settings), check queue backlog during received message
+[ ] Make the block of routes declared with on() method accept various arities

data/USAGE.rdoc

@@ -252,10 +252,7 @@ name of the task.  You can override this per-task.
 
 = Plugins
 
-Plugins change or enhance the behavior of a Symphony::Task.  They
-are enabled with the 'plugin' option, with the name of the plugin (or
-comma separated plugins) as a symbol argument.  Symphony currently
-ships with two.
+Plugins change or enhance the behavior of a Symphony::Task.
 
 
 == Metrics
@@ -265,8 +262,13 @@ of a task worker to the log.  It shows processed message averages and
 resource consumption summaries at the "info" log level, and also changes
 the process name to display a total count and jobs per second rate.
 
-	plugin :metrics
+	require 'symphony/metrics'
 
+	class Test < Symphony::Task
+		prepend Symphony::Metrics
+		# ...
+	end
+		
 
 == Routing
 
@@ -275,10 +277,10 @@ in the #work method, and instead links individual units of work to
 separate #on declarations.  This makes tasks that are designed to
 receive multiple message topics much easier to maintain and test.
 
+	require 'symphony/routing'
+
 	class Test < Symphony::Task
-		
-		# Use the routing plugin
-		plugin :routing
+		include Symphony::Routing
 		
 		on 'users.create', 'workstation.create' do |payload, metadata|
 			puts "A user or workstation wants to be created!"

data/bin/symphony

@@ -1,8 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'symphony'
-require 'symphony/worker_daemon'
+require 'symphony/daemon'
 
 Encoding.default_internal = Encoding::UTF_8
 Symphony::Daemon.run( ARGV )
-

data/lib/symphony.rb

@@ -15,11 +15,11 @@ module Symphony
 	VERSION = '0.3.0'
 
 	# Version-control revision constant
-	REVISION = %q$Revision$
+	REVISION = %q$Revision: cf61ced7d585 $
 
 
 	# The name of the environment variable to check for config file overrides
-	CONFIG_ENV = 'GROUNDCONTROL_CONFIG'
+	CONFIG_ENV = 'SYMPHONY_CONFIG'
 
 	# The path to the default config file
 	DEFAULT_CONFIG_FILE = 'etc/config.yml'

data/lib/symphony/daemon.rb

@@ -3,19 +3,17 @@
 
 require 'configurability'
 require 'loggability'
-require 'fcntl'
-require 'trollop'
 
 require 'symphony' unless defined?( Symphony )
-require 'symphony/worker'
 require 'symphony/task'
+require 'symphony/signal_handling'
 
-
-# The Symphony worker daemon. Watches a Symphony job queue, and runs the tasks
-# contained in the jobs it fetches.
+# A daemon which manages startup and shutdown of one or more Workers
+# running Tasks as they are published from a queue.
 class Symphony::Daemon
 	extend Loggability,
-	       Configurability
+	       Configurability,
+	       Symphony::MethodUtilities
 
 	include Symphony::SignalHandling
 
@@ -24,27 +22,42 @@ class Symphony::Daemon
 	log_to :symphony
 
 	# Configurability API -- use the 'worker_daemon' section of the config
-	config_key :worker_daemon
+	config_key :symphony
+
 
+	# Default configuration
+	CONFIG_DEFAULTS = {
+		throttle_max:    16,
+		throttle_factor: 1,
+		tasks: []
+	}
 
 	# Signals we understand
 	QUEUE_SIGS = [
-		:QUIT, :INT, :TERM, :HUP,
+		:QUIT, :INT, :TERM, :HUP, :CHLD,
 		# :TODO: :WINCH, :USR1, :USR2, :TTIN, :TTOU
 	]
 
-	# The maximum throttle value caused by failing workers
-	THROTTLE_MAX = 16
-
-	# The factor which controls how much incrementing the throttle factor
-	# affects the pause between workers being started.
-	THROTTLE_FACTOR = 2
 
 
 	#
 	# Class methods
 	#
 
+	##
+	# The maximum throttle factor caused by failing workers
+	singleton_attr_accessor :throttle_max
+
+	##
+	# The factor which controls how much incrementing the throttle factor
+	# affects the pause between workers being started.
+	singleton_attr_accessor :throttle_factor
+
+	##
+	# The Array of Symphony::Task classes that are configured to run
+	singleton_attr_accessor :tasks
+
+
 	### Get the daemon's version as a String.
 	def self::version_string( include_buildnum=false )
 		vstring = "%s %s" % [ self.name, Symphony::VERSION ]
@@ -56,37 +69,41 @@ class Symphony::Daemon
 	end
 
 
-	### Start the daemon.
-	def self::run( argv )
-		Loggability.format_with( :color ) if $stdout.tty?
+	### Configurability API -- configure the daemon.
+	def self::configure( config=nil )
+		config = self.defaults.merge( config || {} )
 
-		progname = File.basename( $0 )
-		opts = Trollop.options do
-			banner "Usage: #{progname} OPTIONS"
-			version self.version_string( true )
+		self.throttle_max    = config[:throttle_max]
+		self.throttle_factor = config[:throttle_factor]
+
+		self.tasks = self.load_configured_tasks( config[:tasks] )
+	end
 
-			opt :config, "The config file to load instead of the default",
-				:type => :string
-			opt :crew_size, "Number of workers to maintain.", :default => DEFAULT_CREW_SIZE
-			opt :queue, "The name of the queue to monitor.", :default => '_default_'
 
-			opt :debug, "Turn on debugging output."
+	### Load the tasks with the specified +task_names+ and return them
+	### as an Array.
+	def self::load_configured_tasks( task_names )
+		return task_names.map do |task_name|
+			Symphony::Task.get_subclass( task_name )
 		end
+	end
+
+
+	### Start the daemon.
+	def self::run( args )
+		Loggability.format_with( :color ) if $stdout.tty?
 
 		# Turn on debugging if it's enabled
-		if opts.debug
-			$DEBUG = true
-			Loggability.level = :debug
-		end
+		Loggability.level = :debug if $DEBUG
 
 		# Now load the config file
-		Symphony.load_config( opts.config )
+		Symphony.load_config( args.shift )
 
 		# Re-enable debug-level logging if the config reset it
-		Loggability.level = :debug if opts.debug
+		Loggability.level = :debug if $DEBUG
 
 		# And start the daemon
-		self.new( opts ).run
+		self.new.run
 	end
 
 
@@ -95,13 +112,11 @@ class Symphony::Daemon
 	#
 
 	### Create a new Daemon instance.
-	def initialize( options )
-		@options             = options
-		@queue               = Symphony::Queue.new( options.queue )
-
+	def initialize
 		# Process control
-		@crew_size           = options.crew_size
-		@crew_workers        = []
+		@tasks               = self.class.tasks
+
+		@running_tasks       = {}
 		@running             = false
 		@shutting_down       = false
 		@throttle            = 0
@@ -115,11 +130,8 @@ class Symphony::Daemon
 	public
 	######
 
-	# The Array of PIDs of currently-running workers
-	attr_reader :crew_workers
-
-	# The maximum number of children to have running at any given time
-	attr_reader :crew_size
+	# The Hash of PIDs to task class
+	attr_reader :running_tasks
 
 	# A self-pipe for deferred signal-handling
 	attr_reader :selfpipe
@@ -145,19 +157,13 @@ class Symphony::Daemon
 
 	### Set up the daemon and start running.
 	def run
-		self.log.info "Starting worker supervisor"
-
-		# Become session leader if we can
-		if Process.euid.zero?
-			sid = Process.setsid
-			self.log.debug "  became session leader of new session: %d" % [ sid ]
-		end
+		self.log.info "Starting task daemon"
 
 		# Set up traps for common signals
 		self.set_signal_traps( *QUEUE_SIGS )
 
 		# Listen for new jobs and handle them as they come in
-		self.start_handling_jobs
+		self.run_tasks
 
 		# Restore the default signal handlers
 		self.reset_signal_traps( *QUEUE_SIGS )
@@ -168,26 +174,22 @@ class Symphony::Daemon
 
 	### The main loop of the daemon -- wait for signals, children dying, or jobs, and
 	### take appropriate action.
-	def start_handling_jobs
+	def run_tasks
 		@running = true
 
 		self.log.debug "Starting supervisor loop..."
 		while self.running?
 			self.start_missing_children unless self.shutting_down?
-
-			timeout = self.throttle_seconds
-			timeout = nil if timeout.zero?
-
 			self.wait_for_signals
 			self.reap_children
 		end
-		self.log.info "Supervisor job loop done."
 
 	rescue => err
 		self.log.fatal "%p in job-handler loop: %s" % [ err.class, err.message ]
 		self.log.debug { '  ' + err.backtrace.join("\n  ") }
 
 	ensure
+		self.log.info "Done running tasks."
 		@running = false
 		self.stop
 	end
@@ -202,18 +204,18 @@ class Symphony::Daemon
 
 		self.log.warn "Stopping children."
 		3.times do |i|
-			self.reap_children( *self.crew_workers )
+			self.reap_children
 			sleep( 1 )
 			self.kill_children
 			sleep( 1 )
-			break if self.crew_workers.empty?
+			break if self.running_tasks.empty?
 			sleep( 1 )
-		end unless self.crew_workers.empty?
+		end unless self.running_tasks.empty?
 
 		# Give up on our remaining children.
 		Signal.trap( :CHLD, :IGNORE )
-		if !self.crew_workers.empty?
-			self.log.warn "  %d workers remain: sending KILL" % [ self.crew_workers.length ]
+		if !self.running_tasks.empty?
+			self.log.warn "  %d workers remain: sending KILL" % [ self.running_tasks.length ]
 			self.kill_children( :KILL )
 		end
 	end
@@ -232,11 +234,11 @@ class Symphony::Daemon
 
 	### Handle signals.
 	def handle_signal( sig )
-		self.log.debug "Handling signal %s" % [ sig ]
+		self.log.debug "Handling signal %s in PID %d" % [ sig, Process.pid ]
 		case sig
 		when :INT, :TERM
 			if @running
-				self.log.warn "%s signal: immediate shutdown" % [ sig ]
+				self.log.warn "%s signal: graceful shutdown" % [ sig ]
 				@running = false
 			else
 				self.ignore_signals
@@ -250,6 +252,7 @@ class Symphony::Daemon
 			self.reload_config
 
 		when :CHLD
+			self.log.info "Got SIGCHLD."
 			# Just need to wake up, nothing else necessary
 
 		else
@@ -259,10 +262,10 @@ class Symphony::Daemon
 	end
 
 
-	### Fill out the work crew with new children if necessary
+	### Start any tasks which aren't already running
 	def start_missing_children
-		missing_count = self.crew_size - self.crew_workers.length
-		return unless missing_count > 0
+		missing_tasks = self.find_missing_tasks
+		return if missing_tasks.empty?
 
 		# Return unless the throttle period has lapsed
 		unless self.throttle_seconds < (Time.now - @last_child_started)
@@ -271,21 +274,37 @@ class Symphony::Daemon
 			return
 		end
 
-		self.log.debug "Starting %d workers for a crew of %d" % [ missing_count, self.crew_size ]
-		missing_count.times do |i|
-			pid = self.start_worker
-			self.log.debug "  started worker %d" % [ pid ]
-			self.crew_workers << pid
+		self.log.debug "Starting %d tasks out of %d" % [ missing_tasks.size, self.class.tasks.size ]
+		missing_tasks.each do |task_class|
+			pid = self.start_worker( task_class )
+			self.log.debug "  started task %p at pid %d" % [ task_class, pid ]
+			self.running_tasks[ pid ] = task_class
 		end
 
 		@last_child_started = Time.now
 	end
 
 
+	### Examine the running tasks and return any that are missing.
+	def find_missing_tasks
+		missing_tasks = []
+
+		self.class.tasks.uniq.each do |task_type|
+			count = self.class.tasks.count( task_type )
+			missing = count - self.running_tasks.values.count( task_type )
+			missing.times do
+				missing_tasks << task_type
+			end
+		end
+
+		return missing_tasks
+	end
+
+
 	### Return the number of seconds between child startup times.
 	def throttle_seconds
 		return 0 unless @throttle.nonzero?
-		return Math.log( @throttle ) * THROTTLE_FACTOR
+		return Math.log( @throttle ) * self.class.throttle_factor
 	end
 
 
@@ -295,18 +314,18 @@ class Symphony::Daemon
 		self.log.debug "Adjusting worker throttle by %d" % [ adjustment ]
 		@throttle += adjustment
 		@throttle = 0 if @throttle < 0
-		@throttle = THROTTLE_MAX if @throttle > THROTTLE_MAX
+		@throttle = self.class.throttle_max if @throttle > self.class.throttle_max
 	end
 
 
 	### Kill all current children with the specified +signal+. Returns +true+ if the signal was
 	### sent to one or more children.
 	def kill_children( signal=:TERM )
-		return false if self.crew_workers.empty?
+		return false if self.running_tasks.empty?
 
-		self.log.info "Sending %s signal to %d workers: %p." %
-			 [ signal, self.crew_workers.length, self.crew_workers ]
-		Process.kill( signal, *self.crew_workers )
+		self.log.info "Sending %s signal to %d task pids: %p." %
+			 [ signal, self.running_tasks.length, self.running_tasks.keys ]
+		Process.kill( signal, *self.running_tasks.keys )
 
 		return true
 	rescue Errno::ESRCH
@@ -314,11 +333,18 @@ class Symphony::Daemon
 	end
 
 
-	### Start a new Symphony::Worker and return its PID.
-	def start_worker
+	### Start a new Symphony::Task and return its PID.
+	def start_worker( task_class )
 		return if self.shutting_down?
-		self.log.debug "Starting a worker."
-		return Symphony::Worker.start( self.queue )
+
+		self.log.debug "Starting a %p." % [ task_class ]
+		pid = Process.fork do
+			task_class.after_fork
+			task_class.run
+		end
+		Process.setpgid( pid, 0 )
+
+		return pid
 	end
 
 
@@ -340,28 +366,30 @@ class Symphony::Daemon
 
 
 	### Reap any children that have died within the caller's process group
-	### and remove them from the work crew.
+	### and remove them from the Hash of running tasks.
 	def reap_any_child
 		self.log.debug "  no pids; waiting on any child in this process group"
 
-		pid, status = Process.waitpid2( -1, Process::WNOHANG )
+		pid, status = Process.waitpid2( -1, Process::WNOHANG|Process::WUNTRACED )
+		self.log.debug "  waitpid2 returned: [ %p, %p ]" % [ pid, status ]
 		while pid
 			self.adjust_throttle( status.success? ? -1 : 1 )
 			self.log.debug "Child %d exited: %p." % [ pid, status ]
-			self.crew_workers.delete( pid )
+			self.running_tasks.delete( pid )
 
-			pid, status = Process.waitpid2( -1, Process::WNOHANG )
+			pid, status = Process.waitpid2( -1, Process::WNOHANG|Process::WUNTRACED )
+			self.log.debug "  waitpid2 returned: [ %p, %p ]" % [ pid, status ]
 		end
 	end
 
 
 	### Wait on the child associated with the given +pid+, deleting it from the
-	### crew workers if successful.
+	### running tasks Hash if successful.
 	def reap_specific_child( pid )
 		spid, status = Process.waitpid2( pid )
 		if spid
 			self.log.debug "Child %d exited: %p." % [ spid, status ]
-			self.crew_workers.delete( spid )
+			self.running_tasks.delete( spid )
 			self.adjust_throttle( status.success? ? -1 : 1 )
 		else
 			self.log.debug "Child %d no reapy." % [ pid ]

data/lib/symphony/metrics.rb

@@ -28,7 +28,8 @@ module Symphony::Metrics
 
 		@log_reporter = Metriks::Reporter::Logger.new(
 			logger: Loggability[ Symphony ],
-			registry: @metriks_registry )
+			registry: @metriks_registry,
+			prefix: self.class.name )
 		@proc_reporter = Metriks::Reporter::ProcTitle.new(
 			prefix: self.class.name,
 			registry: @metriks_registry,

data/lib/symphony/queue.rb

@@ -209,7 +209,8 @@ class Symphony::Queue
 		tag     = self.consumer_tag
 
 		# Last argument is *no_ack*, so need to invert the logic
-		self.log.debug "Creating Bunny::Consumer for %p with tag: %s" % [ amqp_queue, tag ]
+		self.log.debug "Creating consumer for the '%s' queue with tag: %s" %
+			[ amqp_queue.name, tag ]
 		cons = Bunny::Consumer.new( amqp_queue.channel, amqp_queue, tag, !ackmode )
 
 		cons.on_delivery do |delivery_info, properties, payload|
@@ -309,5 +310,20 @@ class Symphony::Queue
 		self.consumer.channel.close
 	end
 
+
+	### Return a human-readable representation of the Queue in a form suitable for debugging.
+	def inspect
+		return "#<%p:%#0x %s (%s) ack: %s, routing: %p, prefetch: %d>" % [
+			self.class,
+			self.object_id * 2,
+			self.name,
+			self.consumer_tag,
+			self.acknowledge ? "yes" : "no",
+			self.routing_keys,
+			self.prefetch,
+		]
+	end
+
+
 end # class Symphony::Queue
 

data/lib/symphony/signal_handling.rb

@@ -89,6 +89,7 @@ module Symphony::SignalHandling
 	def ignore_signals( *signals )
 		self.log.debug "Ignoring signals."
 		signals.each do |sig|
+			next if sig == :CHLD
 			Signal.trap( sig, :IGNORE )
 		end
 	end

data/lib/symphony/task.rb

@@ -51,6 +51,14 @@ class Symphony::Task
 	end
 
 
+	### Prepare the process after being forked from the Daemon.
+	def self::after_fork
+		self.log.debug "After fork [%d]: Threads: %p" % [ Process.pid, ThreadGroup::Default.list ]
+		Process.setpgrp
+		Symphony.config.install if Symphony.config
+	end
+
+
 	### Inheritance hook -- set some defaults on subclasses.
 	def self::inherited( subclass )
 		super
@@ -193,6 +201,7 @@ class Symphony::Task
 	end
 
 
+
 	######
 	public
 	######

data/spec/symphony/daemon_spec.rb

@@ -0,0 +1,13 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require_relative '../helpers'
+
+require 'symphony/daemon'
+
+describe Symphony::Daemon do
+
+
+
+end
+

data/spec/symphony/queue_spec.rb

@@ -150,7 +150,7 @@ describe Symphony::Queue do
 
 
 		it "subscribes to the message queue with a configured consumer to wait for messages" do
-			amqp_queue = double( "AMQP queue", channel: described_class.amqp_channel )
+			amqp_queue = double( "AMQP queue", name: 'a queue', channel: described_class.amqp_channel )
 			consumer = double( "Bunny consumer", channel: described_class.amqp_channel )
 
 			expect( described_class.amqp_channel ).to receive( :queue ).
@@ -202,7 +202,7 @@ describe Symphony::Queue do
 
 
 		it "sets up the queue and consumer to only run once if waiting in one-shot mode" do
-			amqp_queue = double( "AMQP queue", channel: described_class.amqp_channel )
+			amqp_queue = double( "AMQP queue", name: 'a queue', channel: described_class.amqp_channel )
 			consumer = double( "Bunny consumer", channel: described_class.amqp_channel )
 
 			expect( described_class.amqp_channel ).to receive( :queue ).
@@ -243,7 +243,7 @@ describe Symphony::Queue do
 
 
 		it "shuts down the consumer if the queues it's consuming from is deleted on the server" do
-			amqp_queue = double( "AMQP queue", channel: described_class.amqp_channel )
+			amqp_queue = double( "AMQP queue", name: 'a queue', channel: described_class.amqp_channel )
 			consumer = double( "Bunny consumer", channel: described_class.amqp_channel )
 
 			expect( described_class.amqp_channel ).to receive( :queue ).
@@ -277,7 +277,7 @@ describe Symphony::Queue do
 
 		it "creates a consumer with acknowledgements enabled if it has acknowledgements enabled" do
 			amqp_channel = double( "AMQP channel" )
-			amqp_queue = double( "AMQP queue", channel: amqp_channel )
+			amqp_queue = double( "AMQP queue", name: 'a queue', channel: amqp_channel )
 			consumer = double( "Bunny consumer" )
 
 			# Ackmode argument is actually 'no_ack'
@@ -293,7 +293,7 @@ describe Symphony::Queue do
 
 		it "creates a consumer with acknowledgements disabled if it has acknowledgements disabled" do
 			amqp_channel = double( "AMQP channel" )
-			amqp_queue = double( "AMQP queue", channel: amqp_channel )
+			amqp_queue = double( "AMQP queue", name: 'a queue', channel: amqp_channel )
 			consumer = double( "Bunny consumer" )
 
 			# Ackmode argument is actually 'no_ack'

data/spec/symphony/task_spec.rb

@@ -64,84 +64,205 @@ describe Symphony::Task do
 
 	context "a concrete subclass" do
 
-		before( :each ) do
-			@task_class = Class.new( described_class ) do
+		let( :task_class ) do
+			Class.new( described_class ) do
 				def self::name; 'ACME::TestingTask'; end
 			end
 		end
+		let( :payload ) {{ "the" => "payload" }}
+		let( :serialized_payload ) { Yajl.dump(payload) }
+		let( :metadata ) {{ :content_type => 'application/json' }}
+		let( :queue ) do
+			obj = Symphony::Queue.for_task( task_class )
+			# Don't really talk to AMQP for messages
+			allow( obj ).to receive( :wait_for_message ) do |oneshot, &callback|
+				callback.call( serialized_payload, metadata )
+			end
+			obj
+		end
+
+
+		it "puts the process into its own process group after a fork" do
+			expect( Process ).to receive( :setpgrp ).with( no_args )
+			task_class.after_fork
+		end
 
 
 		it "raises an exception if run without specifying any subscriptions" do
-			expect { @task_class.run }.to raise_error( ScriptError, /no subscriptions/i )
+			expect { task_class.run }.to raise_error( ScriptError, /no subscriptions/i )
 		end
 
 
 		it "can set an explicit queue name" do
-			@task_class.queue_name( 'happy.fun.queue' )
-			expect( @task_class.queue_name ).to eq( 'happy.fun.queue' )
+			task_class.queue_name( 'happy.fun.queue' )
+			expect( task_class.queue_name ).to eq( 'happy.fun.queue' )
+		end
+
+
+		it "can set the number of messages to prefetch" do
+			task_class.prefetch( 10 )
+			expect( task_class.prefetch ).to eq( 10 )
 		end
 
 
 		it "can retry on timeout instead of rejecting" do
-			@task_class.timeout_action( :retry )
-			expect( @task_class.timeout_action ).to eq( :retry )
+			task_class.timeout_action( :retry )
+			expect( task_class.timeout_action ).to eq( :retry )
 		end
 
 
 		it "provides a default name for its queue based on its name" do
-			expect( @task_class.queue_name ).to eq( 'acme.testingtask' )
+			expect( task_class.queue_name ).to eq( 'acme.testingtask' )
 		end
 
 
 		it "can declare a pattern to use when subscribing" do
-			@task_class.subscribe_to( 'foo.test' )
-			expect( @task_class.routing_keys ).to include( 'foo.test' )
+			task_class.subscribe_to( 'foo.test' )
+			expect( task_class.routing_keys ).to include( 'foo.test' )
 		end
 
 
 		it "has acknowledgements enabled by default" do
-			expect( @task_class.acknowledge ).to eq( true )
+			expect( task_class.acknowledge ).to eq( true )
 		end
 
 
 		it "can enable acknowledgements" do
-			@task_class.acknowledge( true )
-			expect( @task_class.acknowledge ).to eq( true )
+			task_class.acknowledge( true )
+			expect( task_class.acknowledge ).to eq( true )
 		end
 
 
 		it "can disable acknowledgements" do
-			@task_class.acknowledge( false )
-			expect( @task_class.acknowledge ).to eq( false )
+			task_class.acknowledge( false )
+			expect( task_class.acknowledge ).to eq( false )
 		end
 
 
 		it "can set a timeout" do
-			@task_class.timeout( 10 )
-			expect( @task_class.timeout ).to eq( 10 )
+			task_class.timeout( 10 )
+			expect( task_class.timeout ).to eq( 10 )
 		end
 
 
 		it "can declare a one-shot work model" do
-			@task_class.work_model( :oneshot )
-			expect( @task_class.work_model ).to eq( :oneshot )
+			task_class.work_model( :oneshot )
+			expect( task_class.work_model ).to eq( :oneshot )
 		end
 
 
 		it "can declare a long-lived work model" do
-			@task_class.work_model( :longlived )
-			expect( @task_class.work_model ).to eq( :longlived )
+			task_class.work_model( :longlived )
+			expect( task_class.work_model ).to eq( :longlived )
 		end
 
 
 		it "raises an error if an invalid work model is declared " do
 			expect {
-				@task_class.work_model( :lazy )
+				task_class.work_model( :lazy )
 			}.to raise_error( /unknown work_model/i )
 		end
 
 
+		context "an instance" do
+
+			let( :task_class ) do
+				Class.new( described_class ) do
+					def initialize( * )
+						super
+						@received_messages = []
+					end
+					attr_reader :received_messages
+
+					def work( payload, metadata )
+						self.received_messages << [ payload, metadata ]
+						true
+					end
+				end
+			end
+
+			let( :task ) { task_class.new(queue) }
+
+
+			it "handles received messages by calling its work method" do
+				expect( queue ).to receive( :wait_for_message ) do |oneshot, &callback|
+					callback.call( serialized_payload, metadata )
+				end
+
+				task.start_handling_messages
+
+				expect( task.received_messages ).to eq([ [payload, metadata] ])
+			end
+
+
+		end
+
+
+		context "an instance with a timeout" do
+
+			let( :task_class ) do
+				Class.new( described_class ) do
+					timeout 0.2
+					def initialize( * )
+						super
+						@received_messages = []
+						@sleeptime = 0
+					end
+					attr_reader :received_messages
+					attr_accessor :sleeptime
+
+					def work( payload, metadata )
+						self.received_messages << [ payload, metadata ]
+						sleep( self.sleeptime )
+						true
+					end
+				end
+			end
+
+			let( :task ) { task_class.new(queue) }
+
+
+			it "returns true if the work completes before the timeout" do
+				task.sleeptime = 0
+				expect( task.start_handling_messages ).to be_truthy
+			end
+
+
+			it "raises a Timeout::Error if the work takes longer than the timeout" do
+				task.sleeptime = task_class.timeout + 2
+				expect {
+					task.start_handling_messages
+				}.to raise_error( Timeout::Error, /execution expired/ )
+			end
+
+
+			it "returns false if the work takes longer than the timeout and the timeout_action is set to :retry" do
+				task_class.timeout_action( :retry )
+				task.sleeptime = task_class.timeout + 2
+				expect( task.start_handling_messages ).to be_falsey
+			end
+
+		end
+
+
+
+		context "an instance with no #work method" do
+
+			let( :task ) { task_class.new(queue) }
+
+			it "raises an exception when told to do work" do
+				expect {
+					task.work( 'payload', {} )
+				}.to raise_error( NotImplementedError, /#work/ )
+			end
+
+		end
+
+
+
 	end
 
+
+
 end
 

data/spec/symphony_spec.rb

@@ -8,7 +8,62 @@ require 'symphony'
 
 describe Symphony do
 
+	before( :each ) do
+		ENV.delete( 'SYMPHONY_CONFIG' )
+	end
 
 
+	it "will load a default config file if none is specified" do
+		config_object = double( "Configurability::Config object" )
+		expect( Configurability ).to receive( :gather_defaults ).
+			and_return( {} )
+		expect( Configurability::Config ).to receive( :load ).
+			with( described_class::DEFAULT_CONFIG_FILE, {} ).
+			and_return( config_object )
+		expect( config_object ).to receive( :install )
+
+		described_class.load_config
+	end
+
+
+	it "will load a config file given in an environment variable if none is specified" do
+		ENV['SYMPHONY_CONFIG'] = '/usr/local/etc/config.yml'
+
+		config_object = double( "Configurability::Config object" )
+		expect( Configurability ).to receive( :gather_defaults ).
+			and_return( {} )
+		expect( Configurability::Config ).to receive( :load ).
+			with( '/usr/local/etc/config.yml', {} ).
+			and_return( config_object )
+		expect( config_object ).to receive( :install )
+
+		described_class.load_config
+	end
+
+
+	it "will load a config file and install it if one is given" do
+		config_object = double( "Configurability::Config object" )
+		expect( Configurability ).to receive( :gather_defaults ).
+			and_return( {} )
+		expect( Configurability::Config ).to receive( :load ).
+			with( 'a/configfile.yml', {} ).
+			and_return( config_object )
+		expect( config_object ).to receive( :install )
+
+		described_class.load_config( 'a/configfile.yml' )
+	end
+
+
+	it "will override default values when loading the config if they're given" do
+		config_object = double( "Configurability::Config object" )
+		expect( Configurability ).to_not receive( :gather_defaults )
+		expect( Configurability::Config ).to receive( :load ).
+			with( 'a/different/configfile.yml', {database: {dbname: 'test'}} ).
+			and_return( config_object )
+		expect( config_object ).to receive( :install )
+
+		described_class.load_config( 'a/different/configfile.yml', database: {dbname: 'test'} )
+	end
+
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: symphony
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre20140327204419
+  version: 0.3.0
 platform: ruby
 authors:
 - Michael Granger
@@ -271,6 +271,7 @@ extra_rdoc_files:
 - TODO.md
 - USAGE.rdoc
 files:
+- .gemtest
 - .simplecov
 - ChangeLog
 - History.rdoc
@@ -297,6 +298,7 @@ files:
 - lib/symphony/tasks/ssh.rb
 - lib/symphony/tasks/sshscript.rb
 - spec/helpers.rb
+- spec/symphony/daemon_spec.rb
 - spec/symphony/mixins_spec.rb
 - spec/symphony/queue_spec.rb
 - spec/symphony/task_spec.rb
@@ -320,9 +322,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: 2.0.3
 requirements: []
 rubyforge_project: symphony
 rubygems_version: 2.2.2