rexec 1.1.12 → 1.2.1

data/lib/rexec/daemon/controller.rb

@@ -17,176 +17,193 @@ 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
+	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"
+					$stdout.sync = true
+					
+					$stderr.reopen daemon.err_fn, "a"
+					$stderr.sync = true
+
+					begin
+						error = nil
+						
+						main = Thread.new do
+							begin
+								daemon.run
+							rescue
+								error = $!
+							end
+						end
+
+						trap("INT") do
+							begin
+								daemon.shutdown
+								main.exit
+							rescue
+								error = $!
+							end
+						end
+
+						trap("TERM") do
+							exit!
+						end
+
+						main.join
+
+						raise error if error
+					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
+					ensure
+						$stderr.puts "=== Daemon Stopping @ #{Time.now.to_s} ==="
+						$stderr.flush
 					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
+				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
+					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/task.rb

@@ -13,313 +13,327 @@
 # 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
+require 'thread'
 
-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
+module RExec
+	RD = 0
+	WR = 1
 
-class Pathname
-  # Helper for turning a pathname into a command line string
-  def to_cmd
-    to_s
-  end
-end
+	# 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
 
-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
+	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
+		STDPIPES = [STDIN, STDOUT, STDERR]
+		def self.close_pipes(*pipes)
+			pipes = pipes.compact.reject{|pipe| STDPIPES.include?(pipe)}
+
+			pipes.each do |pipe|
+				pipe.close unless pipe.closed?
+			end
+		end
+
+		# Dump any remaining data from the pipes, until they are closed.
+		def self.dump_pipes(*pipes)
+			pipes = pipes.compact.reject{|pipe| STDPIPES.include?(pipe)}
+
+			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>:daemonize => 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)
+			spawn = options[:daemonize] ? :spawn_daemon : :spawn_child
+
+			cid = self.send(spawn) do
+				close_pipes(cin[WR], cout[RD], cerr[RD])
+
+				STDIN.reopen(cin[RD]) if cin[RD]
+				STDOUT.reopen(cout[WR]) if cout[WR]
+				STDERR.reopen(cerr[WR]) if cerr[WR]
+
+				if command.respond_to? :call
+					command.call
+				elsif Array === command
+					# 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[0].respond_to? :realpath
+						command[0] = command[0].realpath
+					end
+					
+					exec *command
+				else
+					if command.respond_to? :realpath
+						command = command.realpath
+					end
+					
+					exec command.to_s
+				end
+			end
+
+			close_pipes(cin[RD], cout[WR], cerr[WR])
+
+			task = Task.new(cin[WR], cout[RD], cerr[RD], cid)
+
+			if block_given?
+				begin
+					yield task
+					task.close_input
+					return task.wait
+				ensure
+					task.close
+				end
+			else
+				return task
+			end
+		end
+
+		def initialize(input, output, error, pid)
+			@input = input
+			@output = output
+			@error = error
+
+			@pid = pid
+
+			@result = nil
+			@status = :running
+			@result_lock = Mutex.new
+			@result_available = ConditionVariable.new
+		end
+
+		attr :input
+		attr :output
+		attr :error
+		attr :pid
+		attr :result
+
+		# Returns true if the current task is still running
+		def running?
+			if self.class.running?(@pid)
+				# The pid still seems alive, check that it isn't some other process using the same pid...
+				@result_lock.synchronize do
+					# If we haven't waited for it yet, it must be either a running process or a zombie...
+					return @status != :stopped
+				end
+			end
+			
+			return false
+		end
+
+		# Close all connections to the child process
+		def close
+			begin
+				self.class.dump_pipes(@output, @error)
+			ensure
+				self.class.close_pipes(@input, @output, @error)
+			end
+		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")
+			if running?
+				Process.kill(signal, @pid)
+			else
+				raise Errno::ECHILD
+			end
+		end
+
+		# Wait for the child process to finish, return the exit status.
+		# This function can be called from multiple threads.
+		def wait
+			begin_wait = false
+			
+			# Check to see if some other caller is already waiting on the result...
+			@result_lock.synchronize do
+				case @status
+				when :waiting
+					# If so, wait for the wait to finish...
+					@result_available.wait(@result_lock)
+				when :running
+					# Else, mark that we should begin waiting...
+					begin_wait = true
+					@status = :waiting
+				when :stopped
+					return @result
+				end
+			end
+			
+			# If we should begin waiting (the first thread to wait)...
+			if begin_wait
+				begin
+					# Wait for the result...
+					_pid, @result = Process.wait2(@pid)
+				end
+				
+				# The result is now available...
+				@result_lock.synchronize do
+					@status = :stopped
+				end
+				
+				# Notify other threads...
+				@result_available.broadcast()
+			end
+			
+			# Return the result
+			return @result
+		end
+
+		# Forcefully stop the child process.
+		def stop
+			if running?
+				close_input
+				kill
+			end
+		end
+	end
 end

data/lib/rexec/version.rb

@@ -16,8 +16,8 @@
 module RExec
   module VERSION #:nodoc:
     MAJOR = 1
-    MINOR = 1
-    TINY  = 12
+    MINOR = 2
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/task_test.rb

@@ -128,7 +128,7 @@ class TaskTest < Test::Unit::TestCase
     
     assert rd.closed?
     
-    assert_raises(Errno::EPIPE) do
+    assert_raises(Errno::EINVAL) do
       wr.puts "The pipe is closed on the other side.."
     end
     

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
+  - 2
   - 1
-  - 12
-  version: 1.1.12
+  version: 1.2.1
 platform: ruby
 authors: 
 - Samuel Williams
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-08 00:00:00 +12:00
+date: 2011-07-10 00:00:00 +12:00
 default_executable: daemon-exec
 dependencies: []
 
@@ -79,7 +79,7 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.3.6
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: RExec (Remote Execution) is a tool to facilitate communicating to another ruby process and executing code.
 test_files: 
 - test/daemon_test.rb