symphony-metronome 0.1.0

data/lib/symphony/metronome/mixins.rb

@@ -0,0 +1,130 @@
+# -*- ruby -*-
+#encoding: utf-8
+# vim: set nosta noet ts=4 sw=4:
+
+require 'symphony' unless defined?( Symphony )
+require 'symphony/metronome' unless defined?( Symphony::Metronome )
+
+
+module Symphony::Metronome
+
+	# Functions for time calculations
+	module TimeFunctions
+
+		###############
+		module_function
+		###############
+
+		### Calculate the (approximate) number of seconds that are in +count+ of the
+		### given +unit+ of time.
+		###
+		def calculate_seconds( count, unit )
+			return case unit
+			when :seconds, :second
+				count
+			when :minutes, :minute
+				count * 60
+			when :hours, :hour
+				count * 3600
+			when :days, :day
+				count * 86400
+			when :weeks, :week
+				count * 604800
+			when :fortnights, :fortnight
+				count * 1209600
+			when :months, :month
+				count * 2592000
+			when :years, :year
+				count * 31557600
+			else
+				raise ArgumentError, "don't know how to calculate seconds in a %p" % [ unit ]
+			end
+		end
+	end # module TimeFunctions
+
+
+	# Refinements to Numeric to add time-related convenience methods
+	module TimeRefinements
+		refine Numeric do
+
+			### Number of seconds (returns receiver unmodified)
+			def seconds
+				return self
+			end
+			alias_method :second, :seconds
+
+			### Returns number of seconds in <receiver> minutes
+			def minutes
+				return TimeFunctions.calculate_seconds( self, :minutes )
+			end
+			alias_method :minute, :minutes
+
+			### Returns the number of seconds in <receiver> hours
+			def hours
+				return TimeFunctions.calculate_seconds( self, :hours )
+			end
+			alias_method :hour, :hours
+
+			### Returns the number of seconds in <receiver> days
+			def days
+				return TimeFunctions.calculate_seconds( self, :day )
+			end
+			alias_method :day, :days
+
+			### Return the number of seconds in <receiver> weeks
+			def weeks
+				return TimeFunctions.calculate_seconds( self, :weeks )
+			end
+			alias_method :week, :weeks
+
+			### Returns the number of seconds in <receiver> fortnights
+			def fortnights
+				return TimeFunctions.calculate_seconds( self, :fortnights )
+			end
+			alias_method :fortnight, :fortnights
+
+			### Returns the number of seconds in <receiver> months (approximate)
+			def months
+				return TimeFunctions.calculate_seconds( self, :months )
+			end
+			alias_method :month, :months
+
+			### Returns the number of seconds in <receiver> years (approximate)
+			def years
+				return TimeFunctions.calculate_seconds( self, :years )
+			end
+			alias_method :year, :years
+
+
+			### Returns the Time <receiver> number of seconds before the
+			### specified +time+. E.g., 2.hours.before( header.expiration )
+			def before( time )
+				return time - self
+			end
+
+
+			### Returns the Time <receiver> number of seconds ago. (e.g.,
+			### expiration > 2.hours.ago )
+			def ago
+				return self.before( ::Time.now )
+			end
+
+
+			### Returns the Time <receiver> number of seconds after the given +time+.
+			### E.g., 10.minutes.after( header.expiration )
+			def after( time )
+				return time + self
+			end
+
+
+			### Return a new Time <receiver> number of seconds from now.
+			def from_now
+				return self.after( ::Time.now )
+			end
+
+		end # refine Numeric
+	end # module TimeRefinements
+
+end # module Symphony::Metronome
+
+

data/lib/symphony/metronome/scheduledevent.rb

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+# vim: set nosta noet ts=4 sw=4:
+
+require 'set'
+require 'sequel'
+require 'sqlite3'
+require 'yajl'
+require 'symphony/metronome'
+
+Sequel.extension :migration
+
+
+### A class the represents the relationship between an interval and
+### an event.
+###
+class Symphony::Metronome::ScheduledEvent
+	extend Loggability, Configurability
+	include Comparable
+
+	log_to :symphony
+	config_key :metronome
+
+
+	# Configure defaults.
+	#
+	CONFIG_DEFAULTS = {
+		db: 'sqlite:///tmp/metronome.db',
+		splay: 0
+	}
+
+	class << self
+		# A Sequel-style DB connection URI.
+		attr_reader :db
+
+		# Adjust recurring intervals by a random window.
+		attr_reader :splay
+	end
+
+
+	######################################################################
+	# C L A S S  M E T H O D S
+	######################################################################
+
+	### Configurability API.
+	###
+	def self::configure( config=nil )
+		config = self.defaults.merge( config || {} )
+		@db    = Sequel.connect( config.delete(:db) )
+		@splay = config.delete( :splay )
+
+		# Ensure the database is current.
+		#
+		migrations_dir = Symphony::Metronome::DATADIR + 'migrations'
+		unless Sequel::Migrator.is_current?( self.db, migrations_dir.to_s )
+			Sequel::Migrator.apply( self.db, migrations_dir.to_s )
+		end
+	end
+
+
+	### Return a set of all known events, sorted by date of execution.
+	### Delete any rows that are invalid expressions.
+	###
+	def self::load
+		now    = Time.now
+		events = SortedSet.new
+
+		# Force reset the DB handle.
+		self.db.disconnect
+
+		self.log.debug "Parsing/loading all actions."
+		self.db[ :metronome ].each do |event|
+			begin
+				event = new( event )
+				events << event
+			rescue ArgumentError, Symphony::Metronome::TimeParseError => err
+				self.log.error "%p while parsing \"%s\": %s" % [
+					err.class,
+					event[:expression],
+					err.message
+				]
+				self.log.debug "  " + err.backtrace.join( "\n  " )
+				self.db[ :metronome ].filter( :id => event[:id] ).delete
+			end
+		end
+
+		return events
+	end
+
+
+	######################################################################
+	# I N S T A N C E  M E T H O D S
+	######################################################################
+
+	### Create a new ScheduledEvent object.
+	###
+	def initialize( row )
+		@event    = Symphony::Metronome::IntervalExpression.parse( row[:expression], row[:created] )
+		@options  = row.delete( :options )
+		@id       = row.delete( :id )
+		self.reset_runtime
+
+		unless self.class.splay.zero?
+			splay = Range.new( - self.class.splay, self.class.splay )
+			@runtime = self.runtime + rand( splay )
+		end
+	end
+
+	# The parsed interval expression.
+	attr_reader :event
+
+	# The unique ID number of the scheduled event.
+	attr_reader :id
+
+	# The options hash attached to this event.
+	attr_reader :options
+
+	# The exact time that this event will run.
+	attr_reader :runtime
+
+
+	### Set the datetime that this event should fire next.
+	###
+	def reset_runtime
+		now = Time.now
+
+		# Start time is in the future, so it's sufficent to be considered the run time.
+		#
+		if self.event.starting >= now
+			@runtime = self.event.starting
+			return
+		end
+
+		# Otherwise, the event should already be running (start time has already
+		# elapsed), so schedule it forward on it's next interval iteration.
+		#
+		@runtime = now + self.event.interval
+	end
+
+
+	### Perform the action attached to the event.  Yields the
+	### deserialized options, the action ID to the supplied block if
+	### this event is okay to execute.
+	###
+	### Automatically remove the event if it has expired.
+	###
+	def fire
+		rv = self.event.fire?
+
+		if rv
+			opts = Yajl.load( self.options )
+			yield opts, self.id
+		end
+
+		self.delete if rv.nil?
+		return rv
+	end
+
+
+	### Permanently remove this event from the database.
+	###
+	def delete
+		self.log.debug "Removing action %p" % [ self.id ]
+		self.class.db[ :metronome ].filter( :id => self.id ).delete
+	end
+
+
+	### Comparable interface, order by next run time, soonest first.
+	###
+	def <=>( other )
+		return self.runtime <=> other.runtime
+	end
+
+end # Symphony::Metronome::ScheduledEvent
+

data/lib/symphony/metronome/scheduler.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+# vim: set nosta noet ts=4 sw=4:
+
+require 'symphony'
+require 'symphony/metronome'
+
+
+### Manage the delta queue of events and associated actions.
+###
+class Symphony::Metronome::Scheduler
+	extend Loggability, Configurability
+	include Symphony::SignalHandling
+
+	log_to :symphony
+	config_key :metronome
+
+	# Signals the daemon responds to.
+	SIGNALS = [ :HUP, :INT, :TERM ]
+
+	CONFIG_DEFAULTS = {
+		:listen => true
+	}
+
+	class << self
+		# Should Metronome register and schedule events via AMQP?
+		# If +false+, you'll need a separate way to add event actions
+		# to the database, and manually HUP the daemon.
+		attr_reader :listen
+	end
+
+	### Configurability API
+	###
+	def self::configure( config=nil )
+		config = self.defaults.merge( config || {} )
+		@listen = config.delete( :listen )
+	end
+
+
+	### Create and start an instanced daemon.
+	###
+	def self::run( &block )
+		return new( block )
+	end
+
+
+	### Actions to perform when creating a new daemon.
+	###
+	private_class_method :new
+	def initialize( block ) #:nodoc:
+
+		# Start the queue subscriber for schedule changes.
+		#
+		if self.class.listen
+			Symphony::Metronome::ScheduledEvent.db.disconnect
+			@child = fork do
+				$0 = 'Metronome (listener)'
+				Symphony::Metronome::ScheduleTask.run
+			end
+			Process.setpgid( @child, 0 )
+		end
+
+		# Signal handling for the master (this) process.
+		#
+		self.set_up_signal_handling
+		self.set_signal_traps( *SIGNALS )
+
+		@queue = Symphony::Metronome::ScheduledEvent.load
+		@proc  = block
+
+		# Enter the main loop.
+		self.start
+
+	rescue => err
+		self.log.error "%p while running: %s" % [ err.class, err.message ]
+		self.log.debug "  " + err.backtrace.join( "\n  " )
+		Process.kill( 'TERM', @child ) if self.class.listen
+	end
+
+
+	# The sorted set of ScheduledEvent objects.
+	attr_reader :queue
+
+
+	#########
+	protected
+	#########
+
+	### Main daemon sleep loop.
+	###
+	def start
+		$0 = "Metronome%s" % [ self.class.listen ? ' (executor)' : '' ]
+		@running = true
+
+		loop do
+			wait = nil
+
+			if ev = self.queue.first
+				wait = ev.runtime - Time.now
+				wait = 0 if wait < 0
+				self.log.info "Next event in %0.3f second(s) (id: %d)..." % [ wait, ev.id ]
+			else
+				self.log.warn "No events scheduled.  Waiting indefinitely..."
+			end
+
+			self.process_events unless self.wait_for_signals( wait )
+			break unless @running
+		end
+	end
+
+
+	### Dispatch incoming signals to appropriate handlers.
+	###
+	def handle_signal( sig )
+		case sig
+		when :TERM, :INT
+			@running = false
+			Process.kill( sig.to_s, @child ) if self.class.listen
+
+		when :HUP
+			@queue = Symphony::Metronome::ScheduledEvent.load
+			self.queue.each{|ev| ev.fire(&@proc) if ev.event.recurring }
+
+		else
+			self.log.debug "Unhandled signal: %s" % [ sig ]
+		end
+	end
+
+
+	### Process all event that have reached their runtime.
+	###
+	def process_events
+		now = Time.now
+
+		self.queue.each do |ev|
+			next unless now >= ev.runtime
+
+			self.queue.delete( ev )
+			rv = ev.fire( &@proc )
+
+			# Reschedule the event and place it back on the queue.
+			#
+			if ev.event.recurring
+				ev.reset_runtime
+				self.queue.add( ev ) unless rv.nil?
+
+			# It was a single run event, torch it!
+			#
+			else
+				ev.delete
+
+			end
+		end
+	end
+
+end # Symphony::Metronome::Scheduler
+