bannister 0.0.1

data/README.md

@@ -0,0 +1,31 @@
+Bannister
+=========
+
+'Cos it's a runner.
+
+INTRODUCTION
+------------
+
+
+Generalised app runner.  Launches all of the scripts in $(pwd)/script/startup
+in sort order.  All the scripts must respond to the TERM signal by shutting
+down, and they will be passed the -X script if they are to run in the
+foreground.
+
+
+USAGE
+-----
+
+$(pwd) must be the root of the application.
+
+To daemonize an application, run:
+
+  $ bannister start
+
+To start an application in screen, run:
+
+  $ bannister run
+
+To stop a daemonized application, run:
+
+  $ bannister stop

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake/clean'
+CLEAN << ".yardoc"
+CLEAN << FileList["*.gem"]
+CLEAN << "doc"
+
+desc "Build the gem"
+task :gem do
+  system "gem build bannister.gemspec"
+end
+
+desc "Build the YARD docs"
+task :docs do
+  system "yardoc"
+end

data/bin/bannister

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'bannister'
+include Bannister
+
+
+trap("TERM") { quit() }
+
+case ARGV.shift
+when "start"
+  start()
+when "run"
+  run()
+when "stop"
+  stop()
+when "restart"
+  stop()
+  start()
+else
+  err "usage: #{$0} (run|start|stop|restart)"
+end

data/lib/bannister/apache.rb

@@ -0,0 +1,102 @@
+
+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)
+      raise ArgumentError.new("config cannot be nil") if config.nil?
+
+      @config = config
+    end
+
+
+
+    # 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()
+        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)
+            next if system "kill -0 #{pid} 2> /dev/null"
+            throw :done
+          end
+          raise "Apache2 failed to stop!"
+        end
+      end
+    end
+
+
+    # Start apache, then sleep. If foreground is true, then pass the -X option
+    # to apache. This makes it run in the foreground.
+    #
+    # Before sleeping, trap TERM and HUP so that we can signal apache to stop.
+    # We need to do this so that when screen exits, we can tell apache to exit
+    # instead of restart, which is its usual HUP response.
+    #
+    # @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
+
+    end
+
+
+    private
+
+    def read_pid()
+      if File.file?(PidFilename)
+        return Integer(File.read(PidFilename).strip)
+      else
+        return nil
+      end
+    end
+
+
+    # Merge the config hash into ENV
+    #
+    # @param [Hash] vars The config hash
+    def rewrite_envvars(vars={})
+      merged_opts = @config['DefaultConfig'].merge(vars)
+      merged_opts.each_pair do |k,v|
+        ENV[k] = v.to_s
+      end
+    end
+  end
+end

data/lib/bannister/recurse.rb

@@ -0,0 +1,40 @@
+module Bannister
+
+  # Use the Recurse class to launch other bannister apps from this one.
+  class Recurse
+
+    # @param [String] dir Directory to chdir to before running bannister
+    def initialize(dir)
+      raise ArgumentError.new("dir cannot be nil!") if dir.nil?
+
+      @dir=dir
+    end
+
+    
+    # Run "bannister stop" and exit.
+    def stop
+      system "bannister stop"
+      exit(0)
+    end
+
+
+    # If foreground is true, exec "bannister run" in @dir.  Otherwise set up
+    # traps for the right signals to a backgrounded "bannister start" process.
+    def start(foreground=false)
+      Dir.chdir(@dir) do
+        if foreground
+          exec "bannister run"
+        else
+          trap("TERM"){stop()}
+          trap("HUP"){stop()}
+
+          system "bannister start &"
+
+          sleep()
+        end
+      end
+    end
+
+
+  end
+end

data/lib/bannister/version.rb

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

data/lib/bannister.rb

@@ -0,0 +1,194 @@
+require 'fileutils'
+
+module Bannister
+
+
+  SCRIPTS = Dir['script/startup/*'].sort
+  LAUNCHED_PIDS = []
+  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."
+    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()
+    exit(0)
+  end
+
+  
+
+  # Send a TERM signal to a #start'ed bannister process.
+  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
+      end
+      remove_pid()
+    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
+  def running?
+    return File.exists?(PID_FILENAME)
+  end
+
+
+  def command_for_script(script)
+    title = File.basename(FileUtils.pwd)+':'+File.basename(script)
+    return "screen -t '#{title}' #{script} -X"
+  end
+
+
+  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
+  end
+
+
+
+  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("/")
+  end
+
+
+  def do_start()
+    set_name()
+    drop_pid()
+    launch_all()
+  end
+
+  def set_name
+    $0 = "bannister:"+File.basename(FileUtils.pwd)
+  end
+
+  def drop_pid
+    system "mkdir -p #{File.dirname PID_FILENAME}"
+    File.open(PID_FILENAME, "w"){|f| f.write $$.to_s}
+  end
+
+
+  def read_pid
+    if File.exists?(PID_FILENAME)
+      return Integer(File.read(PID_FILENAME).strip)
+    else
+      return nil
+    end
+  end
+
+
+  def remove_pid
+    FileUtils.rm_f(PID_FILENAME)
+  end
+
+
+  def launch_all()
+    SCRIPTS.each do |script|
+      LAUNCHED_PIDS << fork do
+        exec script
+      end
+    end
+  end
+
+
+  def wait_for_all()
+    LAUNCHED_PIDS.each do |pid|
+      Process.waitpid(pid)
+    end
+  end
+
+
+  def kill_all()
+    LAUNCHED_PIDS.each do |pid|
+      system "kill -15 #{pid}"
+    end
+  end
+
+
+
+
+
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: bannister
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alex Young
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-22 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: |
+  An application launcher which maintains a tree of processes to keep background
+  processes tied to the launcher.
+
+email: 
+- alex@blackkettle.org
+executables: 
+- bannister
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/bannister
+- lib/bannister/apache.rb
+- lib/bannister/recurse.rb
+- lib/bannister/version.rb
+- lib/bannister.rb
+- README.md
+- Rakefile
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A generalised application launcher with apache support.
+test_files: []
+