jobby 0.1.1

data/README

@@ -0,0 +1,77 @@
+== Jobby
+
+Jobby is a small utility and library for managing running jobs in concurrent
+processes. It was initially developed for offloading long running tasks from
+the webserver in Rails applications, but it has proven to be useful in its own
+right and has been extracted to work in a general manner.
+
+
+== Download
+
+* gem install jobby
+* http://github.com/Spakman/jobby/tree/master
+* git clone git://github.com/Spakman/jobby.git
+
+
+== Contact
+
+* Mark Somerville <mailto:mark@scottishclimbs.com>
+* {Rubyforge}[http://jobby.rubyforge.org/]
+
+
+== Usage
+
+Jobby is a single 'binary' script that, can be run from the command line and is
+often used within scripts. You can, of course, also use the Jobby::Server and
+Jobby::Client classes directly in Ruby programs if you like.
+
+This bash script attempts to illustrate some simple, if somewhat contrived,
+usage of processing a directory full of text files (yes, there are better tools
+for this particular example): 
+
+  #!/bin/bash
+  for i in *; do
+    jobby --ruby 'File.rename("#{input}", "#{input}.jobby"' --max-children 4 --input $i
+  done
+
+The above script runs the specified Ruby code on up to four processes in
+parallel. In this case, each file in the current directory will be renamed with
+'.jobby' appended. Standard Ruby string interpolation is used to replace
+'#{input}' with whatever is specified by --input. You may pass a filepath in
+place of a string as the --ruby parameter - in this case the specified file is
+simply loaded (using the Kernel module method 'load') by Ruby.
+
+The above 'jobby' command is equivalent to:
+
+  jobby --command 'mv #{input} #{input}.jobby' --max-children 4 --input $i
+
+The difference is that whatever is in the --command parameter is exec'd by the
+child process rather than interpretted as Ruby code. Again, Ruby string 
+interpolation is used.
+
+It is important to realise that although the --ruby 'File....' parameter is
+passed every time jobby is called in this for loop, it is only actually read
+and used the first time. I'll try to explain why below.
+
+
+== What happens when you run Jobby?
+
+Jobby can be thought of as a self-managing daemon and client program rolled
+into one. The first time you run Jobby, a daemon is started which listens for
+connections on a socket. The daemon will fork every time it receives a
+connection (up to --max-children, further requests are queued) and the forked
+child will run whatever is specified by --ruby or --command.  
+
+The *same* 'jobby' call also runs a client program to connect to the daemon,
+passing --input as a parameter which will be used by the child process.
+Subsequent calls to 'jobby' will use the existing daemon.  
+
+
+== Running multiple Jobby daemons
+
+Since the --ruby and --command parameters are ignored (and the ones used for
+the first 'jobby' call are used), you may wonder how to specify different types
+of jobs to be run. The most straightforward way to do this is to specify a
+different socket for the Jobby daemon, using the --socket option. Then, the 
+'jobby' command will run whatever --ruby or --command is specified for the 
+daemon running on that socket.

data/bin/jobby

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# Copyright (C) 2008  Mark Somerville
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'logger'
+require 'optparse'
+require 'etc'
+require "#{File.dirname(__FILE__)}/../lib/server"
+require "#{File.dirname(__FILE__)}/../lib/client"
+require "#{File.dirname(__FILE__)}/../lib/runner"
+
+$0 = "jobby" # set the process name
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: jobby [options]"
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |verbose|
+    options[:verbose] = verbose
+  end
+
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on("--version", "Show version") do
+    puts "0.1.1"
+    exit
+  end
+
+  opts.on("-s", "--socket [SOCKETFILE]", "Connect to this UNIX socket") do |socket|
+    options[:socket] = socket
+  end
+
+  opts.on("-i", "--input [INPUT]", "Pass this string to the child process (can be used instead of STDIN)") do |input|
+    options[:input] = input
+  end
+
+  opts.on("-f", "--flush", "Shutdown the server on the specified socket") do |flush|
+    options[:flush] = flush
+  end
+
+  opts.on("-w", "--wipe", "Shutdown the server and terminate the children on the specified socket immediately") do |wipe|
+    options[:wipe] = wipe
+  end
+
+  opts.separator ""
+  opts.separator "Server options:"
+
+  opts.on("-l", "--log [LOGFILE]", "Log to this file") do |logfile|
+    options[:log] = logfile
+  end
+
+  opts.on("-m", "--max-children [MAXCHILDREN]", "Run MAXCHILDREN forked processes at any one time") do |forked_children|
+    options[:max_child_processes] = forked_children.to_i
+  end
+
+  opts.on("-u", "--user [USER]", "Run the processes as this user (probably requires superuser priviledges)") do |user|
+    options[:user] = user
+  end
+
+  opts.on("-g", "--group [GROUP]", "Run the processes as this group (probably requires superuser priviledges)") do |group|
+    options[:group] = group
+  end
+
+  opts.on("-r", "--ruby [RUBY]", "Run this Ruby code in the forked children") do |ruby|
+    options[:ruby] = ruby
+  end
+
+  opts.on("-c", "--command [COMMAND]", "Run this shell code in the forked children") do |command|
+    options[:command] = command
+  end
+end.parse!
+
+Jobby::Runner.new(options).run

data/lib/client.rb

@@ -0,0 +1,38 @@
+# Copyright (C) 2008  Mark Somerville
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'socket'
+
+module Jobby
+  class Client
+    # Creates a new client. Passing a block here is a shortcut for calling send and then close.
+    def initialize(socket_path, &block)
+      @socket = UNIXSocket.open(socket_path)
+      if block_given?
+        yield(self)
+        close
+      end
+    end
+    
+    def send(message = "")
+      @socket.send(message, 0)
+    end
+
+    def close
+      @socket.close
+    end
+  end
+end

data/lib/runner.rb

@@ -0,0 +1,153 @@
+# Copyright (C) 2008  Mark Somerville
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Jobby
+  class Runner
+    DEFAULT_OPTIONS = {}
+    DEFAULT_OPTIONS[:socket] = "/tmp/jobby.socket"
+    DEFAULT_OPTIONS[:log] = $stderr
+    DEFAULT_OPTIONS[:max_child_processes] = 1
+    DEFAULT_OPTIONS[:exit_on_error] = true
+
+    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?
+        message "--input not supplied, reading from STDIN (use ctrl-d to end input)"
+        @options[:input] = $stdin.read
+      end
+    end
+
+    # Tries to connect a client to the server. If there isn't a server detected on
+    # the socket this process is forked and a server is started. Then, another 
+    # client tries to connect to the server.
+    #
+    # We may consider using fork and exec instead of just fork since COW [1] 
+    # semantics are broken using Ruby 1.8.x. There is a patch, for those who can
+    # use it [2].
+    #
+    # [1] - http://blog.beaver.net/2005/03/ruby_gc_and_copyonwrite.html
+    #
+    # [2] - http://izumi.plan99.net/blog/index.php/2008/01/14/making-ruby’s-garbage-collector-copy-on-write-friendly-part-7/
+    #
+    # TODO: this code is pretty ugly.
+    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]).run(&get_proc_from_options)
+          rescue Exception => exception
+            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")
+        end
+      end
+    end
+
+    protected
+
+    # Creates a client and gets it to try to send a message to the Server on 
+    # @options[:socket]. If this doesn't succeed, either a Errno::EACCES, 
+    # Errno::ENOENT or Errno::ECONNREFUSED will probably be raised.
+    def run_client
+      message "Trying to connect to server on #{@options[:socket]}..." if @options[:verbose]
+      Jobby::Client.new(@options[:socket]) { |client| client.send(@options[:input]) }
+      message "Client has run successfully!" if @options[:verbose]
+    end
+
+    # Creates a Proc object that will be run by any children that the Server forks.
+    # The input parameter that is passed to the Proc is the input string that a
+    # Client will send to the server.
+    def get_proc_from_options
+      if @options[:ruby].nil? and @options[:command].nil?
+        return error("No server found on #{@options[:socket]} and you didn't give --ruby or --command to execute")
+
+      elsif not @options[:ruby].nil? and not @options[:command].nil?
+        return error("You can only specify --ruby or --command, not both")
+
+      elsif @options[:ruby] # can be either some Ruby code or a filepath
+        if File.file?(File.expand_path(@options[:ruby]))
+          return lambda { |input, logger|
+            ARGV << input
+            # read and eval this rather than Kernel.load so that the code in the
+            # file can use the local variables in this block
+            instance_eval(File.read(File.expand_path(@options[:ruby])))
+          }
+        else
+          return lambda { |input, logger|
+            instance_eval(@options[:ruby])
+          }
+        end
+
+      elsif @options[:command]
+        return lambda { |input, logger|
+          exec(eval("\"#{@options[:command].gsub('"', '\"')}\""))
+        }
+      end
+    end
+
+    # Changes the user and group ownership of the current process if 
+    # @options[:user] or @options[:group] are set. This might be a privileged 
+    # operation.
+    def change_process_ownership
+      begin
+        if @options[:group]
+          message "Setting group ownership to #{@options[:group]}..." if @options[:verbose]
+          Process::GID.change_privilege Etc.getgrnam(@options[:group]).gid
+        end
+        if @options[:user]
+          message "Setting user ownership to #{@options[:user]}..." if @options[:verbose]
+          Process::UID.change_privilege Etc.getpwnam(@options[:user]).uid
+        end
+      rescue Errno::EPERM
+        return error("You don't have permission to change the process ownership - perhaps you should be root?")
+      end
+    end
+
+    def error(text)
+      puts "  ERROR - #{text}"
+      exit -1 if @options[:exit_on_error]
+      return false
+    end
+
+    def message(text)
+      puts "  #{text}"
+    end
+  end
+end

data/lib/server.rb

@@ -0,0 +1,192 @@
+# Copyright (C) 2008  Mark Somerville
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'fileutils'
+require 'socket'
+require 'logger'
+require 'thread'
+
+module Jobby
+  # This is a generic server class which accepts connections on a UNIX socket. On
+  # receiving a connection, the server process forks and runs the specified block.
+  #
+  # ==Example
+  #
+  #   Jobby::Server.new("/tmp/jobby.socket", 3, "/var/log/jobby.log").run do
+  #     # This code will be run in the forked children
+  #     puts "#{Process.pid}: I'm toilet trained!"
+  #   end
+  #
+  # ==Stopping the server
+  #
+  # A client process can send one of two special strings to stop the server. 
+  #
+  #   "||JOBBY FLUSH||"   will stop the server forking any more children and shut
+  #                       it down.
+  #
+  #   "||JOBBY WIPE||"    will stop the server forking any more children, kill 9 
+  #                       any existing children and shut it down.
+  #
+  # ==Log rotation
+  #
+  # The server can receive USR1 signals 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.
+  #
+  # To tell all Jobby processes that the log file has been rotated, use something 
+  # like:
+  # 
+  #   % pkill -USR1 -f jobby
+  #
+  class Server
+    def initialize(socket_path, max_forked_processes, log)
+      @socket_path = socket_path
+      @max_forked_processes = max_forked_processes.to_i
+      @log = log
+      @queue = Queue.new
+    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
+      unless block_given?
+        @logger.error "No block given, exiting"
+        terminate
+      end
+      start_forking_thread(block)
+      loop do
+        client = @socket.accept
+        input = ""
+        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
+      end
+    end
+
+    protected
+
+    # 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.
+    #
+    # The input variable that is passed to the block is the message that is 
+    # received from Client#send.
+    def start_forking_thread(block)
+      Thread.new do
+        @pids = []
+        loop do
+          if @pids.length >= @max_forked_processes
+            begin
+              reap_child
+            rescue Errno::ECHILD
+            end
+          end
+          # fork and run code that performs the actual work
+          input = @queue.pop
+          @pids << fork do
+            $0 = "jobby: child" # set the process name
+            @logger.info "Child process started (#{Process.pid})"
+            block.call(input, @logger)
+            exit 0
+          end
+          Thread.new do
+            reap_child
+          end
+        end
+      end
+    end
+    
+    # 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
+      unless File.exists? @socket_path
+        connect_to_socket
+      else
+        begin
+          # test for a server on the socket
+          test_socket = UNIXSocket.open(@socket_path)
+          test_socket.close # got this far - seems like there is a server already
+          raise Errno::EADDRINUSE.new("it seems like there is already a server listening on #{@socket_path}")
+        rescue Errno::ECONNREFUSED
+          # probably not a server on that socket - start one
+          FileUtils.rm(@socket_path, :force => true)
+          connect_to_socket
+        end
+      end
+      start_logging
+    end
+
+    def connect_to_socket
+      @socket = UNIXServer.open(@socket_path)
+      FileUtils.chmod 0770, @socket_path
+      @socket.listen 10
+    end
+
+    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
+      @pids.delete Process.wait
+    end
+
+    def rotate_log
+      @logger.close
+      @logger = Logger.new @log
+      @logger.info "USR1 received, rotating log file"
+    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
+      FileUtils.rm(@socket_path, :force => true)
+      exit! 0
+    end
+    
+    # Stops any more children being forked and terminates the existing ones. A kill
+    # 9 signal is used as you will likely be run when termination is needed 
+    # immediately, perhaps due to 'runaway' children.
+    def terminate_children
+      @queue.clear
+      @logger.info "Wipe received - terminating forked children"
+      @pids.each do |pid|
+        begin
+          Process.kill 9, pid
+        rescue Errno::ESRCH
+        end
+      end
+    end
+  end
+end

data/spec/run_all.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'spec'
+
+Dir.glob("#{File.dirname(__FILE__)}/*_spec.rb") do |spec|
+  require spec
+end

data/spec/server_spec.rb

@@ -0,0 +1,179 @@
+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.
+
+describe Jobby::Server do
+
+  def run_server(socket, max_child_processes, log_filepath, &block)
+    @server_pid = fork do
+      Jobby::Server.new(socket, max_child_processes, log_filepath).run(&block)
+    end
+    sleep 0.2
+  end
+
+  def terminate_server
+    Process.kill 15, @server_pid
+    if File.exists? @child_filepath
+      FileUtils.rm @child_filepath
+    end
+    FileUtils.rm @log_filepath, :force => true
+    sleep 0.5
+  end
+
+  before :all do
+    @socket = File.expand_path("#{File.dirname(__FILE__)}/jobby_server.sock")
+    @max_child_processes = 2
+    @log_filepath = File.expand_path("#{File.dirname(__FILE__)}/jobby_server.log")
+    @child_filepath = File.expand_path("#{File.dirname(__FILE__)}/jobby_child")
+  end
+
+  before :each do
+    run_server(@socket, @max_child_processes, @log_filepath) {
+      File.open(@child_filepath, "a+") do |file|
+        file << "#{Process.pid}"
+      end
+    }
+  end
+
+  after :each do
+    terminate_server
+  end
+
+  after :all do
+    FileUtils.rm @socket, :force => true
+  end
+
+  it "should listen on a UNIX socket" do
+    lambda { UNIXSocket.open(@socket).close }.should_not raise_error
+  end
+
+  it "should allow the children to log from within the called block" do
+    terminate_server
+    sleep 0.5
+    run_server(@socket, @max_child_processes, @log_filepath) { |input, logger|
+      logger.info "I can log!"
+    }
+    sleep 1
+    client_socket = UNIXSocket.open(@socket)
+    client_socket.send("hiya", 0)
+    client_socket.close
+    sleep 1
+    File.read(@log_filepath).should match(/I can log!/)
+  end
+
+  it "should throw an exception if there is already a process listening on the socket" do
+    lambda { Jobby::Server.new(@socket, @max_child_processes, @log_filepath).run { true } }.should raise_error(Errno::EADDRINUSE, "Address already in use - it seems like there is already a server listening on #{@socket}")
+  end
+
+  it "should set the correct permissions on the socket file" do
+    `stat --format=%a,%F #{@socket}`.strip.should eql("770,socket")
+  end
+
+  it "should log when it is started" do
+    File.read(@log_filepath).should match(/Server started at/)
+  end
+
+  it "should be able to accept an IO object instead of a log filepath" do
+    terminate_server
+    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+")
+    run_server(@socket, @max_child_processes, io) {}
+    terminate_server
+    sleep 0.5
+    File.readlines(io_filepath).length.should eql(1)
+    FileUtils.rm io_filepath
+  end
+
+  it "should flush and reload the log file when it receieves the USR1 signal" do
+    FileUtils.rm @log_filepath
+    Process.kill "USR1", @server_pid
+    sleep 0.2
+    File.read(@log_filepath).should match(/USR1 received, rotating log file/)
+  end
+
+  it "should not run if a block is not given" do
+    terminate_server
+    sleep 0.5
+    run_server(@socket, @max_child_processes, @log_filepath)
+    sleep 0.5
+    lambda { UNIXSocket.open(@socket).close }.should raise_error
+  end
+  
+  it "should read all of the provided message" do
+    terminate_server
+    sleep 0.5
+    run_server(@socket, @max_child_processes, @log_filepath) { |input, logger|
+      File.open(@child_filepath, "a+") do |file|
+        file << "#{input}"
+      end
+    } 
+    Jobby::Client.new(@socket) { |c| c.send("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890") }
+    sleep 0.5
+    File.read(@child_filepath).should eql("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890")
+  end
+
+  it "should fork off a child and run the specified code when it receives a connection" do
+    Jobby::Client.new(@socket) { |c| c.send("hiya") }
+    sleep 0.2
+    File.read(@child_filepath).should_not eql(@server_pid.to_s)
+  end
+
+  it "should only fork off a certain number of children - the others should have to wait (in an internal queue)" do
+    terminate_server
+    run_server(@socket, @max_child_processes, @log_filepath) do
+      sleep 2
+      File.open(@child_filepath, "a+") do |file|
+        file << "#{Process.pid}\n"
+      end
+    end
+    (@max_child_processes + 2).times do |i|
+      Thread.new do
+        Jobby::Client.new(@socket) { |c| c.send("hiya") }
+      end
+    end
+    sleep 2.5
+    File.readlines(@child_filepath).length.should eql(@max_child_processes)
+    sleep 4
+    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
+    terminate_server
+    sleep 1
+    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 FLUSH||") }
+    sleep 1.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}")
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: jobby
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Mark Somerville
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-17 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mark@scottishclimbs.com
+executables: 
+- jobby
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- bin/jobby
+- lib/runner.rb
+- lib/server.rb
+- lib/client.rb
+- spec/server_spec.rb
+- spec/run_all.rb
+- README
+has_rdoc: true
+homepage: http://mark.scottishclimbs.com/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: jobby
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Jobby is a small utility and library for managing running jobs in concurrent processes.
+test_files: []
+