rsyncmanager 1.1

data/bin/rsyncmanager.rb

@@ -0,0 +1,1210 @@
+#!/usr/local/bin/ruby
+#
+# Author:: David Powers
+# Copyright:: September, 2004
+# Version:: 1.1
+#
+#Overview:
+#
+#Rsyncmanager is a daemon designed to simplify the task of coordinating 
+#multiple file transfers to or from a machine.  It was originally written
+#to serve as the managing hub of a backup system that used rsync to feed 
+#in files from many other machines so that all backups could be run from 
+#a single place.  That said, it can be used to coordinate any kind of regular
+#file transfer, from a single hourly copy of an email store from a primary
+#to a backup server, to multiple concurrent rsyncs to multiple machines on
+#varying schedules.
+#
+#
+#Features:
+#
+#* Coordinate multiple file transfers using rsync, scp or a combination 
+#  of the two
+#* Limit the number of concurrently running file transfers to prevent
+#  resource starvation
+#* Prevent file transfers from starting based on arbitrary conditions using
+#  external scripts (time of day, machine load, memory usage, phase of the 
+#  moon...)
+#* Run commands before and after a file transfer to handle setup and cleanup
+#  conditions (e.g. dump a database to disk, transfer it to a backup, then
+#  delete the dump)
+#* Intelligently limit concurrent file transfers to or from the same machine
+#  to prevent resource limitations from slowing or starving a transfer
+#* Limit concurrent file transfers based on arbitrary grouping (e.g. only
+#  one transfer from internal to external servers over a slow line at any
+#  given point)
+#* Coordinate transfers between multiple machines (grouping over multiple
+#  machines, avoiding having two machines push data to a third at the same
+#  time, etc.)
+#* Provides a clear web-based administrative report of all currently
+#  managed transfers and their current status (running, behind schedule,
+#  etc)
+#* Intelligently schedule file transfers based on average runtimes so that
+#  transfers happen within a defined schedule but do not run constantly if
+#  not needed
+
+require 'getoptlong'
+require 'rexml/document'
+require 'logger'
+require 'net/http'
+require 'optparse'
+require 'socket'
+require 'timeout'
+require 'thread'
+require 'webrick'
+
+
+
+# parent class for configuration exceptions
+class ConfigurationError < Exception
+end
+
+# raised when field content does not match allowed values
+class InvalidContentError < ConfigurationError
+end
+
+# raised when a required element is not found
+class MissingElementError < ConfigurationError
+end
+
+
+
+# holds configuration information about a single transfer and can start and manage
+# a thread to run the transfer
+class Transfer
+	attr_reader :options, :group, :from, :to, :commandpath, :description, :laststarted, :lastfinished, :frequency, :ignorepartialerrors, :cutoffprogram, :runbefore, :runafter
+	
+	def initialize()
+		@laststarted = nil
+		@lastfinished = nil
+		@runtimes = Array.new()
+		
+		# set @thread to a new dead thread to avoid special handling of thread state query functions
+		@thread = Thread.new {}
+	end
+	
+	
+	# turns the internal data into a command
+	def command()
+		return("#{@commandpath} #{@options} '#{@from.gsub(/\'/, '\\\&')}' '#{@to.gsub(/\'/, '\\\&')}'")
+	end
+	
+
+	# returns true if this transfer is eligable to be run
+	def eligable?()
+		# never eligable if it is running right now
+		if(running?())
+			return(false)
+		end
+		
+		# if we have runtimes compare the average runtime with the time remaining
+		# until our ideal runtime.  We need to be reasonably close to our ideal time
+		# to be eligable
+		if(@runtimes.length > 0)
+			@perfecttime = @lastfinished + @frequency - averageruntime()
+			if(Time.now() < @perfecttime - (averageruntime() / 2))
+				return(false)
+			end
+		end
+		
+		return(true)
+	end
+	
+	
+	# returns the average runtime
+	def averageruntime()
+		totaltime = 0
+		@runtimes.each() { |runtime|
+			totaltime = totaltime + runtime
+		}
+		
+		if(@runtimes.length == 0)
+			return(@frequency)
+		else
+			return(totaltime/@runtimes.length)
+		end
+	end
+	
+	
+	# returns the current calculated priority of this transfer.  The priority approaches 100 as the
+	# transfer nears the perfect time for the next start.
+	def priority()
+		$logger.debug("checking priority of \"#{@description}\"")
+		# always return 0 if the transfer is currently running
+		if(running?())
+			$logger.debug("transfer is running - returning 0")
+			return(0)
+		end
+		
+		# if it has never been run - set priority to 250
+		if(@lastfinished == nil)
+			$logger.debug("transfer has never been run - returning 1000")
+			return(250)
+		end
+		
+		@step = @frequency.to_f() / 100.0
+		
+		# as we approach the perfect time (@lastfinished + @frequency) the priority should approach 100
+		priority = (Time.now - @lastfinished) / @step
+		$logger.debug("transfer has a real priority 0f #{priority}")
+		return(priority)
+	end
+	
+	
+	# runs this transfer in a thread
+	def run()
+		@thread = Thread.new() { 
+			begin
+				# mark the start time
+				@laststarted = Time.now()
+				
+				$logger.info("running \"#{@description}\"")
+				
+				# run the runbefore command if it exists
+				if(@runbefore != '')
+					$logger.debug("running command #{@runbefore}")
+					runbeforestatus = system(@runbefore)
+					if(runbeforestatus == false)
+						$logger.error("error during run of #{@runbefore} before #{@description} - error code #{$?}")
+						raise(Exception)
+					end
+				end
+				
+				
+				# actually run the command and report on success/failure
+				$logger.debug("running command #{command()}")
+				ransuccessfully = system(command())
+
+				# update variable and internal state
+				if(ransuccessfully == false and (@ignorepartialerrors == false or $?.to_i() != 5888))
+					$logger.error("error during run of #{command()} - error code #{$?}")
+				else
+					# run the runbefore command if it exists
+					if(@runafter != '')
+						$logger.debug("running command #{@runbefore}")
+						runafterstatus = system(@runafter)
+						if(runafterstatus == false)
+							$logger.error("error during run of #{@runafter} after #{@description} - error code #{$?}")
+							raise(Exception)
+						end
+					end
+
+					$logger.info("\"#{@description}\" completed")
+					
+					# mark the time of completion
+					@lastfinished = Time.now()
+					
+					# set last runtime here to handle clock shifts
+					if(@lastfinished > @laststarted)
+						@runtimes << @lastfinished - @laststarted
+						
+						# lop off the oldest time if we have more than 10
+						if(@runtimes.length > 10)
+							@runtimes = @runtimes[1..-1]
+						end
+					end
+				end
+			rescue Exception
+				$logger.error("error running \"#{description}\" - #{$!}")
+			end
+		}
+	end
+	
+
+	def running?()
+		return(@thread.alive?())
+	end
+	
+	
+	def ignorepartialerrors=(newignorepartialerrors)
+		@ignorepartialerrors = newignorepartialerrors
+		$logger.debug("ignorepartialerrors set to \"#{@ignorepartialerrors}\"")
+	end
+	
+	
+	def commandpath=(newcommandpath)
+		@commandpath = newcommandpath
+		$logger.debug("commandpath set to \"#{@commandpath}\"")
+	end
+	
+	
+	def description=(newdescription)
+		@description = newdescription
+		$logger.debug("description set to \"#{@description}\"")
+	end
+	
+	
+	def options=(newoptions)
+		@options = newoptions
+		$logger.debug("options set to \"#{@options}\"")
+	end
+	
+	
+	def from=(newfrom)
+		@from = newfrom
+		$logger.debug("from set to \"#{@from}\"")
+	end
+	
+	
+	def to=(newto)
+		@to = newto
+		$logger.debug("to set to \"#{@to}\"")
+	end
+	
+	
+	def cutoffprogram=(newcutoffprogram)
+		@cutoffprogram = newcutoffprogram
+		$logger.debug("cutoffprogram set to \"#{@cutoffprogram}\"")
+	end
+	
+	
+	def runbefore=(newrunbefore)
+		@runbefore = newrunbefore
+		$logger.debug("runbefore set to \"#{@runbefore}\"")
+	end
+	
+	
+	def runafter=(newrunafter)
+		@runafter = newrunafter
+		$logger.debug("runafter set to \"#{@runafter}\"")
+	end
+	
+	
+	def group=(newgroup)
+		@group = newgroup
+		$logger.debug("group set to \"#{@group}\"")
+	end
+	
+	
+	# sets the frequency with a human readable string
+	def frequency=(newfrequency)
+		# if it is purely numeric assume minutes, otherwise get a suffix and compute from that
+		if(newfrequency =~ /^[0-9]+$/)
+			@frequency = newfrequency.to_i() * 60
+		elsif(newfrequency =~ /m/)
+			@frequency = newfrequency[/^[0-9]+/].to_i() * 60
+		elsif(newfrequency =~ /h/)
+			@frequency = newfrequency[/^[0-9]+/].to_i() * 60 * 60
+		elsif(newfrequency =~ /d/)
+			@frequency = newfrequency[/^[0-9]+/].to_i() * 24 * 60 * 60
+		else
+			raise(ArgumentError, "frequency could not be set to \"#{newfrequency}\"")
+		end
+	end
+end
+
+
+
+# Reads and holds the configuration for rsyncmanager
+class Configuration
+	attr_reader :general, :transfers
+	
+	# takes the filename of a configuration to read in
+	def initialize(filename)
+		# open the configuration file and read it in as an XML document
+		xmldoc = REXML::Document.new(File.open(filename, File::RDONLY))
+		
+		parse_general(xmldoc.root.elements['general'])
+		parse_transfers(xmldoc.root.elements['transfers'])
+	end
+	
+	
+	# parses the general section of the configuration file
+	def parse_general(generalxml)
+		# setup a hash to hold the options
+		@general = Hash.new()
+		
+		# get the maximum number of transfers to run at once
+		@general['maxtransfers'] = get_setting(generalxml.elements['maxtransfers'], 3, :to_i) { |setting|
+			if(setting <= 0)
+				raise(InvalidContentError, "maxtransfers must be set greater than 0")
+			end
+		}
+		
+		# get the path of the program that controls when to cutoff running any more transfers
+		@general['cutoffprogram'] = get_setting(generalxml.elements['cutoffprogram'], "")
+		
+		# set the command paths (automagically if necessary)
+		@general['rsyncpath'] = get_setting(generalxml.elements['rsyncpath'], get_command_path('rsync')) { |setting|
+			if(setting == "")
+				raise(ConfigurationError, "rsyncpath is not defined and the rsync binary could not be found on your system")
+			end
+		}
+
+		@general['scppath'] = get_setting(generalxml.elements['scppath'], get_command_path('scp')) { |setting|
+			if(setting == "")
+				raise(ConfigurationError, "scppath is not defined and the scp binary could not be found on your system")
+			end
+		}
+		
+		# set the coordination parameters
+		@general['coordinate'] = Array.new()
+		
+		coordinationxml = generalxml.elements['coordinate']
+		if(coordinationxml)
+			coordinationxml.each_element('url') { |url|
+				@general['coordinate'] << url.text()
+			}
+		end
+		
+		# set the http server defaults
+		httpserverxml = generalxml.elements['httpserver']
+		if(httpserverxml)
+			@general['httpserver'] = Hash.new()
+
+			@general['httpserver']['port'] = get_setting(httpserverxml.elements['port'], 7962, :to_i)
+			@general['httpserver']['listen'] = get_setting(httpserverxml.elements['listen'], '0.0.0.0')
+		end
+
+		
+		# get the defaults for transfers
+		parse_transferdefaults(generalxml.elements['transferdefaults'])
+	end
+	
+	
+	# parses the transferdefaults subsection of the general section of the configuration file
+	def parse_transferdefaults(transferdefaultsxml)
+		@transferdefaults = Hash.new()
+		
+		@transferdefaults['type'] = get_setting(transferdefaultsxml.elements['type'], 'rsync') { |setting|
+			if(setting != 'rsync' and setting != 'scp')
+				raise(InvalidContentError, "transferdefaults/type must be either 'rsync' or 'scp' but is currently set to \"#{setting}\"")
+			end
+		}
+		
+		if(transferdefaultsxml.elements['group'])
+			@transferdefaults['group'] = get_setting(transferdefaultsxml.elements['group'], "")
+		else
+			@transferdefaults['group'] = nil
+		end
+
+		@transferdefaults['options'] = get_setting(transferdefaultsxml.elements['options'], '-a -r -q')
+		
+		@transferdefaults['ignorepartialerrors'] = get_setting(transferdefaultsxml.elements['ignorepartialerrors'], 'false') { |setting|
+			if(setting.downcase() == 'true')
+				setting = true
+			elsif(setting.downcase() == 'false')
+				setting = false
+			else
+				raise(InvalidContentError, "transferdefaults/ignorepartialerrors must be either 'true' or 'false' but is currently set to \"#{setting}\"")
+			end
+		}
+		
+		@transferdefaults['frequency'] = get_setting(transferdefaultsxml.elements['frequency'], '1h') { |setting|
+			if(setting !~ /^[1-9][0-9]*(m|h|d|w)?$/)
+				raise(InvalidContentError, "transferdefaults/frequency (\"#{setting}\") cannot be parsed") 
+			end
+		}
+		
+		# get the path of the program that controls when to cutoff running any more transfers
+		@transferdefaults['cutoffprogram'] = get_setting(transferdefaultsxml.elements['cutoffprogram'], "")
+		
+		# set default programs to run before and after a transfer - defaults to nil
+		@transferdefaults['runbefore'] = get_setting(transferdefaultsxml.elements['runbefore'], '')
+		@transferdefaults['runafter'] = get_setting(transferdefaultsxml.elements['runafter'], '')
+	end
+	
+	
+	# parses the transfers section of the configuration file
+	def parse_transfers(transfersxml)
+		@transfers = Array.new()
+		
+		transfersxml.each_element('transfer') { |transferxml|
+			transfer = Transfer.new()
+
+			# set the description (optional)
+			transfer.description = get_setting(transferxml.elements['description'], 'No description given')
+			
+			# set the type
+			type = get_setting(transferxml.elements['type'], @transferdefaults['type']) { |setting|
+				if(setting != 'rsync' and setting != 'scp')
+					raise(InvalidContentError, "type must be either 'rsync' or 'scp' but is currently set to \"#{setting}\"")
+				end
+			}
+			
+			# set the command path
+			if(type == 'rsync')
+				transfer.commandpath = @general['rsyncpath']
+			elsif(type == 'scp')
+				transfer.commandpath = @general['scppath']
+			end
+			
+			# set the group
+			if(transferxml.elements['group'])
+				transfer.group = get_setting(transferxml.elements['group'], '')
+			else
+				transfer.group = @transferdefaults['group']
+			end
+
+			# set the frequency
+			transfer.frequency = get_setting(transferxml.elements['frequency'], @transferdefaults['frequency']) { |setting|
+				if(setting !~ /^[1-9][0-9]*(m|h|d|w)?$/)
+					raise(InvalidContentError, "transferdefaults/frequency (\"#{setting}\") cannot be parsed") 
+				end
+			}
+			
+			# set the options
+			transfer.options = get_setting(transferxml.elements['options'], @transferdefaults['options'])
+			
+			# set the from and to
+			transfer.from = get_setting(transferxml.elements['from'], "") { |setting|
+				if(setting == "")
+					raise(MissingElementError, "\"from\" must be set in each transfer section")
+				end
+			}
+			
+			transfer.to = get_setting(transferxml.elements['to'], "") { |setting|
+				if(setting == nil)
+					raise(MissingElementError, "\"to\" must be set in each transfer section")
+				end
+			}
+
+			# set whether or not we are ignoring partial transfer errors
+			transfer.ignorepartialerrors = get_setting(transferxml.elements['ignorepartialerrors'], @transferdefaults['ignorepartialerrors']) { |setting|
+				if(setting.downcase() == 'true')
+					setting = true
+				elsif(setting.downcase() == 'false')
+					setting = false
+				elsif(setting != true and setting != false)
+					raise(InvalidContentError, "transferdefaults/ignorepartialerrors must be either 'true' or 'false' but is currently set to \"#{setting}\"")
+				end
+			}
+			
+			# set a possible per-transfer cuttoffprogram
+			transfer.cutoffprogram = get_setting(transferxml.elements['cutoffprogram'], @transferdefaults['cutoffprogram'])
+			
+			# set programs to run before and after a transfer - this can handle setup and cleanup that rsync and scp cannot
+			transfer.runbefore = get_setting(transferxml.elements['runbefore'], @transferdefaults['runbefore'])
+			transfer.runafter = get_setting(transferxml.elements['runafter'], @transferdefaults['runafter'])
+			
+			@transfers << transfer
+			$logger.debug("Added transfer to list")
+		}
+	end
+	
+	
+	# finds the full path of a given command - returns false if the path cannot be found
+	def get_command_path(command)
+		paths = Array.[]('/sbin', '/bin', '/usr/sbin', '/usr/bin', '/usr/local/sbin', '/usr/local/bin')
+		
+		paths.each() { |path|
+			if(test(?x, "#{path}/#{command}"))
+				return("#{path}/#{command}")
+			end
+		}
+		
+		return(false)
+	end
+	
+	
+	# returns either the setting from the xml as text or default.  conversionmethod is applied to the
+	# setting to ensure the final return value is of a known type.  If a block is provided setting will
+	# be passed to the block (after conversion) for constraint checking or modification.
+	def get_setting(xml, default, conversionmethod = :to_s)
+		setting = nil
+		
+		if(xml == nil)
+			setting = default
+		else
+			setting = xml.text()
+		end
+		
+		# convert based on the conversion method
+		setting = setting.method(conversionmethod).call()
+		
+		if(block_given?())
+			yield(setting)
+		end
+		
+		return(setting)
+	end
+end
+
+
+
+# Serves a simple xml description of the transfers via WEBrick - mostly
+# for collaboration purposes between instances of rsyncmanager running on
+# separate machines
+class XMLInformationServlet < WEBrick::HTTPServlet::AbstractServlet
+	# handles GET requests using the helper methods of the class
+	def do_GET(req, res)
+		begin
+			@configuration = @options[0]
+			if(!@configuration.kind_of?(Configuration))
+				raise(ArgumentError, "configuration must be a Configuration object")
+			end
+			
+			timeout(30) {
+				xmldoc = REXML::Document.new("<transfers></transfers>")
+				xmldoc << REXML::XMLDecl.new()
+				
+				# now the information
+				@configuration.transfers.each() { |transfer|
+					xmldoc.root.add_element(xml_transfer_description(transfer))
+				}
+				
+				res.body = ""
+				xmldoc.write(res.body, 0)
+			}
+		rescue Exception
+			$logger.error("Error serving xml information page - #{$!}")
+		end
+	end
+	
+	
+	protected
+	
+	
+	# helper function to build a transfer information table
+	def xml_transfer_description(transfer)
+		now = Time.now()
+		transferelement = REXML::Element.new("transfer")
+		
+		if(transfer.group != nil)
+			group = REXML::Element.new("group")
+			group.text = transfer.group.to_s
+			transferelement.add_element(group)
+		end
+
+		running = REXML::Element.new("running")
+		if(transfer.running?)
+			running.text = "true"
+		else
+			running.text = "false"
+		end
+		transferelement.add_element(running)
+		
+		description = REXML::Element.new("description")
+		description.text = transfer.description
+		transferelement.add_element(description)
+
+		runbefore = REXML::Element.new("runbefore")
+		runbefore.text = transfer.runbefore
+		transferelement.add_element(runbefore)
+		
+		runafter = REXML::Element.new("runafter")
+		runafter.text = transfer.runafter
+		transferelement.add_element(runafter)
+		
+		from = REXML::Element.new("from")
+		from.text = transfer.from
+		transferelement.add_element(from)
+
+		to = REXML::Element.new("to")
+		to.text = transfer.to
+		transferelement.add_element(to)
+
+		command = REXML::Element.new("command")
+		command.text = transfer.command
+		transferelement.add_element(command)
+		
+		frequency = REXML::Element.new("frequency")
+		frequency.text = transfer.frequency.to_s()
+		transferelement.add_element(frequency)
+		
+		lastfinished = REXML::Element.new("lastfinished")
+		if(transfer.lastfinished)
+			lastfinished.text = transfer.lastfinished.to_s()
+		end
+		
+		averageruntime = REXML::Element.new("averageruntime")
+		averageruntime.text = transfer.averageruntime.to_s()
+		transferelement.add_element(averageruntime)
+		
+		priority = REXML::Element.new("priority")
+		priority.text = transfer.priority.to_s()
+		transferelement.add_element(priority)
+		
+		return(transferelement)
+	end
+
+end
+
+
+
+# Serves a simple informational page via WEBrick
+class HTTPInformationServlet < WEBrick::HTTPServlet::AbstractServlet
+	
+	# helper function to produce a formatted table row
+	def http_table_row(label, info)
+		row = ""
+		row << "\t<tr>\n"
+		row << "\t\t<td class=\"label\">\n\t\t"
+		row << "#{label}\n"
+		row << "\t\t</td>\n"
+		row << "\t\t<td class=\"info\">\n"
+		row << "#{info}\n"
+		row << "\t\t</td>\n"
+		row << "\t</tr>\n"
+		
+		return(row)
+	end
+	
+	
+	# helper function to build a key
+	def http_key()
+		key = <<KEY
+		<div class="keybox">
+			<div class="keytitle">
+				Transfer Status
+			</div>
+			<table>
+				<tr>
+					<td class="keylabel">
+						On-Time:
+					</td>
+					<td>
+						<div class="demobox" style="background-color: #e1ffe1">
+						</div>
+					</td>
+				</tr>
+				<tr>
+					<td class="keylabel">
+						Slightly Behind:
+					</td>
+					<td>
+						<div class="demobox" style="background-color: #ffffe1">
+						</div>
+					</td>
+				</tr>
+				<tr>
+					<td class="keylabel">
+						Overdue:
+					</td>
+					<td>
+						<div class="demobox" style="background-color: #ffe1e1">
+						</div>
+					</td>
+				</tr>
+				<tr>
+					<td class="keylabel">
+						Never Completed:
+					</td>
+					<td>
+						<div class="demobox" style="background-color: rgb(95%, 95%, 95%)">
+						</div>
+					</td>
+				</tr>
+				<tr>
+					<td class="keylabel">
+						Currently Running:
+					</td>
+					<td>
+						<div class="demobox" style="border: 3px solid #0042ff">
+						</div>
+					</td>
+				</tr>
+			</table>
+		</div>
+KEY
+		return(key)
+	end
+
+
+	# helper function to build a stylesheet
+	def http_stylesheet()
+		stylesheet = <<STYLESHEET
+		<style type=\"text/css\">
+			.transfersummary {
+				margin-left: auto;
+				margin-right: auto;
+				margin-bottom: 10px;
+				width: 90%;
+				border: 1px solid black;
+				background-color: rgb(95%, 95%, 95%);
+			}
+			.label {
+				width: 50px;
+				white-space: nowrap;
+				font-size: 12px;
+				font-weight: bold;
+			}
+			.info {
+				font-size: 10px;
+				font-weight: normal;
+			}
+			
+			.keybox {
+				border: 1px solid black;
+				background-color: #ffffff;
+				z-index: 5;
+				position: absolute;
+				top: 3px;
+				right: 3px;
+			}
+			
+			.keylabel {
+				font-size: 8px;
+			}
+			
+			.keytitle {
+				font-size: 9px;
+				font-weight: bold;
+				color: white;
+				text-align: center;
+				background-color: rgb(20%,20%,20%);
+				padding: 2px;
+			}
+	
+			.demobox {
+				width: 20px;
+				height: 20px;
+				border: 1px solid black;
+				margin-left: auto;
+				margin-right: auto;
+			}
+
+		</style>\n
+STYLESHEET
+		return(stylesheet)
+	end
+	
+	
+	# helper function to build a transfer information table
+	def http_transfer_table(transfer)
+		now = Time.now()
+	
+		table = "<table class=\"transfersummary\" style=\""
+		
+		# change the color of the table based on how close to on-schedule we are
+		if(transfer.lastfinished != nil)
+			green = transfer.lastfinished + transfer.frequency + transfer.frequency/10
+			yellow = transfer.lastfinished + transfer.frequency*2
+			if(now < green)
+				table << "background-color: #e1ffe1; "
+			elsif(now < yellow)
+				table << "background-color: #ffffe1; "
+			else
+				table << "background-color: #ffe1e1; "
+			end
+		end
+		
+		# if it is running, mark it
+		if(transfer.running?())
+			table << "border: 3px solid #0042ff;"
+		end
+		table << "\">\n"
+		
+		if(transfer.group != nil)
+			table << http_table_row("Group:", transfer.group)
+		end
+		
+		table << http_table_row("Description:", transfer.description)
+		if(transfer.runbefore != '')
+			table << http_table_row("Run Before:", transfer.runbefore)
+		end
+		table << http_table_row("Command:", transfer.command)
+		if(transfer.runafter != '')
+			table << http_table_row("Run After:", transfer.runafter)
+		end
+		table << http_table_row("Ideal Frequency:", "#{(transfer.frequency/60).round()} minutes")
+		table << http_table_row("Running:", transfer.running?())
+		if(transfer.lastfinished)
+			table << http_table_row("Last Finished:", "#{transfer.lastfinished} (#{((now - transfer.lastfinished)/60).round()} minutes ago)")
+		else
+			table << http_table_row("Last Finished:", "")
+		end
+		table << http_table_row("Average Run Time:", "#{(transfer.averageruntime/60).round()} minutes")
+		table << http_table_row("Current Priority:", transfer.priority.to_f.round())
+		table << "</table>\n"
+		
+		return(table)
+	end
+	
+	
+	# handles GET requests using the helper methods of the class
+	def do_GET(req, res)
+		begin
+			@configuration = @options[0]
+			if(!@configuration.kind_of?(Configuration))
+				raise(ArgumentError, "configuration must be a Configuration object")
+			end
+	
+			timeout(30) {
+				res.body = ""
+				res.body << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
+				res.body << "<html>\n"
+				res.body << "<head>\n"
+				res.body << "\t<meta http-equiv=\"content-type\" content=\"text/html; charset=ISO-8859-1\"/>\n"
+				res.body << "\t<title>Summary</title>\n"
+				
+				# style sheet
+				res.body << http_stylesheet()
+				
+				# reload the page automatically every 5 minutes
+				res.body << "\t<script type=\"text/JavaScript\">\n"
+				res.body << "\t\tfunction reloadpage()\n"
+				res.body << "\t\t{\n"
+				res.body << "\t\t\tdocument.location.href = document.location.href;\n"
+				res.body << "\t\t}\n\n"
+				res.body << "\t\tsetInterval('reloadpage()', 600000);\n"
+				res.body << "\t</script>\n"
+				
+				res.body << "</head>\n"
+				res.body << "<body>\n"
+				
+				# build a nice little key
+				res.body << http_key()
+				
+				# now the information
+				@configuration.transfers.each() { |transfer|
+					# build the table
+					table = http_transfer_table(transfer)
+					res.body << table
+				}
+				
+				res.body << "</body>\n"
+				res.body << "</html>\n"
+			}
+		rescue Exception
+			$logger.error("Error serving http information page - #{$!}")
+		end
+	end
+end
+
+
+# Collects the non-class methods for rsyncmanager
+module RsyncManager
+	
+	# Sets the $options variable.  Using defaults where none
+	# are provided and entries from the command line where possible
+	def RsyncManager.set_options()
+		$options = Hash.new()
+		$options['config'] = 'rsyncmanager.xml'
+		$options['log'] = '/var/log/rsyncmanager.log'
+		$options['verbosity'] = Logger::INFO
+		$options['pidfile'] = '/var/run/rsyncmanager.pid'
+		$options['daemon'] = true
+		
+
+		opts = OptionParser.new() { |opts|
+			opts.on_tail("-v", "--verbosity VERBOSITY", Integer, "(0-4) 0 being fatal errors only, default 3") { |verbosity|
+				if(verbosity == 0)
+					$options['verbosity'] = Logger::FATAL
+				elsif(verbosity == 1)
+					$options['verbosity'] = Logger::ERROR
+				elsif(verbosity == 2)
+					$options['verbosity'] = Logger::WARN
+				elsif(verbosity == 3)
+					$options['verbosity'] = Logger::INFO
+				elsif(verbosity == 4)
+					$options['verbosity'] = Logger::DEBUG
+				else
+					$stderr.print("verbosity must be set between 0 and 4\n")
+					exit(1)
+				end
+			}
+			
+			opts.on_tail("-h", "--help", "Print this message") {
+				print(opts)
+				exit()
+			}
+			
+			opts.on("-c", "--config CONFIGFILE", "Location of the configuration file") { |filename|
+				$options['config'] = filename
+			}
+			
+			opts.on("-l", "--log LOGFILE", "Location of the log file") { |filename|
+				$options['log'] = filename
+			}
+			
+			opts.on("-p", "--pidfile PIDFILE", "Location of the pid file") { |filename|
+				$options['pidfile'] = filename
+			}
+			
+			opts.on("-d", "--nodaemon", "Do not fork into the background") {
+				$options['daemon'] = false
+			}
+		}
+		
+		opts.parse(ARGV)
+	end
+	
+	
+	# forks the program into the background and detaches it from the terminal
+	def RsyncManager.daemonize()
+		# fork into the background
+		# Parent exits, child continues.
+		if(fork())
+			exit()
+		end
+		
+		# Become session leader.
+		Process.setsid()
+		
+		# Zap session leader.
+		if(fork())
+			exit()
+		end
+		
+		# Release old working directory.
+		Dir.chdir "/"
+		
+		# Ensure sensible umask. Adjust as needed.
+		File.umask 0000
+		
+		# reopen the file descriptors to nothing
+		STDIN.reopen '/dev/null'
+		STDOUT.reopen '/dev/null', 'a'
+		STDERR.reopen STDOUT
+	end
+	
+	
+	# writes the PID to a file
+	def RsyncManager.writepid(pidfile)
+		File.open(pidfile, File::WRONLY|File::CREAT|File::TRUNC, 0644) { |fp|
+			fp.write("#{Process.pid}\n")
+		}
+	end
+
+
+	# looks in each string in *strings and returns the first ip-address or hostname that
+	# it can find (assumes the strings will be of the form used in rsync or scp to designate
+	# a remote host)
+	def RsyncManager.extract_ip(*strings)
+		strings.each() { |str|
+			ipaddress = str[/^([^\/:@]*@)?([^:]+):/, 2]
+			if(ipaddress != nil)
+				return(ipaddress)
+			end
+		}
+		
+		return(nil)
+	end
+	
+	
+	# pulls down xml from the given url and adds the information to runningipaddresses and runninggroups
+	# so that it can be used in making decisions about which transfers to run on this machine
+	def RsyncManager.get_coordination_info(url, runningipaddresses, runninggroups)
+		begin
+			# we can't afford to wait around forever for an answer - we'll take what we can get
+			# and make a best guess if we don't get anything
+			timeout(10) {
+				# we only handle HTTP for now
+				response = Net::HTTP.get(URI.parse(url))
+				xmldoc = REXML::Document.new(response)
+				xmldoc.root.each_element('transfer') { |transfer|
+					if(transfer.elements['running'].text == 'true')
+						group = transfer.elements['group']
+						from = transfer.elements['from'].text
+						to = transfer.elements['to'].text
+						if(group != nil)
+							runninggroups[group] = true
+						end
+						runningipaddresses[extract_ip(from, to)] = 1
+					end
+				}
+			}
+		rescue Exception
+			$logger.warn("Unable to get coordination information from #{url} - #{$!}")
+		end
+	end
+	
+	
+	# The main logic loop of the program
+	def RsyncManager.main()
+		# blow up the whole thing for unhandled exceptions
+		Thread.abort_on_exception = true
+		
+		# set $options
+		set_options()
+		
+		# create a logger
+		$logger = Logger.new($options['log'], 10, 1024000)
+		$logger.level = $options['verbosity']
+		$logger.info("rsyncmanager started")
+		
+		# read in the configuration
+		configuration = Configuration.new($options['config'])
+
+		# go into the background
+		if($options['daemon'] == true)
+			daemonize()
+		end
+
+		# write the pid to a file
+		writepid($options['pidfile'])
+
+		# trap term so we can exit gracefully
+		trap("TERM") {
+			$logger.info("recieved TERM signal")
+			begin
+				# kill the child processes
+				File.unlink($options['pidfile'])
+				exit(0)
+			rescue Exception
+				# do nothing except note that we failed
+				$stderr.print "Unable to delete pid file \"#{$options['pidfile']}\" - #{$!}\n"
+				exit(1)
+			end
+		}
+		
+		# start an informational webserver if it has been requested
+		webserver = nil
+		if(configuration.general['httpserver'] != nil)
+			$logger.info("Starting HTTP server on #{configuration.general['httpserver']['listen']}:#{configuration.general['httpserver']['port']}")
+			
+			config = Hash.new()
+			config[:Port] = configuration.general['httpserver']['port']
+			config[:BindAddress] = configuration.general['httpserver']['listen']
+			webserver = WEBrick::HTTPServer.new(config)
+			webserver.mount('/info', HTTPInformationServlet, configuration)
+			webserver.mount('/xml', XMLInformationServlet, configuration)
+			
+			# start the server in its own thread so it doesn't stop us from doing real work
+			Thread.new() {
+				begin
+					webserver.start()
+				rescue Exception
+					$logger.error("Stopping web server - #{$!}")
+				end
+			}
+		end
+		
+		# run in a loop, scheduling and running transfers.  Set foundtransfer == true at the beginning to "trick"
+		# it into skipping the initial 1 minute sleep
+		foundtransfer = true
+		while(true)
+			# sleep for a minute if we didn't find any transfers available to run
+			if(!foundtransfer)
+				$logger.debug("sleeping")
+				sleep(60)
+				$logger.debug("waking up and considering which transfers need to be run")
+			end
+			
+			$logger.debug("choosing a new transfer to run")
+			
+			# set foundtransfer to false so we will sleep if there are no more available transfers.
+			foundtransfer = false
+			
+			# skip all this if we have a global cutoff program that returns > 0
+			if(configuration.general['cutoffprogram'] != '' and !system(configuration.general['cutoffprogram']))
+				next
+			end
+			
+			# collect information about all the currently running transfers
+			begin
+				numberrunning = 0
+				runningipaddresses = Hash.new()
+				runninggroups = Hash.new()
+				
+				# if we are coordinating with any other information sources, bring them in here
+				configuration.general['coordinate'].each() { |url|
+					get_coordination_info(url, runningipaddresses, runninggroups)
+				}
+				
+				# first loop through the transfers to get a count of the running transfers as well as to tag any
+				# remote addresses that are currently handling transfers so we don't overload them
+				configuration.transfers.each() { |transfer|
+					if(transfer.running?())
+						numberrunning = numberrunning + 1
+						runningipaddresses[extract_ip(transfer.from, transfer.to)] = 1
+						if(transfer.group != nil)
+							runninggroups[transfer.group] = true
+						end
+					end
+				}
+			rescue Exception
+				$logger.fatal("Error calculating running transfers - #{$!} - Exiting")
+				$@.each() { |line|
+					$logger.fatal(line)
+				}
+				exit(1)
+			end
+			
+			# now collect the eligable transfers for running
+			begin
+				# collect the possible transfers in a hash of arrays.  The arrays are hashed by priority
+				# so that we can easily randomly choose from amongst groups of like priority transfers
+				eligabletransfers = Hash.new()
+				configuration.transfers.each() { |transfer|
+					if(transfer.eligable?())
+						# get the ip address from either the from or the to.  If we can get an ip address, and we already
+						# have a transfer running for that ip, then this transfer is not eligable either
+						ipaddress = extract_ip(transfer.from, transfer.to)
+						if(ipaddress != nil and runningipaddresses.has_key?(ipaddress))
+							next
+						end
+						
+						# get the group id from the transfer and compare it to a list of already involved
+						# groups - never run more than one transfer in the same group
+						if(transfer.group != nil and runninggroups.has_key?(transfer.group))
+							next
+						end
+						
+						$logger.debug("priority of \"#{transfer.description}\" is #{transfer.priority}")
+						
+						# add it to the eligabletransfers array if the priority is greater than 100 (meaning
+						# it is at it's ideal running time).  NOTE - it is important to get a static priority
+						# instead of calling transfer.priority each time because the priority can change over the
+						# course of the checks... leading to be juju when we make a slot for it and then try to add
+						# to a different slot.  ;)
+						priority = transfer.priority
+						if(priority >= 100)
+							if(eligabletransfers[priority] == nil)
+								eligabletransfers[priority] = Array.new()
+							end
+							eligabletransfers[priority] << transfer
+						end
+					end
+				}
+			rescue Exception
+				$logger.fatal("Error during check of eligable transfers - #{$!} - Exiting")
+				$@.each() { |line|
+					$logger.fatal(line)
+				}
+				exit(1)
+			end
+			
+			
+			# choose a transfer to actually run
+			begin
+				# check the maximum number of transfers and whether we still have any to run
+				if(numberrunning < configuration.general['maxtransfers'] and eligabletransfers.length > 0)
+					priorities = eligabletransfers.keys()
+					priorities.sort() { |x,y|
+						y <=> x
+					}
+					
+					priorities.each() { |priority|
+						if(foundtransfer == true)
+							break
+						end
+						
+						idealtransfers = eligabletransfers[priority]
+						
+						while(idealtransfers.length > 0)
+							idealtransferindex = rand(idealtransfers.length)
+							idealtransfer = idealtransfers[idealtransferindex]
+							idealtransfers.delete_at(idealtransferindex)
+							
+							# check the per-transfer cutoffprogram
+							if(idealtransfer.cutoffprogram != '' and !system(idealtransfer.cutoffprogram))
+								foundtransfer = false
+								next
+							end
+							
+							foundtransfer = true
+							idealtransfer.run()
+							break;
+						end
+					}
+				end
+				
+				if(foundtransfer == false)
+					$logger.debug("no transfer currently ready to run")
+				end
+			rescue Exception
+				$logger.fatal("Error choosing ideal transfer - #{$!} - Exiting")
+				$@.each() { |line|
+					$logger.fatal(line)
+				}
+				exit(1)
+			end
+		end
+	end
+end
+
+
+# run the program
+RsyncManager.main()

data/tests/test_configuration.rb

@@ -0,0 +1,3 @@
+#!/usr/local/bin/ruby
+
+require 'test/unit'

metadata

@@ -0,0 +1,41 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: rsyncmanager
+version: !ruby/object:Gem::Version 
+  version: "1.1"
+date: 2005-06-19
+summary: RsyncManager is a daemon for controlling and monitoring rsync transfers
+require_paths: 
+  - lib
+email: david@grayskies.net
+homepage: http://rsyncmanager.rubyforge.org
+rubyforge_project: rsyncmanager
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - David Powers
+files: 
+  - bin/rsyncmanager.rb
+test_files: 
+  - tests/test_configuration.rb
+rdoc_options: []
+extra_rdoc_files: []
+executables: 
+  - rsyncmanager.rb
+extensions: []
+requirements: 
+  - rsync
+  - scp
+dependencies: []