lsync 1.2.5 → 2.0.2

data/lib/lsync/server.rb

@@ -1,94 +1,79 @@
 
-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
+require 'lsync/event_handler'
+require 'lsync/shells/ssh'
+
+module LSync
+	class Server
+		include EventHandler
+		
+		def initialize(host)
+			@host = host
+			@root = "/"
+			
+			@platform = "generic"
+			
+			@shell = Shells::SSH.new
+			
+			@enabled = true
+			@connection = nil
+			@pid = nil
+		end
+		
+		# The host name (e.g. DNS entry) for the given server
+		attr :host, true
+		
+		# The root path on the server in which all other directories will be relative to.
+		attr :root, true
+		
+		# The platform of the server, e.g. linux, used for executing actions.
+		attr :platform, true
+		
+		# The shell to use to connect to the server.
+		attr :shell, true
+
+		# Give the full path for a particular subdirectory.
+		def full_path(directory = "./")
+			p = File.expand_path(directory.to_s, @root)
+
+			return Pathname.new(p).cleanpath.normalize_trailing_slash.to_s
+		end
+
+		# Give a general connection string (e.g +"host:/directory"+ or +"/directory"+ if local).
+		def connection_string(directory)
+			if is_local?
+				return full_path(directory)
+			else
+				return @host + ":" + full_path(directory).dump
+			end
+		end
+
+		# Checks if the host resolves to the local machine.
+		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
+
+		# String representation of the server for logging.
+		def to_s
+			"#{@host}:#{full_path}"
+		end
+
+		# Connect to the server using the given #shell and #connection_string.
+		def connect
+			unless @connection
+				@connection, @pid = @shell.connect(self)
+			end
+
+			return @connection
+		end
+	end
 end

data/lib/lsync/shell.rb

@@ -3,101 +3,62 @@ 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
-  
+	CLIENT_CODE = (Pathname.new(__FILE__).dirname + "shell_client.rb").read
+	
+	# There was an error establishing a connection with a server.
+	class ConnectionError < StandardError
+	end
+	
+	# A shell provides access to a server, typically to run an instance of `ruby`.
+	class Shell
+		def initialize(command, options = {})
+			case command
+			when Array
+				@command = command
+			else
+				@command = [command]
+			end
+			
+			@options = options
+		end
+		
+		# The command required to start an instance of Ruby.
+		def ruby_command
+			@options[:ruby] || ["ruby"]
+		end
+		
+		# The command required to connect to the remote machine.
+		def connection_command(server, arguments = [])
+			@command + (@options[:arguments] || []) + arguments + [server.host]
+		end
+		
+		# Establish a connection to the server using this shell configuration.
+		def connect(server)
+			begin
+				connection, pid = open_connection(server)
+				message = connection.receive_object
+			ensure
+				connection.dump_errors if connection
+			end
+			
+			if message != :ready
+				raise ConnectionError.new("Remote shell connection was not successful: #{message}")
+			end
+			
+			return connection, pid
+		end
+		
+		protected
+		# Return a connection object representing a connection to the given server.
+		def open_connection(server)
+			command = ruby_command
+			
+			unless server.is_local?
+				command = connection_command(server) + command
+			end
+			
+			return RExec::start_server(CLIENT_CODE, command)
+		end
+	end
+	
 end

data/lib/lsync/shell_client.rb

@@ -12,73 +12,77 @@ $logger = Logger.new "/tmp/remote-client.log"
 $logger.info "Starting remote shell @ #{Time.now.to_s}"
 
 def script_path(named)
-  File.join(LSYNC_TMP_DIRECTORY, "#{named}")
+	File.join(LSYNC_TMP_DIRECTORY, "#{named}")
 end
 
 module RemoteMethods
-  def self.run_command(cmd)
-    $connection.send_object([:info, "Running #{cmd}..."])
-    
-    cin, cout, cerr = Open3.popen3(cmd)
-    cin.close
-    
-    pipes = [cout, cerr]
-    
-    while pipes.size > 0
-      ready = IO.select(pipes)
-      $logger.info(ready.inspect)
-      
-      ready[0].each do |pipe|
-        # Delete the pipe when it has become closed
-        if pipe.closed? || pipe.eof?
-          pipes.delete(pipe)
-          next
-        end
-        
-        line = pipe.readline.chomp
-        mode = (pipe == cout ? :info : :error)
-        
-        $logger.send(mode, line)
-        $connection.send_object([mode, line])
-      end
-    end
-    
-    $logger.info "Done running command."
-    $connection.send_object(:done)
-  end
-  
-  def self.run_script(name, code, arguments)
-    path = script_path(name)
-    
-    File.open(path, "w") do |f|
-      f.write(code)
-    end
-    
-    FileUtils.chmod 0755, path
-    
-    run_command(path + " " + arguments)
-  end
-  
-  def self.mkdir_p(path)
-    FileUtils.mkdir_p(path)
-  end
-  
-  def self.set_working_dir(path)
-    Dir.chdir(path)
-  end
+	# Run a command in the local environment.
+	def self.run_command(cmd)
+		$logger.info("Running #{cmd.inspect}...")
+		$connection.send_object([:info, "Running #{cmd.inspect}..."])
+
+		cin, cout, cerr = Open3.popen3(*cmd)
+		cin.close
+
+		pipes = [cout, cerr]
+
+		while pipes.size > 0
+			ready = IO.select(pipes)
+
+			ready[0].each do |pipe|
+				# Delete the pipe when it has become closed
+				if pipe.closed? || pipe.eof?
+					pipes.delete(pipe)
+					next
+				end
+
+				line = pipe.readline.chomp
+				mode = (pipe == cout ? :info : :error)
+
+				$logger.send(mode, line)
+				$connection.send_object([mode, line])
+			end
+		end
+
+		$logger.info "Done running command."
+		$connection.send_object(:done)
+	end
+
+	# Run a script (given the code) in the local environment.
+	def self.run_script(name, code, arguments)
+		path = script_path(name)
+
+		File.open(path, "w") do |f|
+			f.write(code)
+		end
+
+		FileUtils.chmod 0755, path
+
+		run_command([path] + arguments)
+	end
+
+	# Recursively make a directory (typically the server.root + directory)
+	def self.mkdir_p(path)
+		FileUtils.mkdir_p(path)
+	end
+
+	# Set the working directory (typically the server.root)
+	def self.set_working_dir(path)
+		Dir.chdir(path)
+	end
 end
 
 begin
-  $connection.send_object(:ready)
-  
-  $connection.run do |message|
-    method = message.shift
-    $logger.info("Calling #{method}...")
-    result = RemoteMethods.send(method, *message)
-  end
+	$connection.send_object(:ready)
+
+	$connection.run do |message|
+		method = message.shift
+		$logger.info("Calling #{method}...")
+		result = RemoteMethods.send(method, *message)
+	end
 rescue
-  $logger.error("Exception caught: #{$!}")
-  exit(1)
+	$logger.error("Exception caught: #{$!}")
+	exit(1)
 ensure
-  FileUtils.rm_rf(LSYNC_TMP_DIRECTORY)
+	FileUtils.rm_rf(LSYNC_TMP_DIRECTORY)
 end