bannister 0.0.2 → 0.0.3

data/Rakefile

@@ -3,8 +3,6 @@ CLEAN << ".yardoc"
 CLEAN << FileList["*.gem"]
 CLEAN << "doc"
 
-DOC_FILES=Dir['*.md']
-
 desc "Build the gem"
 task :gem do
   system "gem build bannister.gemspec"
@@ -12,12 +10,12 @@ end
 
 desc "Build the YARD docs"
 task :docs do
-  system "yardoc --files #{DOC_FILES.join(",")}"
+  system "yardoc"
 end
 
 task :doc => :docs
 
 desc "Build the YARD developer docs, including private methods"
 task :dev_docs do
-  system "yardoc --private --files #{DOC_FILES.join(",")}"
+  system "yardoc --private"
 end

data/bin/bannister

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'bannister'
+require 'bannister/version'
 include Bannister
 
 
@@ -16,6 +17,8 @@ when "stop"
 when "restart"
   stop()
   start()
+when "version", "--version", "-v"
+  $stdout.puts ::Bannister::VERSION.to_s
 else
   err "usage: #{$0} (run|start|stop|restart)"
 end

data/lib/bannister.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'bannister/utils'
 
 module Bannister
 
@@ -20,7 +21,7 @@ module Bannister
   # Daemonize and launch the managed processes.
   def start()
     if running?
-      err "This app is already running!  Run #{$0} stop first."
+      err "This app is already running!  Run #{$0} stop first (or remove #{PID_FILENAME} if you know better)."
     else
       daemonize(){ do_start() }
       wait_for_all()
@@ -67,7 +68,6 @@ module Bannister
   def quit
     kill_all()
     remove_pid()
-    exit(0)
   end
 
   
@@ -76,14 +76,12 @@ module Bannister
   def stop()
     old_pid = read_pid()
     if old_pid
-      begin
-        Process.kill("TERM", old_pid)
-        Process.waitpid(old_pid)
-      rescue SystemCallError 
-        # which gets thrown if the old process is already dead
-        nil
+      Process.kill("TERM", old_pid)
+      if ::Bannister::Utils.wait_foreign_pid(old_pid)
+        remove_pid()
+      else
+        err "Bannister (pid=#{old_pid}) failed to die!"
       end
-      remove_pid()
     end
   end
 

data/lib/bannister.rb.orig

@@ -0,0 +1,279 @@
+require 'fileutils'
+require 'bannister/utils'
+
+module Bannister
+
+
+  # List of scripts in script/startup sorted asciibetically. This is the order 
+  # they will be launched in, but there is no further dependency checking
+  # between the scripts.
+  SCRIPTS = Dir['script/startup/*'].sort
+
+  # A list of pids of the started scripts. These will be sent TERM signals when
+  # bannister is stopped.
+  LAUNCHED_PIDS = []
+
+  # The location of the pidfile for the master process. This will be 
+  # de-hard-coded in a future release.
+  PID_FILENAME = "pids/bannister.pid"
+
+
+  # Daemonize and launch the managed processes.
+  def start()
+    if running?
+      err "This app is already running!  Run #{$0} stop first (or remove #{PID_FILENAME} if you know better)."
+    else
+      daemonize(){ do_start() }
+      wait_for_all()
+    end
+  end
+
+
+  # Launch the managed processes in screen so that they are all foreground
+  # processes.
+  #
+  # If run from inside an existing screen session, it will be reused, and the
+  # managed processes will be added to it. Otherwise a new screen session is
+  # started.
+  #
+  # Starting a new screen session is done by writing a temporary screenrc 
+  # to /tmp, so $HOME/.screenrc is ignored.
+  def run()
+    screenrc_filename = "/tmp/screenrc.#{$$}"
+
+    if ENV['STY'] && !ENV['STY'].empty?
+      # then we already have a screen, so reuse it
+      # by simply running all the commands
+
+      SCRIPTS.each do |script|
+        system( command_for_script(script) )
+      end
+
+    else # create it. The easiest way to do this is to write 
+      # out a screenrc containing the relevant commands and
+      # let screen launch them
+      begin
+        write_screenrc(screenrc_filename)
+
+        system "screen","-c",screenrc_filename
+      ensure
+        FileUtils.rm_f screenrc_filename
+      end
+
+    end
+  end
+
+
+  # Shut down all the managed processes, remove the bannister pidfile and exit.
+  def quit
+    $stderr.reopen("/tmp/bannister.stop.err.log", "wb")
+    $stdout.reopen("/tmp/bannister.stop.out.log", "wb")
+    kill_all()
+    remove_pid()
+  end
+
+  
+
+  # Send a TERM signal to a #start'ed bannister process.
+  def stop()
+    old_pid = read_pid()
+    if old_pid
+      if ::Bannister::Utils.foreign_pid_alive?(old_pid)
+        Process.kill("TERM", old_pid)
+        if ::Bannister::Utils.wait_foreign_pid(old_pid)
+          remove_pid()
+        else
+          err "Bannister (pid=#{old_pid}) failed to die!"
+        end
+      else
+        err "Bannister (pid=#{old_pid}) wasn't alive."
+      end
+    end
+  end
+
+
+  # Used when you have erred. Shows the passed error message and exits
+  # with a status of 1.
+  #
+  # @param [String] msg Message to display.
+  def err(msg)
+    $stderr.puts(msg)
+    exit(1)
+  end
+
+
+
+  private
+  # Method to see whether a bannister process for the current application
+  # is running or not.
+  #
+  # @return [Boolean] true if PID_FILENAME exists, false otherwise.
+  def running?
+    return File.exists?(PID_FILENAME)
+  end
+
+
+  # Generate the screen command for the passed script filename. Since this
+  # will only ever be called when running in the foreground, we append -X
+  # to the command. A title for the screen window is also generated based
+  # on the current directory name and the script filename.
+  #
+  # @param [String] script the filename of a script to run.
+  # @return [String] the screen command to run the script.
+  def command_for_script(script)
+    title = File.basename(FileUtils.pwd)+':'+File.basename(script)
+    return "screen -t '#{title}' #{script} -X"
+  end
+
+
+  # Generate a screen config file and save it to the passed screenrc_filename.
+  # Screen is set up to allow restarting of dead processes with the 'r' key,
+  # and to give each script a meaningful title in the status line.
+  #
+  # @param [String] screenrc_filename the filename to save the
+  #   generated config file to.
+  # @return [NilClass] nil.
+  def write_screenrc(screenrc_filename)
+    File.open(screenrc_filename, "wb") do |f|
+      f.write <<-SCREENRC
+zombie cr onerror
+hardstatus alwayslastline "%-Lw%{= BW}%50>%n%f* %t%{-}%+Lw%<"
+
+SCREENRC
+      SCRIPTS.each do |script|
+        f.puts( command_for_script(script) )
+      end
+    end
+
+    return nil
+  end
+
+
+
+  # Daemonize the bannister process and yield. Used when running in
+  # the background. This is a slightly different daemonize method to
+  # the usual, in that we need to be sure that the script filenames in
+  # SCRIPT don't lose their relative location, so we chdir to '/'
+  # *after* kicking them off. It's each individual script's
+  # responsibility to daemonise properly.
+  def daemonize()
+    exit!(0) if fork
+    Process::setsid
+    exit!(0) if fork
+    File::umask(0)
+    STDIN.reopen("/dev/null")
+    STDOUT.reopen("/dev/null", "w")
+    STDERR.reopen("/dev/null", "w")
+
+    yield if block_given?
+
+    # chdir after yield so that the script paths remain correct
+    # and if any of them rely on relative paths, they won't get
+    # broken
+    Dir::chdir("/")
+
+    return nil
+  end
+
+
+  # Set up our environment and launch everything in the background.
+  def do_start()
+    $stderr.reopen("/tmp/bannister.start.err.log", "wb")
+    $stdout.reopen("/tmp/bannister.start.out.log","wb")
+  
+    set_name()
+    drop_pid()
+    launch_all()
+  end
+
+  # Set the process name to something meaningful. In this case,
+  # "something meaningful" means "bannister:" + the name of the
+  # directory we're in. This makes it easy to see which bannister pids
+  # are responsible for which applications.
+  #
+  # @return [NilClass] nil.
+  def set_name
+    $0 = "bannister:"+File.basename(FileUtils.pwd)
+
+    return nil
+  end
+
+  # Record the current pid somewhere it can be found later
+  def drop_pid
+    system "mkdir -p #{File.dirname PID_FILENAME}"
+    File.open(PID_FILENAME, "w"){|f| f.write $$.to_s}
+
+    return nil
+  end
+
+
+  # Read the pid from where drop_pid left it, or nil if it's not there.
+  #
+  # @return [Fixnum] pid as integer if it exists
+  # @return [NilClass] nil otherwise.
+  def read_pid
+    if File.exists?(PID_FILENAME)
+      return Integer(File.read(PID_FILENAME).strip)
+    else
+      return nil
+    end
+  end
+
+
+  # Clear the pid that drop_pid left behind.
+  #
+  # @return [NilClass] nil.
+  def remove_pid
+    FileUtils.rm_f(PID_FILENAME)
+
+    return nil
+  end
+
+
+  # Fork and exec each of SCRIPTS.
+  #
+  # @return [NilClass] nil.
+  def launch_all()
+    SCRIPTS.each do |script|
+      LAUNCHED_PIDS << fork do
+        exec script
+      end
+    end
+
+    return nil
+  end
+
+
+  # Call Process.waitpid on each process launched by launch_all.
+  #
+  # @return [NilClass] nil.
+  def wait_for_all()
+    LAUNCHED_PIDS.each do |pid|
+      Process.waitpid(pid)
+    end
+
+    return nil
+  end
+
+
+  # Send the TERM signal to each process launched by launch_all.
+  #
+  # @return [NilClass] nil.
+  def kill_all()
+    LAUNCHED_PIDS.each do |pid|
+      if ::Bannister::Utils.foreign_pid_alive?(pid)
+        system "kill -15 #{pid}"
+      else
+        $stderr.puts "Pid #{pid} doesn't seem to be running!"
+      end
+    end
+
+    return nil
+  end
+
+
+
+
+
+end
+Connection to alpha.bytemark.co.uk closed.

data/lib/bannister.remote.rb

@@ -0,0 +1,273 @@
+require 'fileutils'
+require 'bannister/utils'
+
+module Bannister
+
+
+  # List of scripts in script/startup sorted asciibetically. This is the order 
+  # they will be launched in, but there is no further dependency checking
+  # between the scripts.
+  SCRIPTS = Dir['script/startup/*'].sort
+
+  # A list of pids of the started scripts. These will be sent TERM signals when
+  # bannister is stopped.
+  LAUNCHED_PIDS = []
+
+  # The location of the pidfile for the master process. This will be 
+  # de-hard-coded in a future release.
+  PID_FILENAME = "pids/bannister.pid"
+
+
+  # Daemonize and launch the managed processes.
+  def start()
+    if running?
+      err "This app is already running!  Run #{$0} stop first (or remove #{PID_FILENAME} if you know better)."
+    else
+      daemonize(){ do_start() }
+      wait_for_all()
+    end
+  end
+
+
+  # Launch the managed processes in screen so that they are all foreground
+  # processes.
+  #
+  # If run from inside an existing screen session, it will be reused, and the
+  # managed processes will be added to it. Otherwise a new screen session is
+  # started.
+  #
+  # Starting a new screen session is done by writing a temporary screenrc 
+  # to /tmp, so $HOME/.screenrc is ignored.
+  def run()
+    screenrc_filename = "/tmp/screenrc.#{$$}"
+
+    if ENV['STY'] && !ENV['STY'].empty?
+      # then we already have a screen, so reuse it
+      # by simply running all the commands
+
+      SCRIPTS.each do |script|
+        system( command_for_script(script) )
+      end
+
+    else # create it. The easiest way to do this is to write 
+      # out a screenrc containing the relevant commands and
+      # let screen launch them
+      begin
+        write_screenrc(screenrc_filename)
+
+        system "screen","-c",screenrc_filename
+      ensure
+        FileUtils.rm_f screenrc_filename
+      end
+
+    end
+  end
+
+
+  # Shut down all the managed processes, remove the bannister pidfile and exit.
+  def quit
+    kill_all()
+    remove_pid()
+  end
+
+  
+
+  # Send a TERM signal to a #start'ed bannister process.
+  def stop()
+    old_pid = read_pid()
+    if old_pid
+      if ::Bannister::Utils.foreign_pid_alive?(old_pid)
+        Process.kill("TERM", old_pid)
+        if ::Bannister::Utils.wait_foreign_pid(old_pid)
+          remove_pid()
+        else
+          err "Bannister (pid=#{old_pid}) failed to die!"
+        end
+      else
+        err "Bannister (pid=#{old_pid}) wasn't alive."
+      end
+    end
+  end
+
+
+  # Used when you have erred. Shows the passed error message and exits
+  # with a status of 1.
+  #
+  # @param [String] msg Message to display.
+  def err(msg)
+    $stderr.puts(msg)
+    exit(1)
+  end
+
+
+
+  private
+  # Method to see whether a bannister process for the current application
+  # is running or not.
+  #
+  # @return [Boolean] true if PID_FILENAME exists, false otherwise.
+  def running?
+    return File.exists?(PID_FILENAME)
+  end
+
+
+  # Generate the screen command for the passed script filename. Since this
+  # will only ever be called when running in the foreground, we append -X
+  # to the command. A title for the screen window is also generated based
+  # on the current directory name and the script filename.
+  #
+  # @param [String] script the filename of a script to run.
+  # @return [String] the screen command to run the script.
+  def command_for_script(script)
+    title = File.basename(FileUtils.pwd)+':'+File.basename(script)
+    return "screen -t '#{title}' #{script} -X"
+  end
+
+
+  # Generate a screen config file and save it to the passed screenrc_filename.
+  # Screen is set up to allow restarting of dead processes with the 'r' key,
+  # and to give each script a meaningful title in the status line.
+  #
+  # @param [String] screenrc_filename the filename to save the
+  #   generated config file to.
+  # @return [NilClass] nil.
+  def write_screenrc(screenrc_filename)
+    File.open(screenrc_filename, "wb") do |f|
+      f.write <<-SCREENRC
+zombie cr onerror
+hardstatus alwayslastline "%-Lw%{= BW}%50>%n%f* %t%{-}%+Lw%<"
+
+SCREENRC
+      SCRIPTS.each do |script|
+        f.puts( command_for_script(script) )
+      end
+    end
+
+    return nil
+  end
+
+
+
+  # Daemonize the bannister process and yield. Used when running in
+  # the background. This is a slightly different daemonize method to
+  # the usual, in that we need to be sure that the script filenames in
+  # SCRIPT don't lose their relative location, so we chdir to '/'
+  # *after* kicking them off. It's each individual script's
+  # responsibility to daemonise properly.
+  def daemonize()
+    exit!(0) if fork
+    Process::setsid
+    exit!(0) if fork
+    File::umask(0)
+    STDIN.reopen("/dev/null")
+    STDOUT.reopen("/dev/null", "w")
+    STDERR.reopen("/dev/null", "w")
+
+    yield if block_given?
+
+    # chdir after yield so that the script paths remain correct
+    # and if any of them rely on relative paths, they won't get
+    # broken
+    Dir::chdir("/")
+
+    return nil
+  end
+
+
+  # Set up our environment and launch everything in the background.
+  def do_start()
+    set_name()
+    drop_pid()
+    launch_all()
+  end
+
+  # Set the process name to something meaningful. In this case,
+  # "something meaningful" means "bannister:" + the name of the
+  # directory we're in. This makes it easy to see which bannister pids
+  # are responsible for which applications.
+  #
+  # @return [NilClass] nil.
+  def set_name
+    $0 = "bannister:"+File.basename(FileUtils.pwd)
+
+    return nil
+  end
+
+  # Record the current pid somewhere it can be found later
+  def drop_pid
+    system "mkdir -p #{File.dirname PID_FILENAME}"
+    File.open(PID_FILENAME, "w"){|f| f.write $$.to_s}
+
+    return nil
+  end
+
+
+  # Read the pid from where drop_pid left it, or nil if it's not there.
+  #
+  # @return [Fixnum] pid as integer if it exists
+  # @return [NilClass] nil otherwise.
+  def read_pid
+    if File.exists?(PID_FILENAME)
+      return Integer(File.read(PID_FILENAME).strip)
+    else
+      return nil
+    end
+  end
+
+
+  # Clear the pid that drop_pid left behind.
+  #
+  # @return [NilClass] nil.
+  def remove_pid
+    FileUtils.rm_f(PID_FILENAME)
+
+    return nil
+  end
+
+
+  # Fork and exec each of SCRIPTS.
+  #
+  # @return [NilClass] nil.
+  def launch_all()
+    SCRIPTS.each do |script|
+      LAUNCHED_PIDS << fork do
+        exec script
+      end
+    end
+
+    return nil
+  end
+
+
+  # Call Process.waitpid on each process launched by launch_all.
+  #
+  # @return [NilClass] nil.
+  def wait_for_all()
+    LAUNCHED_PIDS.each do |pid|
+      Process.waitpid(pid)
+    end
+
+    return nil
+  end
+
+
+  # Send the TERM signal to each process launched by launch_all.
+  #
+  # @return [NilClass] nil.
+  def kill_all()
+    LAUNCHED_PIDS.each do |pid|
+      if ::Bannister::Utils.foreign_pid_alive?(pid)
+        system "kill -15 #{pid}"
+      else
+        $stderr.puts "Pid #{pid} doesn't seem to be running!"
+      end
+    end
+
+    return nil
+  end
+
+
+
+
+
+end

data/lib/bannister.remote.rb~

@@ -0,0 +1,278 @@
+require 'fileutils'
+require 'bannister/utils'
+
+module Bannister
+
+
+  # List of scripts in script/startup sorted asciibetically. This is the order 
+  # they will be launched in, but there is no further dependency checking
+  # between the scripts.
+  SCRIPTS = Dir['script/startup/*'].sort
+
+  # A list of pids of the started scripts. These will be sent TERM signals when
+  # bannister is stopped.
+  LAUNCHED_PIDS = []
+
+  # The location of the pidfile for the master process. This will be 
+  # de-hard-coded in a future release.
+  PID_FILENAME = "pids/bannister.pid"
+
+
+  # Daemonize and launch the managed processes.
+  def start()
+    if running?
+      err "This app is already running!  Run #{$0} stop first (or remove #{PID_FILENAME} if you know better)."
+    else
+      daemonize(){ do_start() }
+      wait_for_all()
+    end
+  end
+
+
+  # Launch the managed processes in screen so that they are all foreground
+  # processes.
+  #
+  # If run from inside an existing screen session, it will be reused, and the
+  # managed processes will be added to it. Otherwise a new screen session is
+  # started.
+  #
+  # Starting a new screen session is done by writing a temporary screenrc 
+  # to /tmp, so $HOME/.screenrc is ignored.
+  def run()
+    screenrc_filename = "/tmp/screenrc.#{$$}"
+
+    if ENV['STY'] && !ENV['STY'].empty?
+      # then we already have a screen, so reuse it
+      # by simply running all the commands
+
+      SCRIPTS.each do |script|
+        system( command_for_script(script) )
+      end
+
+    else # create it. The easiest way to do this is to write 
+      # out a screenrc containing the relevant commands and
+      # let screen launch them
+      begin
+        write_screenrc(screenrc_filename)
+
+        system "screen","-c",screenrc_filename
+      ensure
+        FileUtils.rm_f screenrc_filename
+      end
+
+    end
+  end
+
+
+  # Shut down all the managed processes, remove the bannister pidfile and exit.
+  def quit
+    $stderr.reopen("/tmp/bannister.stop.err.log", "wb")
+    $stdout.reopen("/tmp/bannister.stop.out.log", "wb")
+    kill_all()
+    remove_pid()
+  end
+
+  
+
+  # Send a TERM signal to a #start'ed bannister process.
+  def stop()
+    old_pid = read_pid()
+    if old_pid
+      if ::Bannister::Utils.foreign_pid_alive?(old_pid)
+        Process.kill("TERM", old_pid)
+        if ::Bannister::Utils.wait_foreign_pid(old_pid)
+          remove_pid()
+        else
+          err "Bannister (pid=#{old_pid}) failed to die!"
+        end
+      else
+        err "Bannister (pid=#{old_pid}) wasn't alive."
+      end
+    end
+  end
+
+
+  # Used when you have erred. Shows the passed error message and exits
+  # with a status of 1.
+  #
+  # @param [String] msg Message to display.
+  def err(msg)
+    $stderr.puts(msg)
+    exit(1)
+  end
+
+
+
+  private
+  # Method to see whether a bannister process for the current application
+  # is running or not.
+  #
+  # @return [Boolean] true if PID_FILENAME exists, false otherwise.
+  def running?
+    return File.exists?(PID_FILENAME)
+  end
+
+
+  # Generate the screen command for the passed script filename. Since this
+  # will only ever be called when running in the foreground, we append -X
+  # to the command. A title for the screen window is also generated based
+  # on the current directory name and the script filename.
+  #
+  # @param [String] script the filename of a script to run.
+  # @return [String] the screen command to run the script.
+  def command_for_script(script)
+    title = File.basename(FileUtils.pwd)+':'+File.basename(script)
+    return "screen -t '#{title}' #{script} -X"
+  end
+
+
+  # Generate a screen config file and save it to the passed screenrc_filename.
+  # Screen is set up to allow restarting of dead processes with the 'r' key,
+  # and to give each script a meaningful title in the status line.
+  #
+  # @param [String] screenrc_filename the filename to save the
+  #   generated config file to.
+  # @return [NilClass] nil.
+  def write_screenrc(screenrc_filename)
+    File.open(screenrc_filename, "wb") do |f|
+      f.write <<-SCREENRC
+zombie cr onerror
+hardstatus alwayslastline "%-Lw%{= BW}%50>%n%f* %t%{-}%+Lw%<"
+
+SCREENRC
+      SCRIPTS.each do |script|
+        f.puts( command_for_script(script) )
+      end
+    end
+
+    return nil
+  end
+
+
+
+  # Daemonize the bannister process and yield. Used when running in
+  # the background. This is a slightly different daemonize method to
+  # the usual, in that we need to be sure that the script filenames in
+  # SCRIPT don't lose their relative location, so we chdir to '/'
+  # *after* kicking them off. It's each individual script's
+  # responsibility to daemonise properly.
+  def daemonize()
+    exit!(0) if fork
+    Process::setsid
+    exit!(0) if fork
+    File::umask(0)
+    STDIN.reopen("/dev/null")
+    STDOUT.reopen("/dev/null", "w")
+    STDERR.reopen("/dev/null", "w")
+
+    yield if block_given?
+
+    # chdir after yield so that the script paths remain correct
+    # and if any of them rely on relative paths, they won't get
+    # broken
+    Dir::chdir("/")
+
+    return nil
+  end
+
+
+  # Set up our environment and launch everything in the background.
+  def do_start()
+    $stderr.reopen("/tmp/bannister.start.err.log", "wb")
+    $stdout.reopen("/tmp/bannister.start.out.log","wb")
+  
+    set_name()
+    drop_pid()
+    launch_all()
+  end
+
+  # Set the process name to something meaningful. In this case,
+  # "something meaningful" means "bannister:" + the name of the
+  # directory we're in. This makes it easy to see which bannister pids
+  # are responsible for which applications.
+  #
+  # @return [NilClass] nil.
+  def set_name
+    $0 = "bannister:"+File.basename(FileUtils.pwd)
+
+    return nil
+  end
+
+  # Record the current pid somewhere it can be found later
+  def drop_pid
+    system "mkdir -p #{File.dirname PID_FILENAME}"
+    File.open(PID_FILENAME, "w"){|f| f.write $$.to_s}
+
+    return nil
+  end
+
+
+  # Read the pid from where drop_pid left it, or nil if it's not there.
+  #
+  # @return [Fixnum] pid as integer if it exists
+  # @return [NilClass] nil otherwise.
+  def read_pid
+    if File.exists?(PID_FILENAME)
+      return Integer(File.read(PID_FILENAME).strip)
+    else
+      return nil
+    end
+  end
+
+
+  # Clear the pid that drop_pid left behind.
+  #
+  # @return [NilClass] nil.
+  def remove_pid
+    FileUtils.rm_f(PID_FILENAME)
+
+    return nil
+  end
+
+
+  # Fork and exec each of SCRIPTS.
+  #
+  # @return [NilClass] nil.
+  def launch_all()
+    SCRIPTS.each do |script|
+      LAUNCHED_PIDS << fork do
+        exec script
+      end
+    end
+
+    return nil
+  end
+
+
+  # Call Process.waitpid on each process launched by launch_all.
+  #
+  # @return [NilClass] nil.
+  def wait_for_all()
+    LAUNCHED_PIDS.each do |pid|
+      Process.waitpid(pid)
+    end
+
+    return nil
+  end
+
+
+  # Send the TERM signal to each process launched by launch_all.
+  #
+  # @return [NilClass] nil.
+  def kill_all()
+    LAUNCHED_PIDS.each do |pid|
+      if ::Bannister::Utils.foreign_pid_alive?(pid)
+        system "kill -15 #{pid}"
+      else
+        $stderr.puts "Pid #{pid} doesn't seem to be running!"
+      end
+    end
+
+    return nil
+  end
+
+
+
+
+
+end

data/lib/bannister/apache.rb

@@ -1,17 +1,36 @@
+require 'bannister/utils'
 
 module Bannister
   # A standardised apache launcher.
   class Apache
 
-    # Location of apache's pidfile. This must agree with apache.conf.
-    PidFilename = "tmp/apache2.pid"
-
-    # @param [Hash] config A config hash to be merged with ENV for 
-    #   substitution into apache.conf.
-    def initialize(config)
+    # @param [Hash] config A config hash to be merged with ENV for
+    #   substitution into apache.conf.  
+    # @param [String] apacheconf_filename Location of apache.conf (only used if
+    #   config['DefaultConfig'] doesn't exist, otherwise
+    #   config['Apache2Conf'] is used instead
+    # @param [String] pid_filename Location where apache will write its pidfile
+    #   (only used if config['DefaultConfig'] doesn't exist, otherwise
+    #   config['DefaultConfig']['
+    def initialize(config, apacheconf_filename=nil, pid_filename=nil)
       raise ArgumentError.new("config cannot be nil") if config.nil?
 
-      @config = config
+
+      # FIXME: This is pig-ugly, and must be changed for 1.0.0. We do it
+      #   this way for compatibility with existing deployments, but the old
+      #   way hardcodes the pid filename, which is problematic and won't
+      #   work across what's already actually deployed.
+      if config.has_key?("DefaultConfig")
+        @config = config['DefaultConfig']
+        @apacheconf_filename = config['Apache2Conf']
+        @pid_filename = @config['PID_FILE']
+      else
+        @config = config
+        @apacheconf_filename = apacheconf_filename
+        @pid_filename = pid_filename
+      end
+      
+      @pid = nil
     end
 
 
@@ -19,22 +38,10 @@ module Bannister
     # Send a TERM signal to the apache process. If the process
     # is still running after 2 seconds, a RuntimeError is thrown.
     def stop
-      if pid = read_pid()
+      if pid = @pid
         Process.kill("TERM", pid)
-        # the apache process isn't a child process, so we can't
-        # use Process.waitpid. Instead we use kill -0, which tests
-        # whether we can send the given pid a signal.
-        catch :done do
-          20.times do
-            sleep(0.1)
-            # No need to trap error messages here, because `kill`
-            # gives us a meaningful error code
-            next if system "kill -0 #{pid} 2> /dev/null"
-            throw :done
-          end
-          
-          raise "Apache2 (pid=#{pid}) failed to stop!"
-        end
+      else
+        $stderr.puts "No apache pid found!"
       end
     end
 
@@ -48,48 +55,26 @@ module Bannister
     #
     # @param [Boolean] foreground Set true to run in the foreground.
     def start(foreground=false)
-      @apache2_conf = @config['Apache2Conf']
       rewrite_envvars(ENV)
-      system "mkdir -p tmp"
-      cmd = foreground ? "/usr/sbin/apache2 -f #{@apache2_conf} -X &" :
-      "/usr/sbin/apache2 -f #{@apache2_conf}" 
-      if system( cmd )
-        # runner sends TERM, but screen sends a HUP when it quits.
-        # This is why we can't just exec apache -X; apache restarts
-        # on HUP.
-        trap("TERM"){ stop() }
-        trap("HUP"){ stop() }
-
-        # Apache2's pidfile is written by the child process
-        # after the parent process (the one we kick off) terminates.
-        # This means that we need to wait for it.
-        catch :done do
-          20.times do
-            sleep(0.1)
-            next if !File.file?(PidFilename)
-            throw :done
-          end
-          raise "Apache2 failed to write #{PidFilename}"
-        end
-
-        sleep # Sleep to wait for the TERM signal
-
-      else
-        raise "Apache2 failed to start!"
-      end
-
+      system "mkdir -p tmp" # FIXME: check pid_filename
+      cmd = foreground ? "/usr/sbin/apache2 -f #{@apacheconf_filename} -X" :
+      "/usr/sbin/apache2 -f #{@apacheconf_filename} -D FOREGROUND" 
+      trap("TERM"){ stop() }
+      trap("HUP"){ stop() }
+      @pid = fork { exec cmd }
+      Process.waitpid(@pid)
     end
 
 
     private
 
-    # Read apache2's pid from {PidFilename}.
+    # Read apache2's pid from {@pid_filename}.
     #
     # @return [Integer] Apache's process id.
     # @return nil if it's not there.
     def read_pid()
-      if File.file?(PidFilename)
-        return Integer(File.read(PidFilename).strip)
+      if File.file?(@pid_filename)
+        return Integer(File.read(@pid_filename).strip)
       else
         return nil
       end
@@ -100,7 +85,7 @@ module Bannister
     #
     # @param [Hash] vars The config hash
     def rewrite_envvars(vars={})
-      merged_opts = @config['DefaultConfig'].merge(vars)
+      merged_opts = @config.merge(vars)
       merged_opts.each_pair do |k,v|
         ENV[k] = v.to_s
       end

data/lib/bannister/utils.rb

@@ -0,0 +1,46 @@
+module Bannister
+
+  module Utils
+
+
+    def self.wait_while(timeout=2.0, attempts=20)
+      raise ArgumentError.new("No block given!") unless block_given?
+      attempts=20
+      sleepy_time = timeout/attempts
+
+      attempts.times do
+        return true unless yield
+        sleep sleepy_time
+      end
+
+      return nil
+    end
+
+    # Waits for process with process id `pid` to die. This is needed
+    # because Process.waitpid can only wait for child pids.
+    #
+    # @param [Integer] pid process id to wait for
+    # @param [Float] timeout time in seconds to wait for
+    # @return [Boolean] true on success, nil otherwise.
+    def self.wait_foreign_pid(pid, timeout=2.0)
+      raise ArgumentError.new("pid cannot be nil!") unless pid
+
+      return wait_while(){ foreign_pid_alive?(pid) }
+    end
+
+
+    # Check to see if the process with id `pid` responds to signals.
+    #
+    # @param [Integer] pid process id to check
+    # @return [Boolean] true if process `pid` responds.
+    def self.foreign_pid_alive?(pid)
+      raise ArgumentError.new("pid cannot be nil!") unless pid
+
+      return system "kill -0 #{pid} 2> /dev/null"
+    end
+
+
+  end
+
+
+end

data/lib/bannister/version.rb

@@ -1,3 +1,3 @@
 module Bannister
-  VERSION="0.0.2"
+  VERSION="0.0.3"
 end

data/lib/bannister/version.rb.orig

@@ -0,0 +1,3 @@
+module Bannister
+  VERSION="0.0.3"
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bannister
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Alex Young
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-13 00:00:00 +01:00
+date: 2010-10-15 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,9 +47,14 @@ extra_rdoc_files: []
 files: 
 - bin/bannister
 - lib/bannister/version.rb
+- lib/bannister/version.rb.orig
 - lib/bannister/recurse.rb
 - lib/bannister/apache.rb
+- lib/bannister/utils.rb
+- lib/bannister.remote.rb
 - lib/bannister.rb
+- lib/bannister.remote.rb~
+- lib/bannister.rb.orig
 - README.md
 - Rakefile
 has_rdoc: true