jobby 0.2.0 → 0.3.1

data/bin/jobby

@@ -22,7 +22,7 @@ require "#{File.dirname(__FILE__)}/../lib/server"
 require "#{File.dirname(__FILE__)}/../lib/client"
 require "#{File.dirname(__FILE__)}/../lib/runner"
 
-$0 = "jobby" # set the process name
+$0 = "#{$0} #{ARGV.join(" ")}" # set the process name
 
 options = {}
 OptionParser.new do |opts|
@@ -38,7 +38,7 @@ OptionParser.new do |opts|
   end
 
   opts.on("--version", "Show version") do
-    puts "0.2.0"
+    puts "0.3.1"
     exit
   end
 
@@ -50,14 +50,6 @@ OptionParser.new do |opts|
     options[:input] = input
   end
 
-  opts.on("-f", "--flush", "Shutdown the server on the socket specified by --socket") do |flush|
-    options[:flush] = flush
-  end
-
-  opts.on("-w", "--wipe", "Shutdown the server and terminate the children immediately on the socket specified by --socket") do |wipe|
-    options[:wipe] = wipe
-  end
-
   opts.separator ""
   opts.separator "Server options:"
 

data/lib/runner.rb

@@ -24,11 +24,7 @@ module Jobby
 
     def initialize(options = {})
       @options = DEFAULT_OPTIONS.merge options
-      if @options[:wipe]
-        @options[:input] = "||JOBBY WIPE||"
-      elsif @options[:flush]
-        @options[:input] = "||JOBBY FLUSH||"
-      elsif @options[:input].nil?
+      if @options[:input].nil?
         message "--input not supplied, reading from STDIN (use ctrl-d to end input)"
         @options[:input] = $stdin.read
       end
@@ -58,20 +54,12 @@ module Jobby
     def run
       change_process_ownership
       begin
-        if @options[:flush] or @options[:wipe]
-          if @options[:wipe]
-            message "Stopping Jobby server and terminating forked children..."
-          else
-            message "Stopping Jobby server..."
-          end
-        end
         run_client
       rescue Errno::EACCES => exception
         return error(exception.message)
       rescue Errno::ENOENT, Errno::ECONNREFUSED
         # Connect failed, fork and start the server process
         message "There doesn't seem to be a server listening on #{@options[:socket]} - starting one..." if @options[:verbose]
-        exit if @options[:flush] or @options[:wipe]
         fork do
           begin
             Jobby::Server.new(@options[:socket], @options[:max_child_processes], @options[:log], @options[:prerun_proc]).run(&get_proc_from_options)
@@ -79,11 +67,19 @@ module Jobby
             return error(exception.message)
           end
         end
-        sleep 2 # give the server time to start
-        begin
-          run_client
-        rescue Errno::ECONNREFUSED
-          return error("Couldn't connect to the server process")
+        # give the server 30 seconds to start
+        @connected = false
+        60.times do
+          begin
+            run_client
+            @connected = true
+            break
+          rescue Errno::ECONNREFUSED, Errno::EACCES, Errno::ENOENT
+            sleep 0.5
+          end
+        end
+        unless @connected
+          error "Couldn't connect to the server process after 60 tries"
         end
       end
     end

data/lib/server.rb

@@ -32,47 +32,51 @@ module Jobby
   #
   # ==Stopping the server
   #
-  # A client process can send one of two special strings to stop the server. 
+  # There are two built-in ways of stopping the server:
   #
-  #   "||JOBBY FLUSH||"   will stop the server forking any more children and shut
-  #                       it down.
+  #   SIGUSR1    will stop the server accepting any more connections, but it 
+  #              will continue to fork if there are any requests in the queue. 
+  #              It will then wait for the children to exit before terminating.
   #
-  #   "||JOBBY WIPE||"    will stop the server forking any more children, kill 9 
-  #                       any existing children and shut it down.
+  #   SIGTERM    will stop the server forking any more children, kill 9 any 
+  #              existing children and terminate it.
   #
   # ==Log rotation
   #
-  # The server can receive USR1 signals as notification that the logfile has been 
+  # The server can receive SIGHUP as notification that the logfile has been 
   # rotated. This will close and re-open the handle to the log file. Since the
-  # server process forks to produce children, they too can handle USR1 signals on
-  # log rotation.
+  # server process forks to produce children, they too can handle SIGHUP on log 
+  # rotation.
   #
   # To tell all Jobby processes that the log file has been rotated, use something 
   # like:
   # 
-  #   % pkill -USR1 -f jobby
+  #   % pkill -HUP -f jobby
   #
   class Server
+    # The log parameter can be either a filepath or an IO object.
     def initialize(socket_path, max_forked_processes, log, prerun = nil)
+      $0 = "jobbyd: #{socket_path}" # set the process name
+      @log = log.path rescue log
+      reopen_standard_streams
+      close_fds
+      start_logging
       @socket_path = socket_path
       @max_forked_processes = max_forked_processes.to_i
-      @log = log
       @queue = Queue.new
-      @prerun = prerun
+      setup_signal_handling
+      prerun.call(@logger) unless prerun.nil?
     end
 
     # Starts the server and listens for connections. The specified block is run in 
     # the child processes. When a connection is received, the input parameter is 
     # immediately added to the queue.
     def run(&block)
-      connect_to_socket_and_start_logging
+      try_to_connect_to_socket
       unless block_given?
         @logger.error "No block given, exiting"
         terminate
       end
-      if @prerun
-        @prerun.call(@logger)
-      end
       start_forking_thread(block)
       loop do
         client = @socket.accept
@@ -80,20 +84,58 @@ module Jobby
         while bytes = client.read(128)
           input += bytes
         end
-        if input == "||JOBBY FLUSH||"
-          terminate
-        elsif input == "||JOBBY WIPE||"
-          terminate_children
-          terminate
-        else
-          @queue << input
-        end
         client.close
+        @queue << input
       end
     end
 
     protected
 
+    # Reopens STDIN (/dev/null), STDOUT and STDERR (both @log).
+    def reopen_standard_streams
+      $stdin.reopen("/dev/null", "r")
+      # @log is either a string or an IO object
+      if @log.respond_to? :close
+        $stdout.reopen(@log)
+        $stderr.reopen(@log)
+      else
+        $stdout.reopen(@log, "w")
+        $stderr.reopen(@log, "w")
+      end
+    end
+
+    # This closes all file descriptors for this process except STDIN, STDOUT 
+    # and STDERR. This is because we might have inherited some FDs from the 
+    # calling process, which we don't want.
+    def close_fds
+      Dir.entries("/proc/#{Process.pid}/fd/").each do |file|
+        unless file == '.' or file == '..' or file.to_i < 3
+          IO.new(file.to_i).close rescue nil
+        end
+      end
+    end
+
+    # Traps SIGHUP, SIGTERM and SIGUSR1 for log rotation, immediate shutdown 
+    # and very pleasant shutdown.
+    def setup_signal_handling
+      Signal.trap("HUP") do
+        @logger.info "HUP signal received"
+        rotate_log
+      end
+      Signal.trap("TERM") do
+        @logger.info "TERM signal received"
+        @socket.close unless @socket.closed?
+        @queue.clear
+        terminate_children
+        terminate
+      end
+      Signal.trap("USR1") do
+        @logger.info "USR1 signal received"
+        wait_for_children_to_return
+        terminate
+      end
+    end
+
     # Runs a thread to manage the forked processes. It will block, waiting for a 
     # child to finish if the maximum number of forked processes are already 
     # running. It will then, read from the queue and fork off a new process.
@@ -113,7 +155,14 @@ module Jobby
           # fork and run code that performs the actual work
           input = @queue.pop
           @pids << fork do
-            $0 = "jobby: child" # set the process name
+            @socket.close unless @socket.closed? # inherited from the Jobby::Server
+            # re-trap TERM to simply exit, since it is inherited from the Jobby::Server
+            Signal.trap("TERM") do
+              @logger.info "Terminating child process #{Process.pid}"
+              exit 0
+            end
+            Signal.trap("USR1") {}
+            $0 = "jobby: #{@socket_path}" # set the process name
             @logger.info "Child process started (#{Process.pid})"
             block.call(input, @logger)
             exit 0
@@ -128,7 +177,7 @@ module Jobby
     # Checks if a process is already listening on the socket. If not, removes the 
     # socket file (if it's there) and starts a server. Throws an Errno::EADDRINUSE
     # exception if an existing server is detected.
-    def connect_to_socket_and_start_logging
+    def try_to_connect_to_socket
       unless File.exists? @socket_path
         connect_to_socket
       else
@@ -143,7 +192,6 @@ module Jobby
           connect_to_socket
         end
       end
-      start_logging
     end
 
     def connect_to_socket
@@ -155,9 +203,6 @@ module Jobby
     def start_logging
       @logger = Logger.new @log
       @logger.info "Server started at #{Time.now}"
-      Signal.trap("USR1") do
-        rotate_log
-      end
     end
 
     def reap_child
@@ -165,16 +210,26 @@ module Jobby
     end
 
     def rotate_log
+      @logger.info "Rotating log file"
       @logger.close
       @logger = Logger.new @log
-      @logger.info "USR1 received, rotating log file"
+    end
+
+    # Closes the socket and waits for any children to finish before 
+    # terminating. New children that are already in the queue may be 
+    # still be forked at this stage.
+    def wait_for_children_to_return
+      @socket.close
+      while @pids.length > 0
+        sleep 1
+      end
     end
 
     # Cleans up the server and exits the process with a return code 0.
     def terminate
       @queue.clear
-      @logger.info "Flush received - terminating server"
-      @socket.close
+      @logger.info "Terminating server #{Process.pid}"
+      @socket.close unless @socket.closed?
       FileUtils.rm(@socket_path, :force => true)
       exit! 0
     end
@@ -184,10 +239,10 @@ module Jobby
     # immediately, perhaps due to 'runaway' children.
     def terminate_children
       @queue.clear
-      @logger.info "Wipe received - terminating forked children"
+      @logger.info "Terminating forked children"
       @pids.each do |pid|
         begin
-          Process.kill 9, pid
+          Process.kill 15, pid
         rescue Errno::ESRCH
         end
       end

data/spec/server_spec.rb

@@ -1,14 +1,17 @@
 require "#{File.dirname(__FILE__)}/../lib/server"
 require "#{File.dirname(__FILE__)}/../lib/client"
 require 'fileutils'
-$0 = "jobby spec"
-
 
 # Due to the multi-process nature of these specs, there are a bunch of sleep calls
 # around. This is, of course, pretty brittle but I can't think of a better way of 
 # handling it. If they start failing 'randomly', I would first start by increasing
 # the sleep times.
 
+class Jobby::Server
+  # Redefining STDIN, STDOUT and STDERR makes testing pretty savage
+  def reopen_standard_streams; end
+end
+
 describe Jobby::Server do
 
   def run_server(socket, max_child_processes, log_filepath, prerun = nil, &block)
@@ -35,6 +38,7 @@ describe Jobby::Server do
   end
 
   before :each do
+    $0 = "jobby spec"
     run_server(@socket, @max_child_processes, @log_filepath) {
       File.open(@child_filepath, "a+") do |file|
         file << "#{Process.pid}"
@@ -85,19 +89,19 @@ describe Jobby::Server do
     sleep 1
     io_filepath = File.expand_path("#{File.dirname(__FILE__)}/io_log_test.log")
     FileUtils.rm io_filepath, :force => true
-    io = File.open(io_filepath, "a+")
+    io = File.open(io_filepath, "w")
     run_server(@socket, @max_child_processes, io) {}
     terminate_server
     sleep 0.5
-    File.readlines(io_filepath).length.should eql(1)
+    File.readlines(io_filepath).length.should eql(4)
     FileUtils.rm io_filepath
   end
 
-  it "should flush and reload the log file when it receieves the USR1 signal" do
+  it "should flush and reload the log file when it receieves the HUP signal" do
     FileUtils.rm @log_filepath
-    Process.kill "USR1", @server_pid
+    Process.kill "HUP", @server_pid
     sleep 0.2
-    File.read(@log_filepath).should match(/USR1 received, rotating log file/)
+    File.read(@log_filepath).should match(/# Logfile created on/)
   end
 
   it "should not run if a block is not given" do
@@ -146,35 +150,23 @@ describe Jobby::Server do
     File.readlines(@child_filepath).length.should eql(@max_child_processes + 2)
   end
 
-  it "should receive a flush command from the client and terminate while the children continue processing" do
+  it "should receive a USR1 signal then stop accepting connections and terminate after reaping all child PIDs" do
     terminate_server
     sleep 1
     run_server(@socket, 1, @log_filepath) do
-      sleep 2
+      sleep 3
     end
     2.times do |i|
       Jobby::Client.new(@socket) { |c| c.send("hiya") }
     end
-    sleep 1
-    Jobby::Client.new(@socket) { |c| c.send("||JOBBY FLUSH||") }
+    sleep 0.5
+    Process.kill "USR1", @server_pid
     sleep 1.5
+    lambda { Jobby::Client.new(@socket) { |c| c.send("hello?") } }.should raise_error(Errno::ECONNREFUSED)
+    sleep 5
     lambda { Jobby::Client.new(@socket) { |c| c.send("hello?") } }.should raise_error(Errno::ENOENT)
     `pgrep -f 'jobby spec' | wc -l`.strip.should eql("2")
-  end
-
-  it "should receive a wipe command from the client and terminate, taking the children with it" do
-    terminate_server
-    run_server(@socket, 1, @log_filepath) do
-      sleep 2
-    end
-    2.times do |i|
-      Jobby::Client.new(@socket) { |c| c.send("hiya") }
-    end
-    sleep 1
-    Jobby::Client.new(@socket) { |c| c.send("||JOBBY WIPE||") }
-    sleep 2.5
-    lambda { Jobby::Client.new(@socket) { |c| c.send("hello?") } }.should raise_error(Errno::ENOENT)
-    `pgrep -f 'jobby spec'`.strip.should eql("#{Process.pid}")
+    `pgrep -f 'jobbyd spec' | wc -l`.strip.should eql("1")
   end
 
   it "should be able to run a Ruby file before any forking" do
@@ -191,4 +183,14 @@ describe Jobby::Server do
     sleep 3
     File.read(@child_filepath).should eql("preran OK")
   end
+  
+  it "close all file descriptors that might have been inherited from the calling process" do
+    terminate_server
+    f = File.open("spec/file_for_prerunning.rb", "r")
+    run_server(@socket, 1, @log_filepath) do
+      sleep 2
+    end
+    Dir.entries("/proc/#{@server_pid}/fd/").length.should eql(7)
+    f.close
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jobby
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Mark Somerville
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-09 00:00:00 +01:00
+date: 2008-11-13 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -23,12 +23,12 @@ extra_rdoc_files:
 - README
 files: 
 - bin/jobby
+- lib/client.rb
 - lib/runner.rb
 - lib/server.rb
-- lib/client.rb
+- spec/file_for_prerunning.rb
 - spec/server_spec.rb
 - spec/run_all.rb
-- spec/file_for_prerunning.rb
 - README
 has_rdoc: true
 homepage: http://mark.scottishclimbs.com/
@@ -52,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: jobby
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Jobby is a small utility and library for managing running jobs in concurrent processes.