ruby-style 1.0.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007 Jeremy Evans <code@jeremyevans.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,292 @@
+= style (Supervised TCPServer, Yielding Listeners Easily)
+
+style is a Ruby program that provides a supervised TCPServer (or TCPServers)
+with multiple listening childing processes.  It allows the child processes to
+be killed and respawned while making sure that there are always child processes
+available to listen to requests.  It automatically respawns dead
+child processes.  It allows for increasing and decreasing the number of child
+processes on the fly.  
+
+style is distributed as a gem, and can be installed with:
+
+    sudo gem install ruby-style
+
+Feedback/Bugs/Support Requests should be handled through RubyForge at
+http://rubyforge.org/projects/ruby-style/.
+
+The RDoc is available at http://code.jeremyevans.net/doc/ruby-style/.
+Subversion access is available at svn://code.jeremyevans.net/ruby-style/.
+
+== Highlights
+
+* Always has child listeners available, so no connections are lost when
+  listeners are restarted
+* Automatically restarts dead child processes
+* Supports both single port and multiple port clustering, with an arbitrary
+  number of listeners per port
+* Supports increasing and decreasing the number of child processes per port on
+  the fly
+* Supports both command line and yaml config file configuration
+* Is easily extensible to support running other frameworks and protocols other
+  than the included ones (RailsMongrel and RailsSCGI)
+
+== Running and configuration
+
+To see the available commands and possible and default configuration options,
+just run the program without any arguments:
+
+style [option value, ...] (decrement|halt|increment|restart|start|stop)
+ Options:
+  -b, --bind          IP address to bind to [127.0.0.1]
+  -c, --config        Location of config file [config/style.yaml]
+  -d, --directory     Working directory [.]
+  -f, --fork          Number of listners on each port [1]
+  -k, --killtime      Number of seconds to wait when killing each child [2]
+  -l, --logfile       Where to redirect STDOUT and STDERR [log/style.log]
+  -n, --number        Number of ports to which to bind [1]
+  -p, --port          Starting port to which to bind [9999]
+  -P, --pidfile       Location of pid file [log/style.pid]
+  -s, --style         Type of style to use [RailsMongrel]
+  -u, --unsupervised  Whether to run unsupervised [No]
+
+Here's what the various commands do:
+
+* decrement (USR2) - Decrease the number of listeners per port by 1
+* halt (TERM) - Immediately shutdown the child processes and exit
+* increment (USR1) - Increase the number of listeners per port by 1
+* restart (HUP) - Replace the current listeners with new listeners
+* start - Starts the supervisor process and the listening processes
+* stop (INT) - Gracefully shutdown the child processes and exit
+
+All commands except start just send the listed signal to the preexisting
+supervisor process specified in the pid file.
+
+Note that the -d (--directory) option changes the working directory of the
+process, so the -c, -l, and -P options are relative to that.
+
+Here's a longer explanation of the options:
+
+  -b, --bind          IP address to bind to [127.0.0.1]
+
+  This is the TCP/IP networking sockets to bind to.  It defaults to the
+  loopback address because generally the web application runs on the same
+  physical server as the web server.  If this is not the case, change it to an
+  externally available IP, and make sure to lock down access to the port via a
+  firewall.
+
+  -c, --config        Location of config file [config/style.yaml]
+
+  This is the configuration file for style.  It is recommended that you use
+  this instead of the command line configuration, as it saves typing.  This
+  path is relative to the working directory, so if it is not inside the working
+  directory, make sure you specify an absolute path.  This option is not
+  configurable from the configuration file.
+
+  -d, --directory     Working directory [.]
+
+  This is the working directory of the process.  It should generally be the
+  path to the root of the application.  Alternatively, you can change to the
+  root of the application before hand and then not use this option. This option
+  is not configurable from the configuration file.
+
+  -f, --fork          Number of listners on each port [1]
+
+  This enables multiple child processes listening on each port.  It is
+  recommended that you use -f instead of -n for multiple listeners, since it
+  simplifies the configuration of the webserver, and can also eliminate
+  the need for a proxy such as pound or pen to handle this for you.  It
+  defaults to one process per port.  Note that when restarting processes, 
+  replacement processes are started before the currently listening processes
+  are killed, so it is possibly to have multiple processes listening on a port
+  even if this is left at one.
+
+  -k, --killtime      Number of seconds to wait when killing each child [2]
+
+  This sets the time that style between sending shutdown signals to child
+  process, as well as the time between starting a replacement process and
+  killing an existing process.  When restarting, the amount of time spent
+  waiting should be between 2-3 * (killtime * number * fork).
+
+  -l, --logfile       Where to redirect STDOUT and STDERR  [log/style.log]
+
+  This is the location of the log file, relative to the working directory.
+  style itself doesn't output anything after it has detached from the listening
+  terminal, but child listening processes might output to STDOUT or STDERR.
+
+  -n, --number        Number of ports to which to bind [1]
+
+  This makes style start up multiple sockets, one per port starting with the
+  given port (so port, port+1, port+2, ..., port+n).  This makes webserver
+  configuration a little more difficult than with just using -f, and might
+  also require a separate proxy such as pound or pen, so you should try just
+  using -f first.
+  
+  -p, --port          Starting port to which to bind [9999]
+
+  This is the starting (or only) port that style will use.  If -n is used, all
+  ports will be greater than this one.
+
+  -P, --pidfile       Location of pid file [log/style.pid]
+
+  This is the pid file, relative to the working directory.  The pid file is
+  necessary, as it is what is used by all commands other than start.  If
+  incorrect information is in the pid file, the processes won't be stopped when
+  they should be, and you will probably won't be able to start new processes
+  (because the ports will still be in use).
+
+  -s, --style         Type of style to use [RailsMongrel]
+
+  This is the type of style to use.  It defaults to RailsMongrel, as that is
+  most common configuration these days.  The other style included with style is
+  RailsSCGI.  Adding other styles is fairly easy, just make the style is in a
+  file named XXXXXStyle.rb (where XXXXX is in the name of the style), and that
+  file is located in ruby's library path ($:, e.g. via the RUBYLIB environment
+  variable).  See the included styles for an example.
+
+  -u, --unsupervised  Whether to run unsupervised [No]
+  
+  This starts child processes without using a supervisor process.  It is not
+  as reliable or as featureful as the regular supervised mode, but those may
+  not be necessary for smaller sites.  In unsupervised mode, only restart,
+  start, and stop are valid commands, child processes aren't automatically
+  restarted when they die, and you may lose connections during restarts.
+
+Every one of the long options can also be specified in the config file.  Also,
+the  config file if you want to specify any settings specific to the style
+being used (such as modifying the Rails environment setting).  
+
+== Included styles and config files
+
+style current comes with support for the following styles: RailsMongrelStyle
+(the default, which requires rails and mongrel), and RailsSCGIStyle (which
+requires rails and ruby-scgi).
+
+The RailsMongrel style supports running Rails on Mongrel, which would usually
+be deployed behind a front end webserver, such as Apache, Lighttpd, or Nginx.
+The RailsSCGI style supports running Rails over SCGI, which is supported by
+both Apache and Lighttpd.  Both default to running Rails in production mode,
+as style is designed as a production tool.
+
+Example RailsMongrel style.yaml that listens on ports 8912 and 8192 on any
+interface, with three listeners per port.  Note how the :style_config entry is
+used to set up settings specific to the RailsMongrel style, such as placing
+Rails in development mode.
+
+---
+:port: 8912
+:bind: ""
+:fork: 3
+:number: 2
+:killtime: 1
+:style: RailsMongrel
+:style_config:
+  :environment: development
+  :log_file: log/rails-mongrel.log
+  :docroot: public
+  :num_processors: 99
+  :timeout: 100
+
+Example RailsSCGI style.yaml that has four listeners on port 8912:
+
+---
+:port: 8912
+:fork: 4
+:number: 1 
+:style: RailsSCGI
+:style_config:
+  :logfile: log/railsscgi.log
+  :maxconns: 10
+  :environment: production
+
+Very simple configuration that runs RailsMongrel style in unsupervised mode on
+port 3000.
+
+---
+:port: 3000
+:unsupervised: 1
+
+== How restarting works
+
+Restarting works by starting a new child process, waiting for killtime, and then
+killing the exisiting process.  It repeats this for all existing child processes.
+
+For example:
+
+# style idling with three listeners
+Thu Sep  6 12:01:47 PDT 2007
+11460 ??  I       0:00.00 ruby: RailsMongrelStyle dir:/home/billg/testrails supervisor (ruby)
+ 6540 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+  272 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+27808 ??  I       0:02.51 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+# Restart occurs, new process started (1207)
+Thu Sep  6 12:01:49 PDT 2007
+11460 ??  I       0:00.00 ruby: RailsMongrelStyle dir:/home/billg/testrails supervisor (ruby)
+27808 ??  I       0:02.51 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+  272 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 6540 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 1207 ??  R       0:00.95 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+# Old process killed (27808)
+Thu Sep  6 12:01:51 PDT 2007
+11460 ??  I       0:00.01 ruby: RailsMongrelStyle dir:/home/billg/testrails supervisor (ruby)
+ 6540 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+  272 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 1207 ??  I       0:02.51 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+# New process started (3204)
+Thu Sep  6 12:01:53 PDT 2007
+11460 ??  I       0:00.01 ruby: RailsMongrelStyle dir:/home/billg/testrails supervisor (ruby)
+  272 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 6540 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 1207 ??  I       0:02.51 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 3204 ??  R       0:01.01 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+# Old process killed (6540)
+Thu Sep  6 12:01:55 PDT 2007
+11460 ??  I       0:00.01 ruby: RailsMongrelStyle dir:/home/billg/testrails supervisor (ruby)
+  272 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 1207 ??  I       0:02.51 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 3204 ??  I       0:02.49 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+# New process started (6766)
+Thu Sep  6 12:01:57 PDT 2007
+11460 ??  I       0:00.01 ruby: RailsMongrelStyle dir:/home/billg/testrails supervisor (ruby)
+  272 ??  I       0:02.52 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 1207 ??  I       0:02.51 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 3204 ??  I       0:02.49 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 6766 ??  R       0:00.99 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+# Old process killed (272)
+Thu Sep  6 12:01:59 PDT 2007
+11460 ??  I       0:00.01 ruby: RailsMongrelStyle dir:/home/billg/testrails supervisor (ruby)
+ 1207 ??  I       0:02.51 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 3204 ??  I       0:02.49 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+ 6766 ??  I       0:02.49 ruby: RailsMongrelStyle dir:/home/billg/testrails port:8912 environment:production (ruby)
+
+Result, three brand new listening processes, total time to restart is about 12
+seconds (2 * (2 killtime * 1 number * 3 fork)).
+
+== Other frameworks and protocols
+
+style can support any ruby server program that supports the following
+interface (which is called a style):
+
+# in file XXXXXStyle.rb, which must be in ruby's path ($:)
+# XXXXX is the name of the style (e.g. RubySCGI)
+  class XXXXXStyle
+    def initialize(options)
+      #options is a Hash
+    end
+    
+    def listen(socket)
+      # socket is a TCPServer
+    end
+  end
+
+Just specify the style with -s or --style on the command line, or :style in the
+config file.
+
+== FAQ
+
+Q: Does this run on Windows?
+
+A: No.  Among other things, style uses fork, which is not available on Windows.
+
+Q: Does it work with Capistrano yet?
+
+A: I haven't tried.  If you have luck, let me know.

data/bin/style

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'style'
+Style.new.process(ARGV[0])

data/lib/RailsMongrelStyle.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'yaml'
+require 'mongrel'
+require 'mongrel/rails'
+require 'etc'
+require 'cgi_multipart_eof_fix' rescue nil
+
+module Mongrel
+  # Patch the Mongrel HttpServer to add a socket= method
+  class HttpServer
+    attr_writer :socket
+    
+    # Keep the interface the same, but ignore the host and port and don't
+    # create a socket (one will be provided later)
+    def initialize(host, port, num_processors=2**30-1, timeout=0)
+      @classifier = URIClassifier.new
+      @workers = ThreadGroup.new
+      @timeout = timeout
+      @num_processors = num_processors
+      @death_time = 60
+    end
+  end
+end
+
+# This hooks the HTTP request into Ruby on Rails and Mongrel.
+class RailsMongrelStyle
+  attr_reader :mongrel
+  
+  # Initialzes Rails and Mongrel with the appropriate environment and settings.
+  def initialize(settings)
+    settings = {:cwd => Dir.pwd, :log_file => 'log/rails-mongrel.log', 
+                :environment => 'production', :docroot => 'public',
+                :mime_map => nil, :debug => false, :includes => ["mongrel"],
+                :config_script => nil, :num_processors => 1024, :timeout => 0,
+                :user => nil, :group => nil, :prefix => nil}.merge(settings)
+    ENV['RAILS_ENV'] = settings[:environment]
+    $0 += " environment:#{ENV['RAILS_ENV']}"
+    @mongrel = Mongrel::Rails::RailsConfigurator.new(settings) do
+      listener do
+        mime = defaults[:mime_map] ? load_mime_map(defaults[:mime_map], mime) : {}
+        debug "/" if defaults[:debug]
+        uri defaults[:prefix] || "/", :handler => rails(:mime => mime, :prefix => defaults[:prefix])
+        load_plugins
+        run_config(defaults[:config_script]) if defaults[:config_script]
+        setup_rails_signals
+      end
+    end
+  end
+  
+  # Set the HttpServer to the correct socket and start running the mongrel event loop.
+  def listen(socket)
+    mongrel.instance_variable_get('@rails_handler').instance_variable_get('@listener').socket = socket
+    mongrel.run
+    mongrel.join
+  end
+end
+
+GemPlugin::Manager.instance.load "mongrel" => GemPlugin::INCLUDE, "rails" => GemPlugin::EXCLUDE

data/lib/RailsSCGIStyle.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'scgi'
+
+# This SCGI::Processor subclass hooks the SCGI request into Ruby on Rails.
+class RailsSCGIStyle < SCGI::Processor
+  # Initialzes Rails with the appropriate environment and settings
+  def initialize(settings)
+    ENV['RAILS_ENV'] = settings[:environment] || 'production'
+    $0 += " environment:#{ENV['RAILS_ENV']}"
+    require "config/environment"
+    ActiveRecord::Base.threaded_connections = false
+    require 'dispatcher'
+    super(settings)
+    @guard = Mutex.new
+  end
+
+  # Submits requests to Rails in a single threaded fashion
+  def process_request(request, body, socket)
+    return if socket.closed?
+    cgi = SCGI::CGIFixed.new(request, body, socket)
+    begin
+      @guard.synchronize{Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, cgi.stdoutput)}
+    rescue IOError
+      @log.error("received IOError #$! when handling client.  Your web server doesn't like me.")
+    rescue Object => rails_error
+      @log.error("calling Dispatcher.dispatch", rails_error)
+    end
+  end
+end

data/lib/style.rb

@@ -0,0 +1,423 @@
+#!/usr/local/bin/ruby
+require 'getoptlong'
+require 'socket'
+require 'thread'
+require 'yaml'
+
+# Supervised TCPServer, Yielding Listeners Easily
+#
+# Style creates a supervised (or unsupervised) group of processes listening on
+# one or more TCP sockets.  It allows for rock solid restarting of processes
+# without modifications to other software, since the same listening socket is
+# reused, and replacement processes are started before the previous processes
+# are killed.  The number of processes used can be increased or decreased on
+# the fly by sending signals to the process.  Children that die are automatically
+# restarted.  The general idea for this was inspired by Erlang/OTP's supervision
+# trees.
+class Style
+  attr_reader :config, :mutex
+  VALID_STYLE_RE = /\A[A-Z][A-ZA-z0-9]*\z/
+  
+  # Configure style
+  def initialize
+    super
+    @config = {:pidfile=>'log/style.pid', :number=>1, :port=>9999,
+               :style=>'RailsMongrel', :fork=>1, :bind=>'127.0.0.1',
+               :cliconfig=>{}, :killtime=>2, :config=>'config/style.yaml',
+               :logfile=>'log/style.log', :children=>{},:sockets=>{},
+               :style_config=>{}, :directory=>'.'}
+    @mutex = Mutex.new
+    parse_options
+  end
+  
+  # Check that the directory of the given filename exists and is a directory, exit otherwise 
+  def check_dir(filename)
+    filename = File.expand_path(filename)
+    dirname = File.dirname(filename)
+    unless File.directory?(dirname)
+      puts "Invalid directory: #{dirname}"
+      exit(1)
+    end
+    filename
+  end
+  
+  # Check that the filename given exists and is a file, exit otherwise 
+  def check_file(filename)
+    filename = File.expand_path(filename)
+    unless File.file?(filename)
+      puts "Invalid file: #{filename}"
+      exit(1)
+    end
+    filename
+  end
+
+  # Return a hash of options from the config file, or an empty hash
+  def config_file_options(filename)
+    conf = YAML.load(File.read(filename)) rescue (return Hash.new)
+    return Hash.new unless conf.is_a?(Hash)
+    conf.delete(:directory)
+    conf.delete(:config)
+    conf
+  end
+  
+  # Detach the process from the controlling terminal, exit otherwise
+  def detach
+    unless Process.setsid
+      puts "Cannot detach from controlling terminal"
+      exit(1)
+    end
+    trap(:HUP, 'IGNORE')
+  end
+
+  # Load the revelent style
+  def get_style(string)
+    raise NameError, "#{string} is not a valid style!" unless VALID_STYLE_RE.match(string)
+    style= "#{string}Style"
+    require style
+    eval(style)
+  end
+  
+  # Kill each of the given pids in order
+  def kill_children_gently(pids)
+    pids.each{|pid| kill_gently(pid)}
+  end
+
+  # Try to allow the child to die gracefully, by trying INT, TERM, and then KILL
+  def kill_gently(pid)
+    begin
+      Process.kill('INT', pid)
+      sleep(config[:killtime])
+      Process.kill('TERM', pid)
+      sleep(config[:killtime])
+      Process.kill('KILL', pid)
+    rescue
+      return nil
+    end
+  end
+
+  # Parse the command line options, and merge them with the default options and
+  # the config file options.  Config file options take precendence over the
+  # default options, and command line options take precendence over both.
+  def parse_options
+    cliconfig = config[:cliconfig]
+    GetoptLong.new(
+      [ '--bind', '-b', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--config', '-c', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--directory', '-d', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--fork', '-f', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--killtime', '-k', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--logfile', '-l', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--number', '-n', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--port', '-p', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--pidfile', '-P', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--style', '-s', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--unsupervised', '-u', GetoptLong::NO_ARGUMENT]
+    ).each do |opt, arg|
+      case opt
+        when '--bind'
+          cliconfig[:bind] = arg
+        when '--config'
+          config[:config] = cliconfig[:config] = arg
+        when '--directory'
+          config[:directory] = arg
+        when '--fork'
+          cliconfig[:fork] = arg.to_i
+        when '--killtime'
+          cliconfig[:killtime] = arg.to_i
+        when '--logfile'
+          cliconfig[:logfile] = arg
+        when '--number'
+          cliconfig[:number] = arg.to_i
+        when '--port'
+          cliconfig[:port] = arg.to_i
+        when '--pidfile'
+          cliconfig[:pidfile] = arg
+        when '--style'
+          cliconfig[:style] = arg
+        when '--unsupervised'
+          cliconfig[:unsupervised] = true
+      end
+    end
+    
+    config[:directory] = File.expand_path(config[:directory])
+    Dir.chdir(config[:directory]) rescue (puts "Invalid directory: #{arg}"; exit(1))
+    
+    cliconfig[:config] = File.expand_path(check_file(cliconfig[:config])) if cliconfig[:config]
+    config[:config] = File.expand_path(config[:config])
+    reload_config
+    
+    [:logfile, :pidfile].each do |opt|
+      cliconfig[opt] = File.expand_path(cliconfig[opt]) if cliconfig[opt]
+      config[opt] = File.expand_path(config[opt])
+      config[opt] = check_dir(config[opt])
+    end
+    unless VALID_STYLE_RE.match(config[:style])
+      puts "#{config[:style]} is not a valid style!"
+      exit(1)
+    end
+  end
+
+  # Process the command given 
+  def process(command)
+    config[:unsupervised] ? process_unsupervised_command(command) : process_supervised_command(command) 
+  end
+
+  # Process the command given in supervised mode.  All commands except start just send
+  # a signal to the pid in the pid file.
+  def process_supervised_command(command)
+    case command
+      when 'decrement'
+        signal_supervisor(:USR2)
+      when 'halt'
+        signal_supervisor(:TERM)
+      when 'increment'
+        signal_supervisor(:USR1)
+      when 'restart'
+        signal_supervisor(:HUP)
+      when 'start'
+        supervisor_start
+      when 'stop'
+        signal_supervisor(:INT)
+      else
+        puts usage
+        exit(1)
+    end
+  end
+
+  # Process the command given in unsupervised mode.  Only restart, start, and stop
+  # are supported.
+  def process_unsupervised_command(command)
+    case command
+      when /\A(decrement|halt|increment)\z/
+        puts "#{$1} not supported in unsupervised mode"
+        exit(1)
+      when 'restart'
+        stop
+        start
+      when 'start'
+        start
+      when 'stop'
+        stop
+      else
+        puts usage
+        exit(1)
+    end
+  end
+  
+  # Reset the umask and redirect STDIN to /dev/null and STDOUT and STDERR to
+  # the appropriate logfile.
+  def redirect_io
+    File.umask(0000)
+    STDIN.reopen('/dev/null') rescue nil
+    begin
+      STDOUT.reopen(config[:logfile], "a")
+      STDOUT.sync = true
+    rescue
+      STDOUT.reopen('/dev/null') rescue nil
+    end
+    STDERR.reopen(STDOUT) rescue nil
+    STDERR.sync = true
+  end
+
+  # Reload the configuration, used when restarting.  Only the following options
+  # take effect when reloading: config, killtime, pidfile, style, and style_config.  
+  def reload_config
+    config.merge!(config_file_options(config[:config]))
+    config.merge!(config[:cliconfig])
+  end
+  
+  # Restart stopping children by waiting on them.  If the children have died and
+  # are in the list of children, restart them.
+  def restart_stopped_children
+    loop do
+      break unless pid = Process.wait(-1, Process::WNOHANG)
+      #puts "received sigchild, pid #{pid}"
+      mutex.synchronize do
+        if socket = config[:children].delete(pid)
+          start_child(socket)
+        end
+      end
+      Process.detach(pid)
+    end rescue nil
+  end
+  
+  # Setup the necessary signals used in supervisory mode:
+  #
+  #  * CLD - Restart any dead children
+  #  * HUP - Reload configuration and restart all children
+  #  * INT - Gracefully shutdown children and exit
+  #  * TERM - Immediately shutdown children and exit
+  #  * USR1 - Increase the number of listeners on each port by 1
+  #  * USR2 - Decrease the number of listeners on each port by 1
+  #
+  # Note that these signals should be sent to the supervising process,
+  # the child processes are only required to shutdown on INT and TERM, and will
+  # respond to other signals differently depending on the style used.
+  def setup_supervisor_signals
+    trap(:CLD) do
+      # Child Died
+      restart_stopped_children
+    end
+    trap(:HUP) do
+      # Restart Children
+      Dir.chdir(config[:directory]) rescue nil
+      reload_config
+      supervisor_restart_children
+    end
+    trap(:INT) do
+      # Graceful Shutdown
+      supervisor_shutdown
+      kill_children_gently(config[:children].keys)
+      supervisor_exit
+    end
+    trap(:TERM) do
+      # Fast Shutdown
+      supervisor_shutdown
+      pids = config[:children].keys
+      Process.kill('TERM', *pids) rescue nil
+      sleep(config[:killtime])
+      Process.kill('KILL', *pids) rescue nil
+      supervisor_exit
+    end
+    trap(:USR1) do
+      # Increment number of children
+      config[:sockets].keys.each do |socket|
+        mutex.synchronize{start_child(socket)}
+      end
+    end
+    trap(:USR2) do
+      # Decrement number of children
+      config[:children].invert.values.each do |pid|
+        mutex.synchronize do 
+          config[:children].delete(pid)
+          kill_gently(pid)
+        end
+      end
+    end
+  end
+  
+  # Read the pid file and signal the supervising process, or raise an error
+  def signal_supervisor(signal)
+    begin
+      pid = File.read(config[:pidfile]).to_i
+    rescue
+      puts "Can't read pidfile (#{config[:pidfile]}) to send signal #{signal}"
+      exit(1)
+    end
+    if pid > 1
+      Process.kill(signal, pid)
+    else
+      puts "Illegal value in pidfile"
+      exit(1)
+    end
+  end
+
+  # Start a child process.  The child process will reset the signals used, as
+  # well as close any unused sockets, and then it should listen indefinitely on
+  # the provided socket.
+  def start_child(socket)
+    return if config[:shutdown]
+    pid = fork do
+      [:HUP, :INT, :TERM, :USR1, :USR2].each{|signal| trap(signal, 'DEFAULT')}
+      config[:sockets].keys.each{|sock| sock.close unless sock == socket}
+      $0 = "#{config[:style]}Style dir:#{Dir.pwd} port:#{config[:sockets][socket]}"
+      get_style(config[:style]).new(config[:style_config]).listen(socket)
+    end
+    #puts "started pid #{pid}"
+    config[:children][pid] = socket
+  end
+
+  # Start an unsupervised group of processes
+  def start
+    fork do
+      detach
+      redirect_io
+      config[:number].times do |i|
+        port = config[:port]+i
+        socket = TCPServer.new(config[:bind], port)
+        config[:sockets][socket] = port
+        config[:fork].times{start_child(socket)}
+      end
+      File.open(config[:pidfile], 'wb'){|file| file.print("#{config[:children].keys.join(' ')}")}
+    end
+  end
+
+  # Stop an unsupervised group of processes
+  def stop
+    if File.file?(config[:pidfile])
+      pids = nil
+      File.open(config[:pidfile], 'rb'){|f| pids = f.read.split.collect{|x| x.to_i if x.to_i > 1}.compact}
+      if pids.length > 0
+        kill_children_gently(pids)
+        File.delete(config[:pidfile])
+      end
+    end
+  end
+  
+  # Start all necessary children of the supervisor process (number * fork)
+  def supervisor_children_start
+    config[:number].times do |i|
+      port = config[:port]+i
+      socket = TCPServer.new(config[:bind], port)
+      config[:sockets][socket] = port
+      config[:fork].times{start_child(socket)}
+    end
+  end
+
+  # Remove the pid file and exit
+  def supervisor_exit
+    File.delete(config[:pidfile]) rescue nil
+    exit
+  end
+
+  # Do the final setup of the supervisor process, and then loop indefinitely
+  def supervisor_loop
+    $0 = "#{config[:style]}Style dir:#{Dir.pwd} supervisor"
+    redirect_io
+    supervisor_children_start
+    setup_supervisor_signals
+    loop{sleep(10) && restart_stopped_children}
+  end
+
+  # Restart all children of the supervisor process
+  def supervisor_restart_children
+    config[:children].keys.each do |pid|
+      mutex.synchronize{start_child(config[:children].delete(pid))}
+      sleep(config[:killtime])
+      kill_gently(pid)
+    end
+  end
+  
+  # Set the internal shutdown signal for the supervisor process.  Once this is set,
+  # no children will be restarted
+  def supervisor_shutdown
+    config[:shutdown] = true
+  end
+
+  # Start the supervisor process, detaching it from the controlling terminal
+  def supervisor_start
+    fork do
+      detach
+      File.open(config[:pidfile], 'wb'){|file| file.print(fork{supervisor_loop})}
+    end
+  end
+
+  # The command line usage of the style program
+  def usage
+    <<-END
+  style [option value, ...] (decrement|halt|increment|restart|start|stop)
+   Options:
+    -b, --bind          IP address to bind to [127.0.0.1]
+    -c, --config        Location of config file [config/style.yaml]
+    -d, --directory     Working directory [.]
+    -f, --fork          Number of listners on each port [1]
+    -k, --killtime      Number of seconds to wait when killing each child [2]
+    -l, --logfile       Where to redirect STDOUT and STDERR [log/style.log]
+    -n, --number        Number of ports to which to bind [1]
+    -p, --port          Starting port to bind to [9999]
+    -P, --pidfile       Location of pid file [log/style.pid]
+    -s, --style         Type of style to use [RailsMongrel]
+    -u, --unsupervised  Whether to run unsupervised [No]
+    END
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ruby-style
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-09-07 00:00:00 -07:00
+summary: Supervised TCPServer, Yielding Listeners Easily
+require_paths: 
+- lib
+email: code@jeremyevans.net
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Jeremy Evans
+files: 
+- LICENSE
+- README
+- lib/style.rb
+- lib/RailsSCGIStyle.rb
+- lib/RailsMongrelStyle.rb
+test_files: []
+
+rdoc_options: 
+- --inline-source
+- --line-numbers
+extra_rdoc_files: []
+
+executables: 
+- style
+extensions: []
+
+requirements: []
+
+dependencies: []
+