lsync 1.2.1

data/lib/lsync/method.rb

@@ -0,0 +1,191 @@
+
+require 'fileutils'
+require 'pathname'
+require 'lsync/run'
+
+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
+        
+        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.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
+  
+end

data/lib/lsync/password.rb

@@ -0,0 +1,35 @@
+
+require 'termios'
+
+module Password
+  def self.echo(on=true, masked=false)
+    term = Termios::getattr( $stdin )
+
+    if on
+      term.c_lflag |= ( Termios::ECHO | Termios::ICANON )
+    else # off
+      term.c_lflag &= ~Termios::ECHO
+      term.c_lflag &= ~Termios::ICANON if masked
+    end
+
+    Termios::setattr( $stdin, Termios::TCSANOW, term )
+  end
+
+  def self.get(message="Password: ")
+    begin
+      if $stdin.tty?
+        echo false
+        print message if message
+      end
+
+      pw = $stdin.gets
+      pw.chomp!
+    ensure
+      if $stdin.tty?
+        echo true
+        print "\n"
+      end
+    end
+  end
+end
+

data/lib/lsync/run.rb

@@ -0,0 +1,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
+  
+end

data/lib/lsync/server.rb

@@ -0,0 +1,94 @@
+
+require 'lsync/shell'
+
+module LSync  
+  class Server
+    def initialize(config)
+      @host = config["host"] || "localhost"
+      @root = config["root"] || "/"
+
+      @actions = {
+        :before => (config["before"] || []).collect { |c| Action.new(c) },
+        :after => (config["after"] || []).collect { |c| Action.new(c) }
+      }
+
+      @shell = Shell.new(config["shell"])
+
+      @enabled = true
+      
+      @connection = nil
+      @pid = nil
+    end
+
+    def full_path(directory = "./")
+      p = File.expand_path(directory.to_s, root_path)
+      
+      return Pathname.new(p).cleanpath.normalize_trailing_slash.to_s
+    end
+
+    def connection_string(directory)
+      if is_local?
+        return full_path(directory)
+      else
+        return @host + ":" + full_path(directory).dump
+      end
+    end
+
+    def is_local?
+      return true if @host == "localhost"
+
+      hostname = Socket.gethostname
+
+      begin
+        hostname = Socket.gethostbyname(hostname)[0]
+      rescue SocketError
+        puts $!
+      end
+
+      return @host == hostname
+    end
+
+    def to_s
+      "#{@host}:#{full_path}"
+    end
+
+    def should_run?
+      return @enabled
+    end
+
+    def connect
+      unless @connection
+        @connection, @pid = @shell.connect(self)
+      end
+      
+      return @connection
+    end
+
+    attr :host
+    attr :shell
+    attr :root
+    
+    def root_path
+      if @root == nil
+        return "/"
+      else
+        return @root.to_s
+      end
+    end
+
+    def run_actions(actions, logger)
+      actions = @actions[actions] if actions.class == Symbol
+      return if actions.size == 0
+      
+      logger.info "Running #{actions.size} action(s):"
+      
+      actions.each do |a|
+        begin
+          a.run_on_server(self, logger)
+        rescue StandardError
+          raise BackupActionError.new(self, a, $!)
+        end
+      end
+    end
+  end
+end

data/lib/lsync/shell.rb

@@ -0,0 +1,103 @@
+
+require 'rexec'
+require 'pathname'
+
+module LSync
+  CLIENT_CODE = (Pathname.new(__FILE__).dirname + "shell_client.rb").read
+  
+  class Shell
+    # Command can be something like "ssh -l username -p 110"
+    def initialize(config)
+      if config.kind_of? String
+        @command = config
+        @options = {}
+      elsif config.kind_of? Hash
+        @command = config["command"]
+        @options = config.dup
+      end
+      
+      @command ||= "ssh $OPTIONS $HOST"
+      @options ||= {}
+      
+      if @command.match(/([^\s]+)/)
+        @name = $1
+      else
+        @name = nil
+      end
+    end
+    
+    def command_options
+      args = []
+      
+      if @name == "ssh"
+        @options.each do |k,v|
+          case(k.to_sym)
+          when :port
+            args += ['-p', v.to_i]
+          when :key
+            args += ['-i', v.dump]
+          when :keys
+            v.each { |key_path| args += ['-i', key_path.dump] } 
+          when :timeout
+            args += ['-o', "ConnectTimeout #{v.to_i}".dump]
+          when :compression
+            args += ['-C']
+          when :user
+            args += ['-l', v.to_s.dump]
+            # args += ['-o', "User #{v.to_s}".dump]
+          end
+        end
+      end
+      
+      return args.join(" ")
+    end
+    
+    def ruby_path
+      @options["ruby"] || "ruby"
+    end
+    
+    def full_command(server = nil)
+      cmd = @command.dup
+      
+      cmd.gsub!("$OPTIONS", command_options)
+
+      if server
+        cmd.gsub!("$HOST", server.host)
+        cmd.gsub!("$ROOT", server.root_path)
+      end
+      
+      return cmd
+    end
+    
+    protected
+    # Return a connection object representing a connection to the given server.
+    def open_connection(server)
+      if server.is_local?
+        $stderr.puts "Opening connection to #{ruby_path.dump}"
+        return RExec::start_server(CLIENT_CODE, ruby_path, :passthrough => [])
+      else
+        command = full_command(server) + " " + ruby_path.dump
+        $stderr.puts "Opening connection to #{command}"
+        return RExec::start_server(CLIENT_CODE, command, :passthrough => [])
+      end
+    end
+    
+    public
+    def connect(server)
+      begin
+        connection, pid = open_connection(server)
+        message = connection.receive_object
+      ensure
+        connection.dump_errors
+      end
+      
+      abort "Remote shell connection was not successful: #{message}" unless message == :ready
+      
+      return connection, pid
+    end
+    
+    attr :command
+    attr :name
+  end
+  
+end