lsync 1.2.5 → 2.0.2

data/lib/lsync/actions/linux/disk

@@ -1,14 +1,14 @@
 #!/usr/bin/env ruby
 
 Commands = {
-  "mount" => "mount",
-  "unmount" => "umount"
+	"mount" => "mount",
+	"unmount" => "umount"
 }
 
 DevicePaths = [
-  "/dev/disk/by-label",
-  "/dev/disk/by-uuid",
-  "/dev"
+	"/dev/disk/by-label",
+	"/dev/disk/by-uuid",
+	"/dev"
 ]
 
 action = ARGV[0]
@@ -19,10 +19,10 @@ mountpoint = File.join('', 'mnt', disk_name)
 if (action == 'mountpoint')
 	puts File.join(mountpoint, ARGV[2..-1])
 else
-  puts "#{action.capitalize}ing #{mountpoint}..."
-  system Commands[action], mountpoint
-  
-  if $?.exitstatus != 0 or $?.exitstatus != 3383
-    exit 5
-  end
+	puts "#{action.capitalize}ing #{mountpoint}..."
+	system Commands[action], mountpoint
+
+	if $?.exitstatus != 0 or $?.exitstatus != 3383
+		exit 5
+	end
 end

data/lib/lsync/actions/linux/terminal

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 
 require 'base64'
+
 cmd = Base64.decode64(ARGV[0])
+
 exec cmd
 

data/lib/lsync/directory.rb

@@ -1,50 +1,64 @@
 
+require 'lsync/event_handler'
 require 'pathname'
 
 class Pathname
-  def components
-    return to_s.split(SEPARATOR_PAT)
-  end
-  
-  def normalize_trailing_slash
-    if to_s.match(/\/$/)
-      return self
-    else
-      return self.class.new(to_s + "/")
-    end
-  end
-
-	# Returns the number of path components
-	# We need to work with a cleanpath to get an accurate depth
-	# "", "/" => 0
-	# "bob" => 1
-	# "bob/dole" => 2
-	# "/bob/dole" => 2
+	# Split a pathname up based on the individual path components.
+	def components
+		return to_s.split(SEPARATOR_PAT)
+	end
+
+	# Add a trailing slash to the path if it doesn't already exist.
+	def normalize_trailing_slash
+		if to_s.match(/\/$/)
+			return self
+		else
+			return self.class.new(to_s + "/")
+		end
+	end
+
+	# Returns the number of path components in a normalised fashion.
 	#
+	# We need to work with a cleanpath to get an accurate depth:
+	#	"", "/" => 0
+	#	"bob" => 1
+	#	"bob/dole" => 2
+	#	"/bob/dole" => 2
 	def depth
 		bits = cleanpath.to_s.split(SEPARATOR_PAT)
-		
+
 		bits.delete("")
 		bits.delete(".")
-		
+
 		return bits.size
 	end
 end
 
 module LSync
-  
-  class Directory
-    def initialize(config)
-      @path = Pathname.new(config["path"]).cleanpath.normalize_trailing_slash
-      
-      abort "Directory paths must be relative (#{config["path"]} is absolute!)." if @path.absolute?
-    end
-    
-    attr :path
-    
-    def to_s
-      @path.to_s
-    end
-  end
-  
+
+	# A specific directory which is relative to the root of a given server. Specific configuration details
+	# such as excludes and other options may be specified.
+	class Directory
+		include EventHandler
+		
+		def initialize(path)
+			@path = Pathname.new(path).cleanpath.normalize_trailing_slash
+			@options = {:arguments => []}
+		end
+
+		attr :path
+		attr :options
+
+		# Exclude a specific shell glob pattern.
+		def exclude(pattern)
+			# RSync specific... need to figure out if there is a good way to do this generally.
+			@options[:arguments] += ["--exclude", pattern]
+		end
+
+		# A string representation of the path for logging.
+		def to_s
+			@path.to_s
+		end
+	end
+
 end

data/lib/lsync/error.rb

@@ -1,33 +1,33 @@
 
 module LSync
-  
-  class Error < StandardError
-    def initialize(reason, components = {})
-      @reason = reason
-      @components = components
-    end
-    
-    def to_s
-      @reason
-    end
-    
-    attr :reason
-    attr :components
-  end
-  
-  class ScriptError < Error
-  end
-  
-  class BackupMethodError < Error
-  end
-  
-  class ConfigurationError < Error
-  end
-  
-  class BackupActionError < Error
-    def initialize(server, action, exception)
-      super("Backup action failed: #{action} (#{exception.to_s})", :action => action, :exception => exception)
-    end
-  end
-  
+
+	# Base exception class which keeps track of related components.
+	class Error < StandardError
+		def initialize(reason, components = {})
+			@reason = reason
+			@components = components
+		end
+
+		def to_s
+			@reason
+		end
+
+		attr :reason
+		attr :components
+	end
+
+	# Indicates that there has been a major backup script error.
+	class ScriptError < Error
+	end
+
+	# Indicates that there has been a major backup method error.
+	class BackupMethodError < Error
+	end
+
+	# Indicates that a backup action shell script has failed.
+	class ShellScriptError < Error
+		def initialize(script, return_code)
+			super("Shell script #{script} failed", :return_code => return_code)
+		end
+	end
 end

data/lib/lsync/event_handler.rb

@@ -0,0 +1,72 @@
+
+module LSync
+	
+	# Basic event handling and delegation.
+	module EventHandler
+		# Register an event handler which may be triggered when an event is fired.
+		def on(event, &block)
+			@events ||= {}
+
+			@events[event] ||= []
+			@events[event] << block
+		end
+
+		# Fire an event which calls all registered event handlers in the order they were defined.
+		def fire(event, *args)
+			handled = false
+			
+			if @events && @events[event]
+				@events[event].each do |handler|
+					handled = true
+					handler.call(*args)
+				end
+			end
+			
+			return handled
+		end
+		
+		# Try executing a given block of code and fire appropriate events.
+		#
+		# The sequence of events (registered via #on) are as follows:
+		# [+:prepare+]  Fired before the block is executed. May call #abort! to cancel execution.
+		# [+:success+]  Fired after the block of code has executed without raising an exception.
+		# [+:failure+]  Fired if an exception is thrown during normal execution.
+		# [+:done+]     Fired at the end of execution regardless of failure.
+		#
+		# If #abort! has been called in the past, this function returns immediately.
+		def try(*arguments)
+			return if @aborted
+			
+			begin
+				catch(abort_name) do
+					fire(:prepare, *arguments)
+					
+					yield
+					
+					fire(:success, *arguments)
+				end
+			rescue Exception => error
+				# Propagage the exception unless it was handled in some specific way.
+				raise unless fire(:failure, *arguments + [error])
+			ensure
+				fire(:done, *arguments)
+			end
+		end
+		
+		# Abort the current event handler. Aborting an event handler persistently implies that in 
+		# the future it will still be aborted; thus calling #try will have no effect.
+		def abort!(persistent = false)
+			@aborted = true if persistent
+			
+			throw abort_name
+		end
+		
+		private
+		
+		# The name used for throwing abortions.
+		def abort_name
+			("abort_" + self.class.name).downcase.to_sym
+		end
+	end
+	
+end

data/lib/lsync/event_timer.rb

@@ -0,0 +1,80 @@
+
+require 'thread'
+
+module LSync
+	
+	# Manages a callback that will be executed after a set duration.
+	class Timeout
+		def initialize(timeout, &block)
+			@cancelled = false
+			
+			@thread = Thread.new do
+				sleep timeout
+				
+				unless @cancelled
+					yield
+				end
+			end
+		end
+		
+		# The thread on which the timeout is being waited.
+		attr :thread
+		
+		# Cancel the timeout if possible and ensure that the callback is not executed.
+		def cancel!
+			@cancelled = true
+			@thread.exit
+		end
+	end
+	
+	# The EventTimer provides a simple time based callback mechanism in which events can be aggregated.
+	# If the timer is triggered once, it will take at most max time for the callback to be triggered.
+	class EventTimer
+		# Times are measured in seconds.
+		# Min specifies the minimum duration between callback invocations.
+		# Max specifies the maximum duration between callback invocations.
+		def initialize(max, &block)
+			@max = max
+			
+			@fired = nil
+			@timeout = nil
+			
+			@callback = Proc.new(&block)
+			@processing = Mutex.new
+		end
+		
+		# Trigger the event timer such that within the specified time, the callback will be fired.
+		def trigger!
+			unless @timeout
+				@timeout = Timeout.new(@max) { fire! }
+			end
+		end
+		
+		private
+		
+		# Return true of the timeout has expired, e.g if it has not been fired within the given duration.
+		def expired?(duration = nil)
+			!@fired || ((Time.now - @fired) > duration)
+		end
+		
+		# Fire the callback.
+		def fire!
+			@processing.synchronize do
+				@timeout = nil
+				
+				@fired = Time.now
+				@callback.call
+			end
+		end
+		
+		public
+		
+		# Wait for the timeout to complete nicely.
+		def join
+			if @timeout
+				@timeout.thread.join
+			end
+		end
+	end
+	
+end

data/lib/lsync/method.rb

@@ -2,191 +2,25 @@
 require 'fileutils'
 require 'pathname'
 require 'lsync/run'
+require 'lsync/event_handler'
 
 module LSync
-  
-  class Method
-    @@methods = {}
-    
-    def self.register(name, handler)
-      @@methods[name] = handler
-    end
-    
-    def self.lookup(name)
-      @@methods[name]
-    end
-    
-    def initialize(config, logger = nil)
-      @logger = logger || Logger.new(STDOUT)
-      
-      @name, @options = config.split(/\s+/, 2)
-      
-      @method = Method.lookup(@name)
-      
-      if @method == nil
-        raise BackupError.new("Could not find method #{@name}!")
-      end
-    end
-    
-    attr :logger, true
-    
-    def run(master_server, target_server, directory)
-      @method.run(master_server, target_server, directory, @options, @logger)
-    end
-    
-    def should_run?(master_server, current_server, target_server)
-      @method.should_run?(master_server, current_server, target_server)
-    end
-    
-    def run_actions(actions, logger)
-    end
-  end
-  
-  module Methods
-    module DirectionalMethodHelper
-      protected
-      def connect_options_for_server (local_server, remote_server)
-        # RSync -e option simply appends the hostname. There is no way to control this behaviour.
-        cmd = remote_server.shell.full_command(remote_server)
-        
-        if cmd.match(/ #{remote_server.host}$/)
-          cmd.gsub!(/ #{remote_server.host}$/, "")
-        else
-          abort "RSync shell requires hostname at end of command! #{cmd.dump}"
-        end
-        
-        ['-e', cmd.dump].join(" ")
-      end
-      
-      public
-      def initialize(direction)
-        @direction = direction
-      end
-      
-      def run(master_server, target_server, directory, options, logger)
-        options ||= ""
-        
-        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
-        
-        options += " " + connect_options_for_server(local_server, remote_server)
-        
-        # Create the destination backup directory
-        @connection = target_server.connect
-        @connection.send_object([:mkdir_p, target_server.full_path(directory)])
-        
-        @logger = logger
-        
-				@logger.info "In directory #{Dir.getwd}"
-        Dir.chdir(local_server.root_path) do
-          if run_handler(src, dst, options) == false
-            raise BackupMethodError.new("Backup from #{src.dump} to #{dst.dump} failed.", :method => self)
-          end
-        end
-      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 RSync
-      include DirectionalMethodHelper
-    
-      def run_handler(src, dst, options)
-        run_command("rsync #{options} #{src.dump} #{dst.dump}")
-      end
-    end
-  
-    Method.register("rsync-pull", RSync.new(:pull))
-    Method.register("rsync-push", RSync.new(:push))
-    
-    class RSyncSnapshot < RSync
-      def run(master_server, target_server, directory, options, logger)
-        options ||= ""
-        link_dest = Pathname.new("../" * (directory.path.depth + 1)) + "latest" + directory.path
-        options += " --archive --link-dest #{link_dest.to_s.dump}"
-        
-        inprogress_path = ".inprogress"
-        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
-        
-        options += " " + connect_options_for_server(local_server, remote_server)
-        
-        # Create the destination backup directory
-        @connection = target_server.connect
-        @connection.send_object([:mkdir_p, target_server.full_path(dst_directory)])
-        
-        @logger = logger
-        
-        Dir.chdir(local_server.root_path) do
-          if run_handler(src, dst, options) == false
-            raise BackupMethodError.new("Backup from #{src.dump} to #{dst.dump} failed.", :method => self)
-          end
-        end
-      end
-    end
-    
-    Method.register("rsync-snapshot-pull", RSyncSnapshot.new(:pull))
-    Method.register("rsync-snapshot-push", RSyncSnapshot.new(:push))
-  
-    class LinkBackup
-      include DirectionalMethodHelper
-      
-      def self.lb_bin
-        return File.join(File.dirname(__FILE__), "lb.py")
-      end
-      
-      def run_handler(src, dst, options)
-        # Verbose mode for debugging..
-        # options += " --verbose"
-        run_command("python #{LinkBackup.lb_bin.dump} #{options} #{src.dump} #{dst.dump}")
-      end
-    end
-  
-    Method.register("lb-pull", LinkBackup.new(:pull))
-    Method.register("lb-push", LinkBackup.new(:push))
-  
-  end
-  
+	
+	# A backup method provides the interface to copy data from one system to another.
+	class Method
+		include EventHandler
+		
+		def initialize(options = {})
+			@logger = options[:logger] || Logger.new(STDOUT)
+		end
+
+		attr :logger, true
+
+		def run(master_server, target_server, directory)
+		end
+
+		def should_run?(master_server, current_server, target_server)
+		end
+	end
+	
 end