rexec 1.1.10

data/lib/rexec/daemon/controller.rb

@@ -0,0 +1,192 @@
+# Copyright (c) 2007, 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rexec/daemon/pidfile'
+require 'rexec/task'
+
+module RExec
+  module Daemon
+    # Daemon startup timeout
+    TIMEOUT = 5
+    
+    # This module contains functionality related to starting and stopping the daemon, and code for processing command line input.
+    module Controller
+      # This function is called from the daemon executable. It processes ARGV and checks whether the user is asking for
+      # <tt>start</tt>, <tt>stop</tt>, <tt>restart</tt> or <tt>status</tt>.
+      def self.daemonize(daemon)
+        #puts "Running in #{WorkingDirectory}, logs in #{LogDirectory}"
+        case !ARGV.empty? && ARGV[0]
+        when 'start'
+          start(daemon)
+          status(daemon)
+        when 'stop'
+          stop(daemon)
+          status(daemon)
+          PidFile.cleanup(daemon)
+        when 'restart'
+          stop(daemon)
+          PidFile.cleanup(daemon)
+          start(daemon)
+          status(daemon)
+        when 'status'
+          status(daemon)
+        else
+          puts "Invalid command. Please specify start, restart, stop or status."
+          exit
+        end
+      end
+
+      # This function starts the supplied daemon
+      def self.start(daemon)
+        puts "Starting daemon..."
+        
+        case PidFile.status(daemon)
+        when :running
+          $stderr.puts "Daemon already running!"
+          return
+        when :stopped
+          # We are good to go...
+        else
+          $stderr.puts "Daemon in unknown state! Will clear previous state and continue."
+          status(daemon)
+          PidFile.clear(daemon)
+        end
+
+        daemon.prefork
+        daemon.mark_err_log
+
+        fork do
+          Process.setsid
+          exit if fork
+
+          PidFile.store(daemon, Process.pid)
+
+          File.umask 0000
+          Dir.chdir daemon.working_directory
+
+          $stdin.reopen "/dev/null"
+          $stdout.reopen daemon.log_fn, "a"
+          $stderr.reopen daemon.err_fn, "a"
+
+          main = Thread.new do
+            begin
+              daemon.run
+            rescue
+              $stderr.puts "=== Daemon Exception Backtrace @ #{Time.now.to_s} ==="
+              $stderr.puts "#{$!.class}: #{$!.message}"
+              $!.backtrace.each { |at| $stderr.puts at }
+              $stderr.puts "=== Daemon Crashed ==="
+              
+              $stderr.flush
+            end
+          end
+
+					trap("INT") do
+						daemon.shutdown
+						main.exit
+					end
+
+          trap("TERM") do
+            exit!
+          end
+
+          main.join
+        end
+
+        puts "Waiting for daemon to start..."
+        sleep 0.1
+        timer = TIMEOUT
+        pid = PidFile.recall(daemon)
+        
+        while pid == nil and timer > 0
+          # Wait a moment for the forking to finish...
+          puts "Waiting for daemon to start (#{timer}/#{TIMEOUT})"
+          sleep 1
+          
+          # If the daemon has crashed, it is never going to start...
+          break if daemon.crashed?
+          
+          pid = PidFile.recall(daemon)
+          
+          timer -= 1
+        end
+      end
+
+      # Prints out the status of the daemon
+      def self.status(daemon)
+        case PidFile.status(daemon)
+        when :running
+          puts "Daemon status: running pid=#{PidFile.recall(daemon)}"
+        when :unknown
+          if daemon.crashed?
+            puts "Daemon status: crashed"
+            
+            $stdout.flush
+            daemon.tail_err_log($stderr)
+          else
+            puts "Daemon status: unknown"
+          end
+        when :stopped
+          puts "Daemon status: stopped"
+        end
+      end
+
+      # Stops the daemon process.
+      def self.stop(daemon)
+        puts "Stopping daemon..."
+        
+        # Check if the pid file exists...
+        if !File.file?(daemon.pid_fn)
+          puts "Pid file not found. Is the daemon running?"
+          return
+        end
+
+        pid = PidFile.recall(daemon)
+
+        # Check if the daemon is already stopped...
+        unless PidFile.running(daemon)
+          puts "Pid #{pid} is not running. Has daemon crashed?"
+          return
+        end
+
+        pid = PidFile.recall(daemon)
+        Process.kill("INT", pid)
+        sleep 0.1
+        
+        # Kill/Term loop - if the daemon didn't die easily, shoot
+        # it a few more times.
+        attempts = 5
+        while PidFile.running(daemon) and attempts > 0
+          sig = (attempts < 2) ? "KILL" : "TERM"
+          
+          puts "Sending #{sig} to pid #{pid}..."
+          Process.kill(sig, pid)
+          
+          sleep 1 unless first
+          attempts -= 1
+        end
+        
+        # If after doing our best the daemon is still running (pretty odd)...
+        if PidFile.running(daemon)
+          puts "Daemon appears to be still running!"
+          return
+        end
+        
+        # Otherwise the daemon has been stopped.
+        PidFile.clear(daemon)
+      end
+    end
+  end
+end

data/lib/rexec/daemon/pidfile.rb

@@ -0,0 +1,64 @@
+# Copyright (c) 2007, 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module RExec
+  module Daemon
+    # This module controls the storage and retrieval of process id files.
+    module PidFile
+      # Saves the pid for the given daemon
+      def self.store(daemon, pid)
+        File.open(daemon.pid_fn, 'w') {|f| f << pid}
+      end
+
+      # Retrieves the pid for the given daemon
+      def self.recall(daemon)
+        IO.read(daemon.pid_fn).to_i rescue nil
+      end
+
+      # Removes the pid saved for a particular daemon
+      def self.clear(daemon)
+        if File.exist? daemon.pid_fn
+          FileUtils.rm(daemon.pid_fn)
+        end
+      end
+
+      # Checks whether the daemon is running by checking the saved pid and checking the corresponding process
+      def self.running(daemon)
+        pid = recall(daemon)
+
+        return false if pid == nil
+
+        gpid = Process.getpgid(pid) rescue nil
+
+        return gpid != nil ? true : false
+      end
+
+      # Remove the pid file if the daemon is not running
+      def self.cleanup(daemon)
+        clear(daemon) unless running(daemon)
+      end
+      
+      # This function returns the status of the daemon. This can be one of <tt>:running</tt>, <tt>:unknown</tt> (pid file exists but no 
+      # corresponding process can be found) or <tt>:stopped</tt>.
+      def self.status(daemon)
+        if File.exist? daemon.pid_fn
+          return PidFile.running(daemon) ? :running : :unknown
+        else
+          return :stopped
+        end
+      end
+    end
+  end
+end

data/lib/rexec/priviledges.rb

@@ -0,0 +1,28 @@
+
+require 'etc'
+
+module RExec
+  
+  # Set the user of the current process. Supply either a user ID
+  # or a user name.
+  #
+  # Be aware that on Mac OS X / Ruby 1.8 there are bugs when the user id
+  # is negative (i.e. it doesn't work). For example "nobody" with uid -2
+  # won't work.
+  def self.change_user(user)
+    if user.kind_of?(String)
+      user = Etc.getpwnam(user).uid
+    end
+
+    Process::Sys.setuid(user)
+  end
+  
+  
+  # Get the user of the current process. Returns the user name.
+  def self.current_user
+    uid = Process::Sys.getuid
+    
+    Etc.getpwuid(uid).name
+  end
+  
+end

data/lib/rexec/reverse_io.rb

@@ -0,0 +1,70 @@
+
+class File
+  # Seek to the end of the file
+  def seek_end
+    seek(0, IO::SEEK_END)
+  end
+  
+  # Read a chunk of data and then move the file pointer backwards.
+  #
+  # Calling this function multiple times will return new data and traverse the file backwards.
+  #
+  def read_reverse(length)
+    offset = tell
+    
+    if offset == 0
+      return nil
+    end
+    
+    start = [0, offset-length].max
+    
+    seek(start, IO::SEEK_SET)
+    
+    buf = read(offset-start)
+    
+    seek(start, IO::SEEK_SET)
+    
+    return buf
+  end
+  
+  REVERSE_BUFFER_SIZE = 128
+
+  # This function is very similar to gets but it works in reverse.
+  #
+  # You can use it to efficiently read a file line by line backwards.
+  # 
+  # It returns nil when there are no more lines.
+  def reverse_gets(sep_string=$/)
+    end_pos = tell
+    
+    offset = nil
+    buf = ""
+    
+    while offset == nil
+      chunk = read_reverse(REVERSE_BUFFER_SIZE)
+      return (buf == "" ? nil : buf) if chunk == nil
+      
+      buf = chunk + buf
+      
+      offset = buf.rindex(sep_string)
+    end
+    
+    line = buf[offset...buf.size].sub(sep_string, "")
+    
+    seek((end_pos - buf.size) + offset, IO::SEEK_SET)
+    
+    return line
+  end
+  
+  # Similar to each_line but works in reverse. Don't forget to call
+  # seek_end before you start!
+  def reverse_each_line(sep_string=$/, &block)
+    line = reverse_gets(sep_string)
+    
+    while line != nil
+      yield line
+      
+      line = reverse_gets(sep_string)
+    end
+  end
+end

data/lib/rexec/server.rb

@@ -0,0 +1,62 @@
+# Copyright (c) 2007 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'pathname'
+require 'rexec/task'
+require 'rexec/connection'
+
+module RExec
+  
+  class InvalidConnectionError < Exception
+  end
+  
+  @@connection_code = (Pathname.new(__FILE__).dirname + "connection.rb").read
+  @@client_code = (Pathname.new(__FILE__).dirname + "client.rb").read
+  
+  # Start a remote ruby server. This function is a structural cornerstone. This code runs the command you 
+  # supply (this command should start an instance of ruby somewhere), sends it the code in
+  # <tt>connection.rb</tt> and <tt>client.rb</tt> as well as the code you supply.
+  #
+  # Once the remote ruby instance is set up and ready to go, this code will return (or yield) the connection
+  # and pid of the executed command.
+  #
+  # From this point, you can send and receive objects, and interact with the code you provided within a
+  # remote ruby instance.
+  #
+  # If <tt>command</tt> is a shell such as "/bin/sh", and we need to start ruby separately, you can supply
+  # <tt>options[:ruby] = "/usr/bin/ruby"</tt> to explicitly start the ruby command.
+  def self.start_server(code, command, options = {}, &block)
+    options[:passthrough] = :err unless options[:passthrough]
+    
+    send_code = Proc.new do |cin|
+      cin.puts(@@connection_code)
+      cin.puts(@@client_code)
+      cin.puts(code)
+    end
+    
+    if block_given?
+      Task.open(command, options) do |process|
+        conn = Connection.build(process, options, &send_code)
+        
+        yield conn, process.pid
+      end
+    else
+      process = Task.open(command, options)
+      conn = Connection.build(process, options, &send_code)
+      
+      return conn, process.pid
+    end
+  end
+end

data/lib/rexec/task.rb

@@ -0,0 +1,325 @@
+# Copyright (c) 2007 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class String
+  # Helper for turning a string into a shell argument
+  def to_arg
+    match(/\s/) ? dump : self
+  end
+  
+  def to_cmd
+    return self
+  end
+end
+
+class Array
+  # Helper for turning an array of items into a command line string
+  # <tt>["ls", "-la", "/My Path"].to_cmd => "ls -la \"/My Path\""</tt>
+  def to_cmd
+    collect{ |a| a.to_arg }.join(" ")
+  end
+end
+
+class Pathname
+  # Helper for turning a pathname into a command line string
+  def to_cmd
+    to_s
+  end
+end
+
+module RExec
+  RD = 0
+  WR = 1
+
+  # This function closes all IO other than $stdin, $stdout, $stderr
+  def self.close_io(except = [$stdin, $stdout, $stderr])
+    # Make sure all file descriptors are closed
+    ObjectSpace.each_object(IO) do |io|
+      unless except.include?(io)
+        io.close rescue nil
+      end
+    end
+  end
+
+  class Task
+    private
+    def self.pipes_for_options(options)
+      pipes = [[nil, nil], [nil, nil], [nil, nil]]
+
+      if options[:passthrough]
+        passthrough = options[:passthrough]
+        
+        if passthrough == :all
+          passthrough = [:in, :out, :err]
+        elsif passthrough.kind_of?(Symbol)
+          passthrough = [passthrough]
+        end
+        
+        passthrough.each do |name|
+          case(name)
+          when :in
+            options[:in] = $stdin
+          when :out
+            options[:out] = $stdout
+          when :err
+            options[:err] = $stderr
+          end
+        end
+      end
+      
+      modes = [RD, WR, WR]
+      {:in => 0, :out => 1, :err => 2}.each do |name, idx|
+        m = modes[idx]
+        p = options[name]
+        
+        if p.kind_of?(IO)
+          pipes[idx][m] = p
+        elsif p.kind_of?(Array) and p.size == 2
+          pipes[idx] = p
+        else
+          pipes[idx] = IO.pipe
+        end
+      end
+
+      return pipes
+    end
+    
+    # Close all the supplied pipes
+    def close_pipes(*pipes)
+      pipes.compact!
+
+      pipes.each do |pipe|
+        pipe.close unless pipe.closed?
+      end
+    end
+
+    # Dump any remaining data from the pipes, until they are closed.
+    def dump_pipes(*pipes)
+      pipes.compact!
+
+      pipes.delete_if { |pipe| pipe.closed? }
+      # Dump any output that was not consumed (errors, etc)
+      while pipes.size > 0
+        result = IO.select(pipes)
+
+        result[0].each do |pipe|
+          if pipe.closed? || pipe.eof?
+            pipes.delete(pipe)
+            next
+          end
+
+          $stderr.puts pipe.readline.chomp
+        end
+      end
+    end
+    
+    public
+    # Returns true if the given pid is a current process
+    def self.running?(pid)
+      gpid = Process.getpgid(pid) rescue nil
+
+      return gpid != nil ? true : false
+    end
+    
+    # Very simple method to spawn a child daemon. A daemon is detatched from the controlling tty, and thus is
+    # not killed when the parent process finishes.
+    # <tt>
+    # spawn_daemon do
+    #   Dir.chdir("/")
+    #   File.umask 0000
+    #   puts "Hello from daemon!"
+    #   sleep(600)
+    #   puts "This code will not quit when parent process finishes..."
+    #   puts "...but $stdout might be closed unless you set it to a file."
+    # end
+    # </tt>
+    def self.spawn_daemon(&block)
+      pid_pipe = IO.pipe
+
+      fork do
+        Process.setsid
+        exit if fork
+
+        # Send the pid back to the parent
+        pid_pipe[RD].close
+        pid_pipe[WR].write(Process.pid.to_s)
+        pid_pipe[WR].close
+
+        yield
+
+        exit(0)
+      end
+
+      pid_pipe[WR].close
+      pid = pid_pipe[RD].read
+      pid_pipe[RD].close
+
+      return pid.to_i
+    end
+    
+    # Very simple method to spawn a child process
+    # <tt>
+    # spawn_child do 
+    #   puts "Hello from child!"
+    # end
+    # </tt>
+    def self.spawn_child(&block)
+      pid = fork do
+        yield
+
+        exit!(0)
+      end
+
+      return pid
+    end
+    
+    # Open a process. Similar to IO.popen, but provides a much more generic interface to stdin, stdout, 
+    # stderr and the pid. We also attempt to tidy up as much as possible given some kind of error or
+    # exception. You are expected to write to output, and read from input and error.
+    #
+    # = Options =
+    #
+    # We can specify a pipe that will be redirected to the current processes pipe. A typical one is
+    # :err, so that errors in the child process are printed directly to $stderr of the parent process.
+    # <tt>:passthrough => :err</tt>
+    # <tt>:passthrough => [:in, :out, :err]</tt> or <tt>:passthrough => :all</tt>
+    #
+    # We can specify a set of pipes other than the standard ones for redirecting to other things, eg
+    # <tt>:out => File.open("output.log", "a")</tt>
+    #
+    # If you need to supply a pipe manually, you can do that too:
+    # <tt>:in => IO.pipe</tt>
+    #
+    # You can specify <tt>:daemon => true</tt> to cause the child process to detatch. In this
+    # case you will generally want to specify files for <tt>:in, :out, :err</tt> e.g.
+    # <tt>
+    #   :in => File.open("/dev/null"),
+    #   :out => File.open("/var/log/my.log", "a"),
+    #   :err => File.open("/var/log/my.err", "a")
+    # </tt>
+    def self.open(command, options = {}, &block)
+      cin, cout, cerr = pipes_for_options(options)
+      stdpipes = [STDIN, STDOUT, STDERR]
+
+      spawn = options[:daemonize] ? :spawn_daemon : :spawn_child
+
+      cid = self.send(spawn) do
+        [cin[WR], cout[RD], cerr[RD]].compact.each { |pipe| pipe.close }
+        
+        STDIN.reopen(cin[RD]) if cin[RD] and !stdpipes.include?(cin[RD])
+        STDOUT.reopen(cout[WR]) if cout[WR] and !stdpipes.include?(cout[WR])
+        STDERR.reopen(cerr[WR]) if cerr[WR] and !stdpipes.include?(cerr[WR])
+        
+        if command.respond_to? :call
+          command.call
+        else
+          # If command is a Pathname, we need to convert it to an absolute path if possible,
+          # otherwise if it is relative it might cause problems.
+          if command.respond_to? :realpath
+            command = command.realpath
+          end
+          
+          if command.respond_to? :to_cmd
+            exec(command.to_cmd)
+          else
+            exec(command.to_s)
+          end
+        end
+      end
+      
+      # Don't close stdin, stdout, stderr.
+      [cin[RD], cout[WR], cerr[WR]].compact.each { |pipe| pipe.close unless stdpipes.include?(pipe) }
+
+      task = Task.new(cin[WR], cout[RD], cerr[RD], cid)
+
+      if block_given?
+        begin
+          yield task
+          task.close_input
+          return task.wait
+        ensure
+          task.stop
+        end
+      else
+        return task
+      end
+    end
+    
+    def initialize(input, output, error, pid)
+      @input = input
+      @output = output
+      @error = error
+      
+      @pid = pid
+      @result = nil
+    end
+    
+    attr :input
+    attr :output
+    attr :error
+    attr :pid
+    attr :result
+    
+    def running?
+      return self.class.running?(@pid)
+    end
+    
+    # Close all connections to the child process
+    def close
+      close_pipes(@input, @output, @error)
+    end
+    
+    # Close input pipe to child process (if applicable)
+    def close_input
+      @input.close if @input and !@input.closed?
+    end
+    
+    # Send a signal to the child process
+    def kill(signal = "INT")
+      Process.kill("INT", @pid)
+    end
+    
+    # Wait for the child process to finish, return the exit status.
+    def wait
+      begin
+        close_input
+        
+        _pid, @result = Process.wait2(@pid)
+        
+        dump_pipes(@output, @error)
+      ensure
+        close_pipes(@input, @output, @error)
+      end
+      
+      return @result
+    end
+    
+    # Forcefully stop the child process.
+    def stop
+      # The process has already been stoped/waited upon
+      return if @result
+      
+      begin
+        close_input
+        kill
+        wait
+        
+        dump_pipes(@output, @error)
+      ensure
+        close_pipes(@output, @error)
+      end
+    end
+  end
+end