thin 1.8.2 → 2.0.0.pre

data/lib/thin/server.rb

@@ -1,290 +1,241 @@
+require "eventmachine"
+
+require "thin/system"
+require "thin/listener"
+require "thin/connection"
+require "thin/backends/prefork"
+require "thin/backends/single_process"
+
 module Thin
-  # The utterly famous Thin HTTP server.
-  # It listens for incoming requests through a given +backend+
-  # and forwards all requests to +app+.
-  #
-  # == TCP server
-  # Create a new TCP server bound to <tt>host:port</tt> by specifiying +host+
-  # and +port+ as the first 2 arguments.
+  # The uterly famous Thin server.
   #
-  #   Thin::Server.start('0.0.0.0', 3000, app)
+  # == Listening
+  # Create and start a new server listenting on port 3000 and forwarding all requests to +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. 
+  #   server = Thin::Server.new(app)
+  #   server.listen 3000
+  #   server.start
   #
-  #   Thin::Server.start('/tmp/thin.sock', app)
+  # == Preforking and workers
+  # If fork(2) is available on your system, Thin will try to start workers to process requests.
+  # By default the number of workers will be based on the number of processors on your system.
+  # Configure this using the +worker_processes+ attribute.
+  # However, if fork(2) or if +worker_processes+ if equal to +0+, Thin will run in a single process
+  # with limited features.
   #
-  # == Using a custom backend
-  # You can implement your own way to connect the server to its client by creating your
-  # own Backend class and passing it as the :backend option.
+  # == Single process mode
+  # In this mode, Thin features will be limited:
+  # - no log files
+  # - no signal handling (only exits on INT).
   #
-  #   Thin::Server.start('galaxy://faraway', 1345, app, :backend => Thin::Backends::MyFancyBackend)
+  # This mode is only intended as a fallback for systems with no fork(2) system call.
   #
-  # == Rack application (+app+)
-  # All requests will be processed through +app+, which 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
+  # You can force this mode by setting +worker_processes+ to +0+.
   #
   # == Controlling with signals
-  # * INT and TERM: Force shutdown (see Server#stop!)
-  # * TERM & QUIT calls +stop+ to shutdown gracefully.
-  # * HUP calls +restart+ to ... surprise, restart!
-  # * USR1 reopen log files.
-  # Signals are processed at one second intervals.
-  # Disable signals by passing <tt>:signals => false</tt>.
-  # 
+  # - *WINCH*: Gracefully kill all workers but keep master alive
+  # - *TTIN*: Increase number of workers
+  # - *TTOU*: Decrease number of workers
+  # - *QUIT*: Kill workers and master in a graceful way
+  # - *TERM*, *INT*: Kill workers and master immediately
   class Server
-    include Logging
-    include Daemonizable
-    extend  Forwardable
+    # Application called with the request that produces the response.
+    attr_reader :app
     
-    # Default values
-    DEFAULT_TIMEOUT                        = 30 #sec
-    DEFAULT_HOST                           = '0.0.0.0'
-    DEFAULT_PORT                           = 3000
-    DEFAULT_MAXIMUM_CONNECTIONS            = 1024
-    DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS = 100
-        
-    # Application (Rack adapter) called with the request that produces the response.
-    attr_accessor :app
+    # Set to +true+ to load the app before forking to workers.
+    # Default: false
+    attr_accessor :preload_app
 
     # A tag that will show in the process listing
     attr_accessor :tag
 
-    # Backend handling the connections to the clients.
-    attr_accessor :backend
-    
-    # Maximum number of seconds for incoming data to arrive before the connection
-    # is dropped.
-    def_delegators :backend, :timeout, :timeout=
-    
-    # Maximum number of file or socket descriptors that the server may open.
-    def_delegators :backend, :maximum_connections, :maximum_connections=
-    
-    # Maximum number of connections that can be persistent at the same time.
-    # Most browsers never close the connection so most of the time they are closed
-    # when the timeout occurs. If we don't control the number of persistent connections,
-    # it would be very easy to overflow the server for a DoS attack.
-    def_delegators :backend, :maximum_persistent_connections, :maximum_persistent_connections=
-    
-    # Allow using threads in the backend.
-    def_delegators :backend, :threaded?, :threaded=, :threadpool_size, :threadpool_size=
-    
-    # Allow using SSL in the backend.
-    def_delegators :backend, :ssl?, :ssl=, :ssl_options=
-    
-    # Address and port on which the server is listening for connections.
-    def_delegators :backend, :host, :port
-    
-    # UNIX domain socket on which the server is listening for connections.
-    def_delegator :backend, :socket
-    
-    # Disable the use of epoll under Linux
-    def_delegators :backend, :no_epoll, :no_epoll=
+    # Number of child worker processes.
+    # Setting this to 0 will result in running in a single process with limited features.
+    # Default: number of processors available, or 1 in development, or 0 if +fork+ is not available.
+    attr_accessor :worker_processes
+
+    # Maximum number of file descriptors that the worker may open.
+    # Default: 1024
+    attr_accessor :worker_connections
+
+    # Set to +true+ to call +app+ in a thread.
+    # Default: false
+    attr_accessor :threaded
+
+    # Size of the pool of threads used to call the +app+.
+    # Default: 20
+    attr_accessor :thread_pool_size
+
+    # Workers are killed if they don't check-in under +timeout+ seconds.
+    # Default: 30
+    attr_accessor :timeout
     
-    def initialize(*args, &block)
-      host, port, options = DEFAULT_HOST, DEFAULT_PORT, {}
+    # Maximum number of concurrent requests which can be made over a keep-alive connection.
+    # Default: 100
+    attr_accessor :max_keep_alive_requests
+
+    # Path to the file in which the PID is saved.
+    # Default: ./thin.pid
+    attr_accessor :pid_path
+
+    # Path to the file in which standard output streams are redirected.
+    # Default: none, outputs to stdout
+    attr_accessor :log_path
+
+    # Set to +true+ to use epoll event model.
+    attr_accessor :use_epoll
+
+    # Set to +true+ to use kqueue event model.
+    attr_accessor :use_kqueue
+
+    # Set the backend handling the connections to the clients.
+    attr_writer :backend
+
+    # Listeners currently registered on this server.
+    # @see Thin::Listener
+    attr_accessor :listeners
+
+    # Object that is +call+ed before forking a worker process inside the master process.
+    attr_accessor :before_fork
+
+    # Object that is +call+ed after forking a worker process inside the worker process.
+    attr_accessor :after_fork
+
+    # Creates a new server that will forward requests to the app returned when +call+ing the +app_loader+ block.
+    # When +preload_app+ is set to +true+, +app_loader+ will be called before forking.
+    # When +preload_app+ is set to +false+, +app_loader+ will be called after forking.
+    # +host+, +port+ and +app+ supported for backward compatibility with Rack adapter.
+    def initialize(host=nil, port=nil, app=nil, &app_loader)
+      app_loader = proc { app } if app
+      @app_loader = app_loader || raise(ArgumentError, "app_loader block required")
       
-      # Guess each parameter by its type so they can be
-      # received in any order.
-      args.each do |arg|
-        case arg
-        when 0.class, /^\d+$/ then port    = arg.to_i
-        when String           then host    = arg
-        when Hash             then options = arg
+      # Set defaults
+      @preload_app = false
+      @timeout = 30
+      @pid_path = "./thin.pid"
+      @log_path = nil
+      @worker_connections = 1024
+      @threaded = false
+      @thread_pool_size = 20
+      @max_keep_alive_requests = 100
+      @keep_alive_requests = 0
+      @connections = 0 # Number of active connections
+
+      if System.supports_fork?
+        if ENV["RACK_ENV"] == "development"
+          # Default to one worker in development.
+          @worker_processes = 1
         else
-          @app = arg if arg.respond_to?(:call)
+          # One worker per processor in production.
+          @worker_processes = System.processor_count
         end
+      else
+        # No workers, runs in a single process.
+        @worker_processes = 0
       end
-      
-      # Set tag if needed
-      self.tag = options[:tag]
 
-      # Try to intelligently select which backend to use.
-      @backend = select_backend(host, port, options)
-      
-      load_cgi_multipart_eof_fix
+      @listeners = []
       
-      @backend.server = self
-      
-      # Set defaults
-      @backend.maximum_connections            = DEFAULT_MAXIMUM_CONNECTIONS
-      @backend.maximum_persistent_connections = DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
-      @backend.timeout                        = options[:timeout] || DEFAULT_TIMEOUT
-      
-      # Allow using Rack builder as a block
-      @app = Rack::Builder.new(&block).to_app if block
-      
-      # If in debug mode, wrap in logger adapter
-      @app = Rack::CommonLogger.new(@app) if Logging.debug?
-      
-      @setup_signals = options[:signals] != false
+      listen "#{host}:#{port}" if host && port
     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.
-    def start
-      raise ArgumentError, 'app required' unless @app
-      
-      log_info  "Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
-      log_debug "Debugging ON"
-      trace     "Tracing ON"
-      
-      log_info "Maximum connections set to #{@backend.maximum_connections}"
-      log_info "Listening on #{@backend}, CTRL+C to stop"
 
-      @backend.start { setup_signals if @setup_signals }
-    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 waits for all current connections to finish.
-    # Calling twice is the equivalent of calling <tt>stop!</tt>.
-    def stop
-      if running?
-        @backend.stop
-        unless @backend.empty?
-          log_info "Waiting for #{@backend.size} connection(s) to finish, "\
-                   "can take up to #{timeout} sec, CTRL+C to stop now"
+    # Backend handling connections to the clients.
+    def backend
+      @backend ||= begin
+        if prefork?
+          Backends::Prefork.new(self)
+        else
+          Backends::SingleProcess.new(self)
         end
-      else
-        stop!
       end
     end
     
-    # == 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!
-      if @backend.started_reactor?
-        log_info "Stopping ..."
-      else
-        log_info "Stopping Thin ..."
-        log_info "Thin was started inside an existing EventMachine.run block."
-        log_info "Call `EventMachine.stop` to stop the reactor and quit the process."
-      end
-
-      @backend.stop!
-    end
-    
-    # == Reopen log file.
-    # Reopen the log file and redirect STDOUT and STDERR to it.
-    def reopen_log
-      return unless log_file
-      file = File.expand_path(log_file)
-      log_info "Reopening log file: #{file}"
-      Daemonize.redirect_io(file)
+    # Listen for incoming connections on +address+.
+    # @example
+    #   listen 3000 # port number
+    #   listen "0.0.0.0:8008", :backlog => 80
+    #   listen "[::]:8008", :ipv6_only => true
+    #   listen "/tmp/thin.sock"
+    # @param address [String, Integer] address to listen on. Can be a port number of host:port.
+    # @option options [Boolean] :tcp_no_delay (true) Disables the Nagle algorithm for send coalescing.
+    # @option options [Boolean] :ipv6_only (false) do not listen on IPv4 interface.
+    # @option options [Integer] :backlog (1024) Maximum number of clients in the listening backlog.
+    def listen(address, options={})
+      @listeners << Listener.new(address, options)
     end
-    
-    # == Configure the server
-    # The process might need to have superuser privilege to configure
-    # server with optimal options.
-    def config
-      @backend.config
-    end
-    
-    # Name of the server and type of backend used.
-    # This is also the name of the process in which Thin is running as a daemon.
-    def name
-      "thin server (#{@backend})" + (tag ? " [#{tag}]" : "")
-    end
-    alias :to_s :name
-    
-    # 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?
-      @backend.running?
-    end
-    
-    protected
-      def setup_signals
-        # Queue up signals so they are processed in non-trap context
-        # using a EM timer.
-        @signal_queue ||= []
 
-        %w( INT TERM ).each do |signal|
-          trap(signal) { @signal_queue.push signal }
-        end
-        # *nix only signals
-        %w( QUIT HUP USR1 ).each do |signal|
-          trap(signal) { @signal_queue.push signal }
-        end unless Thin.win?
+    # Starts the server and open a listening socket for each +listeners+.
+    # @param daemonize Daemonize the process after starting.
+    def start(daemonize=false)
+      puts "Starting #{to_s} ..."
 
-        # Signals are processed at one second intervals.
-        @signal_timer ||= EM.add_periodic_timer(1) { handle_signals }
-      end
+      # Configure EventMachine
+      EM.epoll = @use_epoll unless @use_epoll.nil?
+      EM.kqueue = @use_kqueue unless @use_kqueue.nil?
+      @worker_connections = EM.set_descriptor_table_size(@worker_connections)
+      EM.threadpool_size = @thread_pool_size
 
-      def handle_signals
-        case @signal_queue.shift
-        when 'INT'
-          stop!
-        when 'TERM', 'QUIT'
-          stop
-        when 'HUP'
-          restart
-        when 'USR1'
-          reopen_log
-        end
-        EM.next_tick { handle_signals } unless @signal_queue.empty?
-      end
-      
-      def select_backend(host, port, options)
-        case
-        when options.has_key?(:backend)
-          raise ArgumentError, ":backend must be a class" unless options[:backend].is_a?(Class)
-          options[:backend].new(host, port, options)
-        when options.has_key?(:swiftiply)
-          Backends::SwiftiplyClient.new(host, port, options)
-        when host.include?('/')
-          Backends::UnixServer.new(host)
-        else
-          Backends::TcpServer.new(host, port)
-        end
+      # Preload the app in the master process.
+      @app = @app_loader.call if @preload_app
+
+      @listeners.each do |listener|
+        puts "Listening with #{listener}"
+        listener.listen
       end
-      
-      # Taken from Mongrel cgi_multipart_eof_fix
-      # Ruby 1.8.5 has a security bug in cgi.rb, we need to patch it.
-      def load_cgi_multipart_eof_fix
-        version = RUBY_VERSION.split('.').map { |i| i.to_i }
-        
-        if version[0] <= 1 && version[1] <= 8 && version[2] <= 5 && RUBY_PLATFORM !~ /java/
-          begin
-            require 'cgi_multipart_eof_fix'
-          rescue LoadError
-            log_error "Ruby 1.8.5 is not secure please install cgi_multipart_eof_fix:"
-            log_error "gem install cgi_multipart_eof_fix"
+      puts "CTRL+C to stop"
+
+      backend.start(daemonize) do
+        # Load the app in the worker process if it was not preloaded.
+        @app = @app_loader.call unless @preload_app
+
+        @listeners.each do |listener|
+          EM.attach_server(listener.socket, Connection) do |connection|
+            connection.comm_inactivity_timeout = @timeout
+            connection.server = self
+            connection.listener = listener
+            
+            # We control the number of keep-alive connections to prevent easy DDoS attacks.
+            if @keep_alive_requests < @max_keep_alive_requests
+              connection.can_keep_alive = true
+              @keep_alive_requests += 1
+            else
+              connection.can_keep_alive = false
+            end
+            
+            @connections += 1
+            
+            # Decrement counters on close
+            connection.on_close do
+              @keep_alive_requests -= 1 if connection.can_keep_alive
+              @connections -= 1
+            end
           end
         end
       end
+    rescue
+      stop
+      raise
+    end
+
+    # Stops the server and close all listeners.
+    def stop
+      puts "Stopping ..."
+      @listeners.each { |listener| listener.close }
+    end
+    alias :shutdown :stop
+
+    # Returns +true+ if the server will fork workers or +false+ if it will run in a single process.
+    def prefork?
+      @worker_processes > 0
+    end
+    
+    def threaded?
+      @threaded
+    end
+
+    # Procline of the process when the server is running.
+    def to_s
+      "Thin" + (@tag ? " [#{@tag}]" : "")
+    end
   end
 end

data/lib/thin/system.rb

@@ -0,0 +1,49 @@
+module Thin
+  module System
+    def self.win?
+      RUBY_PLATFORM =~ /mswin|mingw/
+    end
+
+    def self.java?
+      RUBY_PLATFORM =~ /java/
+    end
+
+    def self.linux?
+      RUBY_PLATFORM =~ /linux/
+    end
+
+    def self.ruby_18?
+      RUBY_VERSION =~ /^1\.8/
+    end
+
+    # Source: https://github.com/grosser/parallel/blob/master/lib/parallel.rb#L65-84
+    def self.processor_count
+      architecture = RbConfig::CONFIG['host_os']
+      case architecture = RbConfig::CONFIG['host_os']
+      when /darwin9/
+        `hwprefs cpu_count`.to_i
+      when /darwin/
+        (`which hwprefs` != '' ? `hwprefs thread_count` : `sysctl -n hw.ncpu`).to_i
+      when /linux/
+        `grep -c processor /proc/cpuinfo`.to_i
+      when /freebsd/
+        `sysctl -n hw.ncpu`.to_i
+      when /mswin|mingw/
+        require 'win32ole'
+        wmi = WIN32OLE.connect("winmgmts://")
+        cpu = wmi.ExecQuery("select NumberOfLogicalProcessors from Win32_Processor")
+        cpu.to_enum.first.NumberOfLogicalProcessors
+      else
+        warn "Unknown architecture ( #{architecture} ) assuming one processor."
+        1
+      end
+    end
+
+    def self.supports_fork?
+      fork { exit }
+      true
+    rescue NotImplementedError
+      false
+    end
+  end
+end

data/lib/thin/version.rb

@@ -1,32 +1,17 @@
 module Thin
-  # Raised when a feature is not supported on the
-  # current platform.
-  class PlatformNotSupported < RuntimeError; end
-  
-  module VERSION #:nodoc:
-    MAJOR    = 1
-    MINOR    = 8
-    TINY     = 2
-    
-    STRING   = [MAJOR, MINOR, TINY].join('.')
-    
-    CODENAME = "Ruby Razor".freeze
-    
-    RACK     = [1, 0].freeze # Rack protocol version
+  module VERSION
+    MAJOR    = 2
+    MINOR    = 0
+    TINY     = 0
+    PRE      = "pre"
+
+    STRING   = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+
+    CODENAME = "The Wire Burner".freeze
+
+    RACK     = [1, 1].freeze # Rack protocol version
   end
-  
+
   NAME    = 'thin'.freeze
   SERVER  = "#{NAME} #{VERSION::STRING} codename #{VERSION::CODENAME}".freeze
-  
-  def self.win?
-    RUBY_PLATFORM =~ /mswin|mingw/
-  end
-  
-  def self.linux?
-    RUBY_PLATFORM =~ /linux/
-  end
-  
-  def self.ruby_18?
-    RUBY_VERSION =~ /^1\.8/
-  end
 end

data/lib/thin.rb

@@ -1,45 +1,3 @@
-require 'fileutils'
-require 'timeout'
-require 'stringio'
-require 'time'
-require 'forwardable'
-require 'openssl'
-require 'eventmachine'
-require 'rack'
-
-module Thin
-  autoload :Command,            "thin/command"
-  autoload :Connection,         "thin/connection"
-  autoload :Daemonizable,       "thin/daemonizing"
-  autoload :Logging,            "thin/logging"
-  autoload :Headers,            "thin/headers"
-  autoload :Request,            "thin/request"
-  autoload :Response,           "thin/response"
-  autoload :Runner,             "thin/runner"
-  autoload :Server,             "thin/server"
-  autoload :Stats,              "thin/stats"
-  
-  module Backends
-    autoload :Base,             "thin/backends/base"
-    autoload :SwiftiplyClient,  "thin/backends/swiftiply_client"
-    autoload :TcpServer,        "thin/backends/tcp_server"
-    autoload :UnixServer,       "thin/backends/unix_server"
-  end
-  
-  module Controllers
-    autoload :Cluster,          "thin/controllers/cluster"
-    autoload :Controller,       "thin/controllers/controller"
-    autoload :Service,          "thin/controllers/service"
-  end
-end
-
 require "thin/version"
-require "thin/statuses"
-require "rack/adapter/loader"
-require "thin_parser"
-
-module Rack
-  module Adapter
-    autoload :Rails, "rack/adapter/rails"
-  end
-end
+require "thin/system"
+require "thin/server"

data/man/index.txt

@@ -0,0 +1,3 @@
+# manuals
+thin(1)         thin.1.ronn
+thin-conf(5)    thin-conf.5.ronn