scgi 0.7.0 → 0.8.0

data/README

@@ -1,6 +1,6 @@
 = ruby-scgi
 
-ruby-scgi is a small Ruby script for running Ruby on Rails (and possibly other
+ruby-scgi is a Ruby library for running Ruby on Rails (and possibly other
 web applications) for high-speed deployment of your applications in production.
 It is intended as a replacement for the ancient FastCGI code base and bring
 some big advantages to Rails deployment for production operations.  
@@ -21,29 +21,17 @@ Subversion access is available at svn://code.jeremyevans.net/ruby-scgi/.
 
 == Advantages
 
-* Simultaneous support for Apache1, Apache2, and lighttpd on OSX and most 
-  Linux/BSD systems.
 * Same performance as FastCGI and better performance than other methods.
-* Simple to install, run, and configure.
-* Supports both single-port and multi-port clustering on most systems for that
-  extra boost in concurrency.
-* Supports both command line and config file configuration.
-* Gives out limited status information to help manage your Rails application's
+* Can be used to run Rails with style (sudo gem install style)
+* Gives out limited status information to help manage your application's
   resources.
-* Makes it easy to manage your production deployment, and you can even run your
-  application in development mode exactly the same way as with script/server
-  for extra testing efficiency.
 * You can set a maximum concurrent connections limit, which causes any
   connections over the limit to get redirected to a /busy.html file. This can
   help keep your site alive under heavy load.
-* Simple to configure with your web server. Even if you use clustering you'll
-  be able to manage your webserver and Rails application independently.
-* Supports supervisor mode for rock solid upgrades without losing connections
-* Reasonable defaults for almost everything based on user feedback.
+* Simple to configure with your web server. 
 * Completely free code licensed under Rails's own license.
 * No external dependencies other than Ruby
-* The core implementation and the command line tools are easily extensible for
-  other Ruby web frameworks.
+* The core implementation is easily extensible for other Ruby web frameworks.
 
 == Comparison With FastCGI
 
@@ -85,162 +73,16 @@ ruby-scgi on a totally different machine with this.
 
 == Running and Configuration
 
-If you want to start ruby-scgi with the default configuration, just run:
-
-  scgi_ctrl -d /path/to/rails/app start
-  
-To stop the application:
-
-  scgi_ctrl -d /path/to/rails/app stop
-  
-To restart the application:
-
-  scgi_ctrl -d /path/to/rails/app restart
-  
-Note that restarting/stopping is controlled by a pid file (the location is
-configurable).  If the pidfile exists, it is read and the pids in it are
-killed.  If restarting, new processes are forked after the existing processes
-are killed.
-
-To see the possible and default configuration options, just run the program
-without any arguments:
-
-scgi_ctrl [option=value, ...] (start|stop)
- Options:
-  -b, --bind          IP address to bind to [127.0.0.1]
-  -c, --config        Location of config file [config/scgi.yaml]
-  -d, --directory     Working directory [.]
-  -e, --environment   Environment (for Rails) [production]
-  -f, --fork          Number of listners on each port [1]
-  -k, --killtime      Number of seconds to wait when killing children [2]
-  -l, --logfile       Location of log file [log/scgi.log]
-  -m, --maxconns      Maximum number of concurrent users [2**30-1]
-  -n, --number        Number of ports to bind to [1]
-  -p, --port          Starting port to bind to [9999]
-  -P, --pidfile       Location of pid file [log/scgi.pid]
-  -r, --processor     Type of processor to use [Rails]
-  -s, --supervise     Whether to use a supervisor [No]
-
-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/scgi.yaml]
-  
-  This is the configuration file for ruby-scgi.  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.  Also, note that this is
-  the only option that 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 web application.  Alternatively, you can change to
-  the root of the web application before hand and then not use this option.
-  
-  -e, --environment   Environment (for Rails) [production]
-  
-  This is the only option that is Rails-specific, allowing you to specify the
-  Rails environment on the command line.  It defaults to production because
-  that is the general use case for ruby-scgi.
-  
-  -f, --fork          Number of listners on each port [1]
-  
-  This enables single-port clustering of processes, so there are multiple
-  processes listening on each port.  This can simplify configuration of the
-  webserver, since only a single port need be specified, 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.  Try single port clustering first, and if
-  it is not stable, switch to multiple port clustering.  It is possible to use
-  both as once.
-  
-  -k, --killtime      Number of seconds to wait when killing children [2]
-
-  This sets the time that ruby-scgi will wait when stopping or restarting
-  child processes.  The time can actually be twice as long as this, if the
-  child processes are not shutting down cleanly.
-
-  -l, --logfile       Location of log file [log/scgi.log]
-  
-  This is the location of the log file, relative to the working directory.
-  ruby-scgi doesn't log all that much (starts, shutdowns, bad requests, other
-  errors, and status info when sent SIGUSR2).
-  
-  -m, --maxconns      Maximum number of concurrent users [2**30-1]
-  
-  The maximum number of concurrent connections.  If more connections that this
-  are sent to the server, it redirects them to the /busy.html file.
-  
-  -n, --number        Number of ports to bind to [1]
-  
-  This enables multi-port clustering.  Multi-port clustering listens on
-  multiple ports starting with the port specified (so port, port+1, port+2,
-  ...).  This makes webserver configuration a little more difficult, and might
-  also require a separate proxy such as pound or pen, so you should try
-  single-port clustering first.  You can run both at once if you want.
-  
-  -p, --port          Starting port to bind to [9999]
-  
-  This is the starting (or only) port that ruby-scgi will use.  If multi-port
-  clustering is used, all ports will be greater than this one.
-  
-  -P, --pidfile       Location of pid file [log/scgi.pid]
-  
-  This is the pid file, relative to the working directory.  The pid file is
-  necessary, as it is what is used to specify which pids to kill when stopping
-  or restarting.  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).
-  
-  -r, --processor     Type of processor to use [Rails]
-  
-  This is the type of processor to use, it defaults to Rails, as that is the
-  only one currently supported.  Adding other processers is fairly easy, just
-  make the processor is in a file named XXXXXSCGIProcessor.rb (where XXXXX is
-  in the name of the processor), and that file is located in ruby's library
-  path (the RUBYLIB environment variable).  See RailsSCGIProcessor.rb for an
-  example.
-
-  -s, --supervise     Whether to use a supervisor [No]
-
-  This starts a supervisor process in addition to the worker processes.  The
-  supervisor process can then add and remove children using the same SCGI
-  listening socket, which means that there will be no downtime when you have
-  to upgrade your application.  Using a supervisor restricts some of the
-  variables that will be updated when you use restart.  You can change the
-  environment, fork, killtime, logfile, maxconns, and processor variables.
-  Note that if you use a supervisor, you should specify those variables in
-  the config file and not on the command line, otherwise it won't be 
-  possible to update them.  This is the only option that does not take an 
-  argument on the command line.  To set it in the config file, see below.
-
-Each of the options can also be specified in the config file as a symbol.  An
-example config file would be:
-
----
-:port: 4000
-:fork: 3
-:supervise: true
-
-This sets up a supervised single-port cluster on port 4000 with 3 listening 
-processes.
+ruby-scgi is now just a library and doesn't come with a tool to run Rails. The
+previous command line tool (scgi_ctrl) has been greatly enhanced and is now
+available as a standalone gem called style.
 
 == Example configurations
 
 Note that ruby-scgi is only tested on Lighttpd.  Also, note that Lighttpd
 1.4.16 has a bug which breaks redirects using server.error-handler-404, so
-either use mod_magnet, wait for 1.4.17, or apply the patch in ticket
-1270 on Lighttpd's Trac.
+either use mod_magnet, use 1.4.17, or apply the patch in ticket 1270 on
+Lighttpd's Trac.
 
 Lighttpd:
 
@@ -299,28 +141,14 @@ Apache:
     </Directory>
  </VirtualHost>
 
-== Security
-
-Alright, listen up.  I'm not gonna have people trying to take me to court
-because they think I didn't tell them about security problems.  Here are the
-main attack vectors you should be aware of when running this:
-
-* POSIX signals are bad if you're in a shared hosting setup that configures all
-  processes to run as a common user like *nobody*.  If your provider does this
-  then you should use something else or find a better provider.
-* The config file, pid file, and log file and directories should have
-  appropriate permissions. The config file should ideally be readable but not
-  writable by the user running scgi_ctrl.  The pid and log file directory
-  should be writable by the user running scgi_ctrl and by no other user.  If
-  the config file is writable by a non-trusted user, they could potentially
-  run arbitrary code, and they could certainly open arbitrary ports and or
-  attempt denial of service.  If the pid file is writable by a non-trusted
-  user, it could cause arbitrary processes to be killed by the user running
-  scgi_ctrl
-* Never run scgi_ctrl as root.  If you don't know why you should read up about
-  the unix security model before deploying any more software.
-
-== Changes from previous versions
+== Changes from version 0.7.0
+
+* Command line tool is now in a seperate gem called style
+* You now must pass a socket to SCGI::Processor#listen
+* SCGI::Processor's @log and @maxconns now have defaults
+* SCGI::Processor's @host and @port are no longer used 
+
+== Changes from SCGI Rails Runner by Zed Shaw
 
 * Single-port clustering is back
 * scgi_ctrl is fully configurable on the command line
@@ -337,16 +165,6 @@ the new hotness!
 
 A: Well, aren't you snotty.  You can certainly use Mongrel if you want.  The
 memory/performance differences are small, and it is probably better maintained.
-ruby-scgi may have simpler clustering, and may be useful for certain legacy
-setups.  Also, it works well and it's been working for me for the last few
-years, so I haven't felt the need to change.
-
-Q: Does it work with Capistrano yet?
-
-A: I haven't tried.  If you have luck, let me know.
-
-Q: Is there an easy way to reload?  I don't want to take the whole thing down
-just to deploy new code.
-
-A: Use supervise mode, which ensures that no connections will be lost when
-updating your apps.
+ruby-scgi is a simpler version of SCGI Rails Runner, and may be useful for 
+certain legacy setups.  Also, it works well and it's been working for me for 
+the last few years, so I haven't felt the need to change to Mongrel.

data/lib/scgi.rb

@@ -82,32 +82,21 @@ module SCGI
   # they aren't supported in Apache, and in lighttpd they're unreliable.
   # Also, domain sockets don't work so well on Windows.
   class Processor < Monitor
-    attr_reader :settings
-    
     def initialize(settings = {})
       @total_conns = 0
       @shutdown = false
       @dead = false
       @threads = Queue.new
-      @settings = settings
-      @log = LogFactory.instance.create(settings[:logfile])
-      @host = settings[:bind]
-      @port = settings[:port]
-      @maxconns = settings[:maxconns]
+      @log = LogFactory.instance.create(settings[:logfile] || 'log/scgi.log')
+      @maxconns = settings[:maxconns] || 2**30-1
       super()
       setup_signals
     end
         
-    # Starts the SCGI::Processor having it listen on either the
-    # given socket or listening to a new socket on the @host/@port
-    # configured.  The option to give listen a socket is there so
-    # that others can create one socket, and then fork several processors
-    # to listen to it.
-    #
-    # This function does not return until a shutdown.
-    def listen(socket = nil)
-      @log.info("Started listening on #{@host}:#{@port} at #{@started = Time.now}")
-      @socket = socket || TCPServer.new(@host, @port)
+    # Starts the SCGI::Processor having it listen on the given socket. This
+    # function does not return until a shutdown.
+    def listen(socket)
+      @socket = socket
       
       # we also need a small collector thread that does nothing
       # but pull threads off the thread queue and joins them
@@ -237,8 +226,7 @@ module SCGI
     # when dumping data to the logs
     def status_info
       { 
-      :time => Time.now,  :pid => Process.pid, :settings => @settings,
-      :environment => @settings[:environment], :started => @started,
+      :time => Time.now,  :pid => Process.pid, :started => @started,
       :max_conns => @maxconns, :conns => @threads.length, :systimes => Process.times,
       :shutdown => @shutdown, :dead => @dead, :total_conns => @total_conns
       }.inspect

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: scgi
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
-date: 2007-08-15 00:00:00 -07:00
+  version: 0.8.0
+date: 2007-09-06 00:00:00 -07:00
 summary: Simple support for using SCGI in ruby apps, such as Rails
 require_paths: 
 - lib
@@ -29,10 +29,9 @@ post_install_message:
 authors: 
 - Jeremy Evans
 files: 
-- COPYING
+- LICENSE
 - README
 - lib/scgi.rb
-- lib/RailsSCGIProcessor.rb
 test_files: []
 
 rdoc_options: 
@@ -40,8 +39,8 @@ rdoc_options:
 - --line-numbers
 extra_rdoc_files: []
 
-executables: 
-- scgi_ctrl
+executables: []
+
 extensions: []
 
 requirements: []

data/bin/scgi_ctrl

@@ -1,236 +0,0 @@
-#!/usr/local/bin/ruby
-require 'getoptlong'
-require 'yaml'
-require 'socket'
-SCGI_DEFAULT_CONFIG = {:pidfile=>'log/scgi.pid', :number=>1, :port=>9999,
-  :processor=>'Rails', :fork=>1, :logfile=>'log/scgi.log', :maxconns=>2**30-1,
-  :bind=>'127.0.0.1', :cliconfig=>{}, :killtime=>2, :config=>'config/scgi.yaml'}
-SCGI_CONFIG = {}
-
-module SCGI
-  class Starter
-    def initialize
-      super
-      parse_options
-    end
-    
-    def config_file_options(filename)
-      begin
-        config = YAML.load(File.read(filename))
-        config.is_a?(Hash) ? config : Hash.new
-      rescue
-        Hash.new
-      end
-    end
-
-    def get_processor(string)
-      raise NameError, "#{string} is not a valid processor!" unless string =~ /\A[A-Z][A-ZA-z]*\z/
-      processor = "#{string}SCGIProcessor"
-      require processor
-      eval(processor)
-    end
-    
-    def kill_children_forcefully(pids)
-      kill_pids('TERM', *pids)
-      sleep(SCGI_CONFIG[:killtime])
-      kill_pids('KILL', *pids)
-    end
-    
-    def kill_children_gently(pids)
-      kill_pids('INT', *pids)
-      sleep(SCGI_CONFIG[:killtime])
-      sleep(SCGI_CONFIG[:killtime]) if kill_pids('TERM', *pids)
-      kill_pids('KILL', *pids)
-    end
-
-    def kill_pids(signal, *pids)
-      Process.kill(signal, *pids) rescue nil
-    end
-
-    def parse_options
-      cliconfig = {}
-      opts = GetoptLong.new(
-        [ '--bind', '-b', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--config', '-c', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--directory', '-d', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--environment', '-e', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--fork', '-f', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--killtime', '-k', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--logfile', '-l', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--maxconns', '-m', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--number', '-n', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--port', '-p', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--pidfile', '-P', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--processor', '-r', GetoptLong::REQUIRED_ARGUMENT ],
-        [ '--supervise', '-s', GetoptLong::NO_ARGUMENT]
-      )
-      opts.each do |opt, arg|
-        case opt
-          when '--bind'
-            cliconfig[:bind] = arg
-          when '--config'
-            cliconfig[:config] = arg
-          when '--directory'
-            Dir.chdir(arg)
-          when '--environment'
-            cliconfig[:environment] = arg
-          when '--fork'
-            cliconfig[:fork] = arg.to_i
-          when '--killtime'
-            cliconfig[:killtime] = arg.to_i
-          when '--logfile'
-            cliconfig[:logile] = arg
-          when '--maxconns'
-            cliconfig[:maxconns] = arg.to_i
-          when '--number'
-            cliconfig[:number] = arg.to_i
-          when '--port'
-            cliconfig[:port] = arg.to_i
-          when '--pidfile'
-            cliconfig[:pidfile] = arg
-          when '--processor'
-            cliconfig[:processor] = arg
-          when '--supervise'
-            cliconfig[:supervise] = true
-        end
-      end
-
-      # Configuration Precedence: Command Line > Config File > Default
-      SCGI_CONFIG.merge!(SCGI_DEFAULT_CONFIG)
-      SCGI_CONFIG.merge!(config_file_options(cliconfig[:config] || SCGI_DEFAULT_CONFIG[:config]))
-      SCGI_CONFIG.merge!(cliconfig)
-      SCGI_CONFIG[:cliconfig] = cliconfig
-    end
-
-    def process(command)
-      return process_supervisor(command) if SCGI_CONFIG[:supervise]
-      case command
-        when 'restart'
-          stop
-          start
-        when 'start'
-          start
-        when 'stop'
-          stop
-        else
-          puts usage
-      end
-    end
-
-    def process_supervisor(command)
-      case command
-        when 'restart'
-          supervisor_restart
-        when 'start'
-          supervisor_start
-        when 'stop'
-          supervisor_stop
-        else
-          puts usage
-      end
-    end
-
-    def reload_config
-      SCGI_CONFIG.merge!(config_file_options(SCGI_CONFIG[:config]))
-      SCGI_CONFIG.merge!(SCGI_CONFIG[:cliconfig])
-    end
-
-    def start_child(socket, port)
-      fork do
-        $0 = "scgi-#{SCGI_CONFIG[:processor]} dir:#{Dir.pwd} port:#{port}"
-        get_processor(SCGI_CONFIG[:processor]).new(SCGI_CONFIG).listen(socket)
-      end
-    end
-
-    def start
-      pids = []
-      SCGI_CONFIG[:number].times do |i|
-        socket = TCPServer.new(SCGI_CONFIG[:bind], port = SCGI_CONFIG[:port]+i)
-        SCGI_CONFIG[:fork].times do
-          pids << start_child(socket, port)
-        end
-      end
-      File.open(SCGI_CONFIG[:pidfile], 'wb'){|file| file.print("#{pids.join(' ')}")}
-    end
-
-    def stop
-      if File.file?(SCGI_CONFIG[:pidfile])
-        pids = nil
-        File.open(SCGI_CONFIG[:pidfile], 'rb'){|f| pids = f.read.split.collect{|x| x.to_i if x.to_i > 0}.compact}
-        if pids.length > 0
-          kill_children_gently(pids)
-          File.delete(SCGI_CONFIG[:pidfile])
-        end
-      end
-    end
-
-    def supervisor_exit
-      File.delete(SCGI_CONFIG[:pidfile])
-      exit
-    end
-
-    def supervisor_loop
-      $0 = "scgi-#{SCGI_CONFIG[:processor]} dir:#{Dir.pwd} supervisor"
-      trap("HUP") { reload_config; supervisor_restart_children }
-      trap("TERM") { kill_children_forcefully(SCGI_CONFIG[:pids].values.flatten); supervisor_exit }
-      trap("INT") { kill_children_gently(SCGI_CONFIG[:pids].values.flatten); supervisor_exit }
-      loop{sleep(60)}
-    end
-
-    def supervisor_restart
-      kill_pids("HUP", File.read(SCGI_CONFIG[:pidfile]).to_i)
-    end
-
-    def supervisor_restart_children
-      new_pids = {}
-      SCGI_CONFIG[:pids].each do |port, pids|
-        SCGI_CONFIG[:fork].times do
-          (new_pids[port] ||= []) << start_child(SCGI_CONFIG[:sockets][port], port)
-        end
-        kill_children_gently(pids)
-        pids.each{|pid| Process.detach(pid)}
-      end
-      SCGI_CONFIG[:pids] = new_pids
-    end
-
-    def supervisor_start
-      SCGI_CONFIG[:pids] = {}
-      SCGI_CONFIG[:sockets] = {}
-      SCGI_CONFIG[:number].times do |i| 
-        port = SCGI_CONFIG[:port]+i
-        SCGI_CONFIG[:sockets][port] = TCPServer.new(SCGI_CONFIG[:bind], port)
-        SCGI_CONFIG[:fork].times do
-          (SCGI_CONFIG[:pids][port] ||= []) << start_child(SCGI_CONFIG[:sockets][port], port)
-        end
-      end
-      File.open(SCGI_CONFIG[:pidfile], 'wb'){|file| file.print(fork{supervisor_loop})}
-    end
-
-    def supervisor_stop
-      kill_pids("INT", File.read(SCGI_CONFIG[:pidfile]).to_i)
-    end
-
-    def usage
-      <<-END
-    scgi_ctrl [option value, ...] (restart|start|stop)
-     Options:
-      -b, --bind          IP address to bind to [127.0.0.1]
-      -c, --config        Location of config file [config/scgi.yaml]
-      -d, --directory     Working directory [.]
-      -e, --environment   Environment (for Rails) [production]
-      -f, --fork          Number of listners on each port [1]
-      -k, --killtime      Number of seconds to wait when killing children [2]
-      -l, --logfile       Location of log file [log/scgi.log]
-      -m, --maxconns      Maximum number of concurrent users [2**30-1]
-      -n, --number        Number of ports to bind to [1]
-      -p, --port          Starting port to bind to [9999]
-      -P, --pidfile       Location of pid file [log/scgi.pid]
-      -r, --processor     Type of processor to use [Rails]
-      -s, --supervise     Whether to use a supervisor [No]
-      END
-    end
-  end
-end
-
-SCGI::Starter.new.process(ARGV[0])
-

data/lib/RailsSCGIProcessor.rb

@@ -1,28 +0,0 @@
-#!/usr/local/bin/ruby
-require 'scgi'
-
-# This SCGI::Processor subclass hooks the SCGI request into Ruby on Rails.
-class RailsSCGIProcessor < SCGI::Processor 
-  # Initialzes Rails with the appropriate environment and settings
-  def initialize(settings)
-    ENV["RAILS_ENV"] = settings[:environment] || 'production'
-    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