thin 0.6.2-x86-mswin32-60 → 0.6.3-x86-mswin32-60

data/lib/thin/controllers/service.sh.erb

@@ -0,0 +1,39 @@
+#!/bin/sh
+### BEGIN INIT INFO
+# Provides:          thin
+# Required-Start:    $local_fs $remote_fs
+# Required-Stop:     $local_fs $remote_fs
+# Default-Start:     2 3 4 5
+# Default-Stop:      S 0 1 6
+# Short-Description: thin initscript
+# Description:       thin
+### END INIT INFO
+
+# Original author: Forrest Robertson
+
+# Do NOT "set -e"
+
+DAEMON=<%= Command.script %>
+SCRIPT_NAME=<%= INITD_PATH %>
+CONFIG_PATH=<%= config_files_path %>
+
+# Exit if the package is not installed
+[ -x "$DAEMON" ] || exit 0
+
+case "$1" in
+  start)
+	$DAEMON start --all $CONFIG_PATH
+	;;
+  stop)
+	$DAEMON stop --all $CONFIG_PATH
+	;;
+  restart)
+	$DAEMON restart --all $CONFIG_PATH
+	;;
+  *)
+	echo "Usage: $SCRIPT_NAME {start|stop|restart}" >&2
+	exit 3
+	;;
+esac
+
+:

data/lib/thin/daemonizing.rb

@@ -12,6 +12,9 @@ module Process
 end
 
 module Thin
+  # Raised when the pid file already exist starting as a daemon.
+  class PidFileExist < RuntimeError; end
+  
   # Module included in classes that can be turned into a daemon.
   # Handle stuff like:
   # * storing the PID in a file
@@ -31,15 +34,17 @@ module Thin
     
     # Turns the current script into a daemon process that detaches from the console.
     def daemonize
-      raise PlatformNotSupported, 'Daemonizing not supported on Windows' if Thin.win?
-      raise ArgumentError, 'You must specify a pid_file to deamonize' unless @pid_file
+      raise PlatformNotSupported, 'Daemonizing not supported on Windows'     if Thin.win?
+      raise ArgumentError,        'You must specify a pid_file to daemonize' unless @pid_file
+      raise PidFileExist,         "#{@pid_file} already exist, seems like it's already running. " +
+                                  "Stop the process or delete #{@pid_file}." if File.exist?(@pid_file)
       
       pwd = Dir.pwd # Current directory is changed during daemonization, so store it
       
-      Daemonize.daemonize(File.expand_path(@log_file))
+      Daemonize.daemonize(File.expand_path(@log_file), name)
       
       Dir.chdir(pwd)
-            
+      
       write_pid_file
       
       trap('HUP') { restart }

data/lib/thin/headers.rb

@@ -7,7 +7,7 @@ module Thin
     
     def initialize
       @sent = {}
-      @out = ''
+      @out = []
     end
     
     # Add <tt>key: value</tt> pair to the headers.
@@ -21,7 +21,7 @@ module Thin
     end
     
     def to_s
-      @out
+      @out.join
     end
   end
 end

data/lib/thin/runner.rb

@@ -0,0 +1,166 @@
+require 'optparse'
+require 'yaml'
+
+module Thin
+  # CLI runner.
+  # Parse options and send command to the correct Controller.
+  class Runner
+    COMMANDS            = %w(start stop restart config)
+    LINUX_ONLY_COMMANDS = %w(install)
+    
+    # Commands that wont load options from the config file
+    CONFIGLESS_COMMANDS = %w(config install)
+    
+    # Parsed options
+    attr_accessor :options
+    
+    # Name of the command to be runned.
+    attr_accessor :command
+    
+    # Arguments to be passed to the command.
+    attr_accessor :arguments
+    
+    # Return all available commands
+    def self.commands
+      commands  = COMMANDS
+      commands += LINUX_ONLY_COMMANDS if Thin.linux?
+      commands
+    end
+    
+    def initialize(argv)
+      @argv = argv
+      
+      # Default options values
+      @options = {
+        :chdir       => Dir.pwd,
+        :environment => 'development',
+        :address     => '0.0.0.0',
+        :port        => 3000,
+        :timeout     => 60,
+        :log         => 'log/thin.log',
+        :pid         => 'tmp/pids/thin.pid'
+      }
+      
+      parse!
+    end
+    
+    def parser
+      # NOTE: If you add an option here make sure the key in the +options+ hash is the
+      # same as the name of the command line option.
+      # +option+ keys are used to build the command line to launch other processes,
+      # see <tt>lib/thin/command.rb</tt>.
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: thin [options] #{self.class.commands.join('|')}"
+
+        opts.separator ""
+        opts.separator "Server options:"
+
+        opts.on("-a", "--address HOST", "bind to HOST address " +
+                                        "(default: #{@options[:address]})")             { |host| @options[:address] = host }
+        opts.on("-p", "--port PORT", "use PORT (default: #{@options[:port]})")          { |port| @options[:port] = port.to_i }
+        opts.on("-S", "--socket FILE", "bind to unix domain socket")                    { |file| @options[:socket] = file }
+        opts.on("-e", "--environment ENV", "Rails environment " +                       
+                                           "(default: #{@options[:environment]})")      { |env| @options[:environment] = env }
+        opts.on("-c", "--chdir DIR", "Change to dir before starting")                   { |dir| @options[:chdir] = File.expand_path(dir) }
+        opts.on("-t", "--timeout SEC", "Request or command timeout in sec " +            
+                                       "(default: #{@options[:timeout]})")              { |sec| @options[:timeout] = sec.to_i }
+        opts.on("-r", "--rackup FILE", "Load a Rack config file instead of " +
+                                       "the Rails adapter")                             { |file| @options[:rackup] = file }
+        opts.on(      "--prefix PATH", "Mount the app under PATH (start with /)")       { |path| @options[:prefix] = path }
+        opts.on(      "--stats PATH", "Mount the Stats adapter under PATH")             { |path| @options[:stats] = path }
+        
+        unless Thin.win? # Daemonizing not supported on Windows
+          opts.separator ""
+          opts.separator "Daemon options:"
+                                                                                      
+          opts.on("-d", "--daemonize", "Run daemonized in the background")              { @options[:daemonize] = true }
+          opts.on("-l", "--log FILE", "File to redirect output " +                      
+                                      "(default: #{@options[:log]})")                   { |file| @options[:log] = file }
+          opts.on("-P", "--pid FILE", "File to store PID " +                            
+                                      "(default: #{@options[:pid]})")                   { |file| @options[:pid] = file }
+          opts.on("-u", "--user NAME", "User to run daemon as (use with -g)")           { |user| @options[:user] = user }
+          opts.on("-g", "--group NAME", "Group to run daemon as (use with -u)")         { |group| @options[:group] = group }
+                                                                                      
+          opts.separator ""
+          opts.separator "Cluster options:"                                             
+                                                                                      
+          opts.on("-s", "--servers NUM", "Number of servers to start")                  { |num| @options[:servers] = num.to_i }
+          opts.on("-o", "--only NUM", "Send command to only one server of the cluster") { |only| @options[:only] = only }
+          opts.on("-C", "--config FILE", "Load options from config file")               { |file| @options[:config] = file }
+          opts.on(      "--all [DIR]", "Send command to each config files in DIR")      { |dir| @options[:all] = dir } if Thin.linux?
+        end
+        
+        opts.separator ""
+        opts.separator "Common options:"
+
+        opts.on_tail("-D", "--debug", "Set debbuging on")       { $DEBUG = true }
+        opts.on_tail("-V", "--trace", "Set tracing on")         { $TRACE = true }
+        opts.on_tail("-h", "--help", "Show this message")       { puts opts; exit }
+        opts.on_tail('-v', '--version', "Show version")         { puts Thin::SERVER; exit }
+      end
+    end
+    
+    # Parse the options.
+    def parse!
+      parser.parse! @argv
+      @command   = @argv.shift
+      @arguments = @argv
+    end
+        
+    # Parse the current shell arguments and run the command.
+    # Exits on error.
+    def run!
+      if self.class.commands.include?(@command)
+        run_command
+      elsif @command.nil?
+        puts "Command required"
+        puts @parser
+        exit 1  
+      else
+        abort "Invalid command: #{@command}"
+      end
+    end
+    
+    # Send the command to the controller: single instance or cluster.
+    def run_command
+      load_options_from_config_file! unless CONFIGLESS_COMMANDS.include?(@command)
+      
+      # PROGRAM_NAME is relative to the current directory, so make sure
+      # we store and expand it before changing directory.
+      Command.script = File.expand_path($PROGRAM_NAME)
+      
+      # Change the current directory ASAP so that all relative paths are
+      # relative to this one.
+      Dir.chdir(@options[:chdir]) unless CONFIGLESS_COMMANDS.include?(@command)
+      
+      controller = case
+      when cluster? then Controllers::Cluster.new(@options)
+      when service? then Controllers::Service.new(@options)
+      else               Controllers::Controller.new(@options)
+      end
+      
+      if controller.respond_to?(@command)
+        controller.send(@command, *@arguments)
+      else
+        abort "Invalid options for command: #{@command}"
+      end
+    end
+    
+    # +true+ if we're controlling a cluster.
+    def cluster?
+      @options[:only] || @options[:servers]
+    end
+    
+    # +true+ if we're acting a as system service.
+    def service?
+      @options.has_key?(:all) || @command == 'install'
+    end
+    
+    private
+      def load_options_from_config_file!
+        if file = @options.delete(:config)
+          YAML.load_file(file).each { |key, value| @options[key.to_sym] = value }
+        end
+      end
+  end
+end

data/lib/thin/server.rb

@@ -1,68 +1,106 @@
 module Thin
-  # The Thin HTTP server used to served request.
-  # It listen for incoming request on a given port
+  # The uterly famous Thin HTTP server.
+  # It listen for incoming request through a given connector
   # and forward all request to +app+.
   #
-  # Based on HTTP 1.1 protocol specs:
-  # http://www.w3.org/Protocols/rfc2616/rfc2616.html
+  # == TCP server
+  # Create a new TCP server on bound to <tt>host:port</tt> by specifiying +host+
+  # and +port+ as the first 2 arguments.
+  #
+  #   Thin::Server.start('0.0.0.0', 3000, app)
+  #
+  # == UNIX domain server
+  # Create a new UNIX domain socket bound to +socket+ file by specifiying a filename
+  # as the first argument. Eg.: /tmp/thin.sock. If the first argument contains a <tt>/</tt>
+  # it will be assumed to be a UNIX socket. 
+  #
+  #   Thin::Server.start('/tmp/thin.sock', nil, app)
+  #
+  # == Using a custom connector
+  # You can implement your own way to connect the server to its client by creating your
+  # own Thin::Connectors::Connector class and pass it as the first argument.
+  #
+  #   connector = Thin::Connectors::MyFancyConnector.new('galaxy://faraway:1345')
+  #   Thin::Server.start(connector, nil, app)
+  #
+  # == Rack application (+app+)
+  # All requests will be processed through +app+ that must be a valid Rack adapter.
+  # A valid Rack adapter (application) must respond to <tt>call(env#Hash)</tt> and
+  # return an array of <tt>[status, headers, body]</tt>.
+  #
+  # == Building an app in place
+  # If a block is passed, a <tt>Rack::Builder</tt> instance
+  # will be passed to build the +app+. So you can do cool stuff like this:
+  # 
+  #   Thin::Server.start('0.0.0.0', 3000) do
+  #     use Rack::CommonLogger
+  #     use Rack::ShowExceptions
+  #     map "/lobster" do
+  #       use Rack::Lint
+  #       run Rack::Lobster.new
+  #     end
+  #   end
+  #
   class Server
     include Logging
     include Daemonizable
+    extend  Forwardable
+        
+    # Application (Rack adapter) called with the request that produces the response.
+    attr_accessor :app
     
-    # Address and port on which the server is listening for connections.
-    attr_accessor :port, :host
+    # Connector handling the connections to the clients.
+    attr_accessor :connector
     
-    # UNIX domain socket on which the server is listening for connections.
-    attr_accessor :socket
+    # Maximum number of seconds for incoming data to arrive before the connection
+    # is dropped.
+    def_delegators :@connector, :timeout, :timeout=
     
-    # App called with the request that produces the response.
-    attr_accessor :app
+    # Address and port on which the server is listening for connections.
+    def_delegators :@connector, :host, :port
     
-    # Maximum time for incoming data to arrive
-    attr_accessor :timeout
+    # UNIX domain socket on which the server is listening for connections.
+    def_delegator :@connector, :socket
     
-    # Creates a new server bound to <tt>host:port</tt>
-    # or to +socket+ that will pass request to +app+.
-    # If +host_or_socket+ contains a <tt>/</tt> it is assumed
-    # to be a UNIX domain socket filename.
-    # If a block is passed, a <tt>Rack::Builder</tt> instance
-    # will be passed to build the +app+.
-    # 
-    #   Server.new '0.0.0.0', 3000 do
-    #     use Rack::CommonLogger
-    #     use Rack::ShowExceptions
-    #     map "/lobster" do
-    #       use Rack::Lint
-    #       run Rack::Lobster.new
-    #     end
-    #   end.start
-    #
-    def initialize(host_or_socket, port=3000, app=nil, &block)
-      if host_or_socket.include?('/')
-        @socket    = host_or_socket
-      else      
-        @host      = host_or_socket
-        @port      = port.to_i
-      end       
-      @app         = app
-      @timeout     = 60 # sec
-      @connections = []
+    def initialize(host_or_socket_or_connector, port=3000, app=nil, &block)
+      # Try to intelligently select which connector to use.
+      @connector = case
+      when host_or_socket_or_connector.is_a?(Connectors::Connector)
+        host_or_socket_or_connector
+      when host_or_socket_or_connector.include?('/')
+        Connectors::UnixServer.new(host_or_socket_or_connector)
+      else
+        Connectors::TcpServer.new(host_or_socket_or_connector, port.to_i)
+      end
+
+      @connector.server = self
+      @app              = app
       
+      # Allow using Rack builder as a block
       @app = Rack::Builder.new(&block).to_app if block
     end
     
+    # Lil' shortcut to turn this:
+    # 
+    #   Server.new(...).start
+    # 
+    # into this:
+    # 
+    #   Server.start(...)
+    # 
     def self.start(*args, &block)
       new(*args, &block).start!
     end
     
-    # Start the server and listen for connections
+    # Start the server and listen for connections.
+    # Also register signals:
+    # * INT calls +stop+ to shutdown gracefully.
+    # * TERM calls <tt>stop!</tt> to force shutdown.
     def start
       raise ArgumentError, 'app required' unless @app
       
       trap('INT')  { stop }
       trap('TERM') { stop! }
-      
-      at_exit { remove_socket_file } if @socket
             
       # See http://rubyeventmachine.com/pub/rdoc/files/EPOLL.html
       EventMachine.epoll
@@ -70,83 +108,65 @@ module Thin
       log   ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
       trace ">> Tracing ON"
       
-      EventMachine.run { @signature = start_server }
+      log ">> Listening on #{@connector}, CTRL+C to stop"
+      @running = true
+      EventMachine.run { @connector.connect }
     end
     alias :start! :start
     
+    # == Gracefull shutdown
     # Stops the server after processing all current connections.
+    # As soon as this method is called, the server stops accepting
+    # new requests and wait for all current connections to finish.
     # Calling twice is the equivalent of calling <tt>stop!</tt>.
     def stop
-      if @stopping
-        stop!
-      else
-        @stopping = true
+      if @running
+        @running = false
         
         # Do not accept anymore connection
-        EventMachine.stop_server(@signature)
+        @connector.disconnect
         
         unless wait_for_connections_and_stop
           # Still some connections running, schedule a check later
           EventMachine.add_periodic_timer(1) { wait_for_connections_and_stop }
         end
+      else
+        stop!
       end
     end
     
-    # Stops the server closing all current connections
+    # == Force shutdown
+    # Stops the server closing all current connections right away.
+    # This doesn't wait for connection to finish their work and send data.
+    # All current requests will be dropped.
     def stop!
       log ">> Stopping ..."
 
-      @connections.each { |connection| connection.close_connection }
+      @connector.close_connections
       EventMachine.stop
 
-      remove_socket_file
+      @connector.close
     end
+        
+    def name
+      "thin server (#{@connector})"
+    end
+    alias :to_s :name
     
-    def connection_finished(connection)
-      @connections.delete(connection)
+    # Return +true+ if the server is running and ready to receive requests.
+    # Note that the server might still be running and return +false+ when
+    # shuting down and waiting for active connections to complete.
+    def running?
+      @running
     end
     
-    protected
-      def start_server
-        if @socket
-          start_server_on_socket
-        else
-          start_server_on_host
-        end
-      end
-      
-      def start_server_on_host
-        log ">> Listening on #{@host}:#{@port}, CTRL+C to stop"
-        EventMachine.start_server(@host, @port, Connection, &method(:initialize_connection))
-      end
-      
-      def start_server_on_socket
-        raise PlatformNotSupported, 'UNIX sockets not available on Windows' if Thin.win?
-        
-        log ">> Listening on #{@socket}, CTRL+C to stop"
-        EventMachine.start_unix_domain_server(@socket, Connection, &method(:initialize_connection))
-      end
-      
-      def initialize_connection(connection)
-        connection.server                  = self
-        connection.comm_inactivity_timeout = @timeout
-        connection.app                     = @app
-        connection.silent                  = @silent
-        connection.unix_socket             = !@socket.nil?
-
-        @connections << connection
-      end
-      
-      def remove_socket_file
-        File.delete(@socket) if @socket && File.exist?(@socket)
-      end
-      
+    protected            
       def wait_for_connections_and_stop
-        if @connections.empty?
+        if @connector.empty?
           stop!
           true
         else
-          log ">> Waiting for #{@connections.size} connection(s) to finish, CTRL+C to force stop"
+          log ">> Waiting for #{@connector.size} connection(s) to finish, CTRL+C to force stop"
           false
         end
       end