lsync 1.2.5 → 2.0.2

data/lib/lsync/methods/rsync.rb

@@ -0,0 +1,132 @@
+
+require 'lsync/method'
+
+module LSync
+	module Methods
+		
+		class RSync < Method
+			protected
+			
+			def connect_arguments (local_server, remote_server)
+				# RSync -e option simply appends the hostname. There is no way to control this behaviour.
+				command = remote_server.shell.connection_command(remote_server)
+
+				if command.last != remote_server.host
+					abort "RSync shell requires hostname at end of command! #{cmd.inspect}"
+				else
+					command.pop
+				end
+
+				return ['-e', command.to_cmd]
+			end
+
+			public
+			
+			def initialize(direction, options = {})
+				super(options)
+				@direction = direction
+				@command = options[:command] || "rsync"
+				
+				@options = options
+				@connection = nil
+			end
+			
+			def run(master_server, target_server, directory)
+				arguments = (@options[:arguments] || ["--archive"]) + (directory.options[:arguments] || [])
+
+				local_server = nil
+				remote_server = nil
+
+				if @direction == :push
+					local_server = master_server
+					remote_server = target_server
+
+					dst = remote_server.connection_string(directory)
+					src = local_server.full_path(directory)
+				else
+					local_server = target_server
+					remote_server = master_server
+
+					src = remote_server.connection_string(directory)
+					dst = local_server.full_path(directory)
+				end
+
+				arguments += connect_arguments(local_server, remote_server)
+
+				# Create the destination backup directory
+				@connection = target_server.connect
+				@connection.send_object([:mkdir_p, target_server.full_path(directory)])
+
+				@logger.info "In directory #{Dir.getwd}..."
+				Dir.chdir(local_server.root) do
+					if run_handler(src, dst, arguments) == false
+						raise BackupMethodError.new("Backup from #{src.dump} to #{dst.dump} failed.", :method => self)
+					end
+				end
+			end
+			
+			def run_handler(src, dst, arguments)
+				run_command([@command] + arguments + [src, dst])
+			end
+			
+			def should_run?(master_server, current_server, target_server)
+				if @direction == :push
+					return current_server == master_server
+				elsif @direction == :pull
+					return target_server.is_local?
+				else
+					return false
+				end
+			end
+			
+			def run_command(cmd)
+				return LSync.run_command(cmd, @logger) == 0
+			end
+		end
+		
+		class RSyncSnapshot < RSync
+			def inprogress_path
+				@options[:inprogress_path] || "backup.inprogress"
+			end
+			
+			def run(master_server, target_server, directory)
+				arguments = (@options[:arguments] || []) + (directory.options[:arguments] || [])
+				
+				link_dest = Pathname.new("../" * (directory.path.depth + 1)) + "latest" + directory.path
+				arguments += ['--archive', '--link-dest', link_dest.to_s]
+
+				dst_directory = File.join(inprogress_path, directory.to_s)
+
+				local_server = nil
+				remote_server = nil
+
+				if @direction == :push
+					local_server = master_server
+					remote_server = target_server
+
+					dst = remote_server.connection_string(dst_directory)
+					src = local_server.full_path(directory)
+				else
+					local_server = target_server
+					remote_server = master_server
+
+					dst = local_server.full_path(dst_directory)
+					src = remote_server.connection_string(directory)
+				end
+
+				arguments += connect_arguments(local_server, remote_server)
+
+				# Create the destination backup directory
+				@connection = target_server.connect
+				@connection.send_object([:mkdir_p, target_server.full_path(dst_directory)])
+
+				Dir.chdir(local_server.root) do
+					if run_handler(src, dst, arguments) == false
+						raise BackupMethodError.new("Backup from #{src.dump} to #{dst.dump} failed.", :method => self)
+					end
+				end
+			end
+		end
+		
+	end
+end

data/lib/lsync/run.rb

@@ -2,33 +2,34 @@
 require 'rexec/task'
 
 module LSync
-  
-  def self.run_command(command, logger)
-    logger.info "Running: #{command} in #{Dir.getwd.dump}"
-    
-    process_result = RExec::Task.open(command) do |task|
-      task.input.close
-      pipes = [task.output, task.error]
-
-      while pipes.size > 0
-        result = IO.select(pipes)
-
-        result[0].each do |pipe|
-          if pipe.closed? || pipe.eof?
-            pipes.delete(pipe)
-            next
-          end
-
-          if pipe == task.output
-            logger.info pipe.readline.chomp
-          elsif pipe == task.error
-            logger.error pipe.readline.chomp
-          end
-        end
-      end
-    end
-    
-    return process_result
-  end
-  
+
+	# Run a specific command and output the results to the given logger.
+	def self.run_command(command, logger)
+		logger.info "Running: #{command.to_cmd} in #{Dir.getwd.dump}"
+
+		process_result = RExec::Task.open(command) do |task|
+			task.input.close
+			pipes = [task.output, task.error]
+
+			while pipes.size > 0
+				result = IO.select(pipes)
+
+				result[0].each do |pipe|
+					if pipe.closed? || pipe.eof?
+						pipes.delete(pipe)
+						next
+					end
+
+					if pipe == task.output
+						logger.info pipe.readline.chomp
+					elsif pipe == task.error
+						logger.error pipe.readline.chomp
+					end
+				end
+			end
+		end
+
+		return process_result
+	end
+
 end

data/lib/lsync/script.rb

@@ -7,130 +7,217 @@ require 'lsync/server'
 require 'lsync/directory'
 
 module LSync
-
-  class Script
-    private
-    # Given a name, find out which server config matches it
-    def find_named_server name
-      if @servers.key? name
-        return @servers[name]
-      else
-        hostname = Socket.gethostbyname(name)[0] rescue name
-        return @servers.values.find { |s| s["host"] == hostname }
-      end
-    end
-
-    # Find out the config section for the current server
-    def find_current_server
-      server = nil
-
-      # Find out if the master server is local...
-      if @master.is_local?
-        server = @master
-      else
-        # Find a server config that specifies the local host
-        server = @servers.values.find { |s| s.is_local? }
-      end
-
-      return server
-    end
-
-    def script_logger
-      if @config["log-file"]
-        return Logger.new(@config["log-file"], 'weekly')
-      end
-    end
-
-    public
-    def initialize(config, logger = nil)
-      @config = config
-      
-      @logger = logger || Logger.new(STDOUT)
-
-      @servers = config.keys_matching(/^server\./) { |c,n| Server.new(c) }
-      @directories = config.keys_matching(/^directory\./) { |c,n| Directory.new(c) }
-
-      @master = find_named_server(config["master"])
-
-      if @master == nil
-        raise ConfigurationError.new("Could not determine master server!", :script => self)
-      end
-
-      @method = Method.new(config["method"])
-      @log_buffer = nil
-    end
-
-    attr :logger, true
-    attr :master
-    attr :method
-    attr :servers
-    attr :directories
-    attr :log_buffer
-
-    def run_backup
-      # We buffer the log data so that if there is an error it is available to the notification sub-system
-      @log_buffer = StringIO.new
-      logger = @logger.tee(script_logger, Logger.new(@log_buffer))
-
-      current = find_current_server
-
-      # At this point we must know the current server or we can't continue
-      if current == nil
-        raise ScriptError.new("Could not determine current server!", :script => self, :master => @master)
-      end
-
-      if @master.is_local?
-        logger.info "We are the master server..."
-      else
-        logger.info "We are not the master server..."
-        logger.info "Master server is #{@master}..."
-      end
-
-      # Run server pre-scripts.. if these fail then we abort the whole backup
-      begin
-        @method.run_actions(:before, logger)
-        @master.run_actions(:before, logger)
-      rescue AbortBackupException
-        return
-      end
-
-      logger.info "Running backups for server #{current}..."
-
-      @servers.each do |name, s|
-        # S is always a data destination, therefore s can't be @master
-        next if s == @master
-
-        # Skip servers that shouldn't be processed
-        unless @method.should_run?(@master, current, s)
-          logger.info "\t" + "Skipping".rjust(20) + " : #{s}"
-          next
-        end
-
-        # Run pre-scripts for a particular server
-        begin
-          s.run_actions(:before, logger)
-        rescue AbortBackupException
-          next
-        end
-
-        @directories.each do |name, d|
-          logger.info "\t" + ("Processing " + d.to_s).rjust(20) + " : #{s}"
-
-          @method.logger = logger
-          @method.run(@master, s, d)
-        end
-
-        # Run post-scripts for a particular server
-        s.run_actions(:after, logger)
-      end
-
-      @method.run_actions(:after, logger)
-      @master.run_actions(:after, logger)
-    end
-
-    def self.load_from_file(path)
-      new(YAML::load(File.read(path)))
-    end
-  end
+	
+	# The server controller provides event handlers with a unified interface
+	# for dealing with servers and associated actions.
+	class ServerController
+		def initialize(script, server, logger)
+			@script = script
+			@server = server
+			@logger = logger
+		end
+		
+		# The containing script.
+		attr :script
+		
+		# The current server.
+		attr :server
+		
+		# The output logger.
+		attr :logger
+		
+		# Run a given shell script on the server.
+		def run!(*function)
+			action = Action.new(function)
+			action.run_on_server(@server, @logger)
+		end
+	end
+	
+	# The directory controller provides event handlers with a unified interface
+	# for dealing with a particular backup in a particular directory.
+	class DirectoryController < ServerController
+		def initialize(script, master, server, directory, logger)
+			super(script, server, logger)
+			
+			@master = master
+			@directory = directory
+		end
+		
+		# The master server where data is being copied from.
+		attr :master
+		
+		# The directory that the data is being copied within.
+		attr :directory
+	end
+	
+	# The main backup/synchronisation mechanism is the backup script. It specifies all
+	# servers and directories, and these are then combined specifically to produce the
+	# desired data replication behaviour.
+	class Script
+		include EventHandler
+		
+		def initialize(options = {}, &block)
+			@logger = options[:logger] || Logger.new($stdout)
+			@method = nil
+			
+			@servers = {}
+			@directories = []
+
+			@log = nil
+			
+			if block_given?
+				instance_eval &block
+			end
+		end
+		
+		# Given a name, find out which server config matches it
+		def find_named_server name
+			if @servers.key? name
+				return @servers[name]
+			else
+				hostname = Socket.gethostbyname(name)[0] rescue name
+				return @servers.values.find { |s| s["host"] == hostname }
+			end
+		end
+		
+		alias :[] :find_named_server
+		
+		# Find the master server based on the name #master= specified
+		def find_master_server
+			find_named_server(@master)
+		end
+		
+		# Find out the config section for the current server
+		def find_current_server
+			master = find_master_server
+			server = nil
+			
+			# Find out if the master server is local...
+			if master.is_local?
+				server = master
+			else
+				# Find a server config that specifies the local host
+				server = @servers.values.find { |s| s.is_local? }
+			end
+			
+			return server
+		end
+		
+		# Register a server with the backup script.
+		def server(name, &block)
+			case name
+			when Symbol
+				host = "localhost"
+			else
+				host = name.to_s
+			end
+			
+			server = Server.new(host)
+			
+			yield server if block_given?
+			
+			@servers[name] = server
+		end
+		
+		# Backup a particular path (or paths).
+		def backup(*paths, &block)
+			paths.each do |path|
+				directory = Directory.new(path)
+				
+				yield directory if block_given?
+				
+				@directories << directory
+			end
+		end
+
+		# The script logger which will be provided all events when the script is run.
+		attr :logger, true
+		
+		# The master server name (e.g. symbolic or host name)
+		attr :master, true
+		
+		# A specific method which will perform the backup (e.g. an isntance of LSync::Method)
+		attr :method, true
+		
+		# All servers which are participating in the backup process.
+		attr :servers
+		
+		# All directories which may be synchronised.
+		attr :directories
+		
+		# Log data (an +IO+) specific to the current script.
+		attr :log
+		
+		# Run the backup process for all servers and directories specified.
+		def run!
+			start_time = Time.now
+			
+			# We buffer the log data so that if there is an error it is available to the notification sub-system
+			@log = StringIO.new
+			local_logger = Logger.new(@log)
+			local_logger.formatter = MinimalLogFormat.new
+			logger = @logger.tee(local_logger)
+
+			master = find_master_server
+			current = find_current_server
+
+			# At this point we must know the current server or we can't continue
+			if current == nil
+				raise ScriptError.new("Could not determine current server!", :script => self, :master => @master)
+			end
+
+			if master.is_local?
+				logger.info "We are the master server..."
+			else
+				logger.info "We are not the master server..."
+				logger.info "Master server is #{@master}..."
+			end
+
+			master_controller = ServerController.new(self, master, logger)
+
+			self.try do
+				method.try do
+					master.try(master_controller) do
+						logger.info "Running backups for server #{current}..."
+						
+						run_backups!(master, current, logger)
+					end
+				end
+			end
+			
+			end_time = Time.now
+			logger.info "Backup Completed (#{end_time - start_time}s)."
+		end
+		
+		protected
+		
+		# This function runs the method for each directory and server combination specified.
+		def run_backups!(master, current, logger)
+			@servers.each do |name, server|
+				# S is always a data destination, therefore s can't be @master
+				next if server == master
+
+				# Skip servers that shouldn't be processed
+				unless @method.should_run?(master, current, server)
+					logger.info "\t" + "Skipping".rjust(20) + " : #{s}"
+					next
+				end
+
+				server_controller = ServerController.new(self, server, logger)
+
+				server.try(server_controller) do
+					@directories.each do |directory|
+						directory_controller = DirectoryController.new(self, master, server, directory, logger)
+
+						directory.try(directory_controller) do
+							logger.info "\t" + ("Processing " + directory.to_s).rjust(20) + " : #{server}"
+					
+							method.run(master, server, directory)
+						end
+					end
+				end
+			end
+		end
+	end
 
 end