thin 0.7.1 → 0.8.0

data/lib/rack/adapter/rails.rb

@@ -3,13 +3,18 @@ require 'cgi'
 # Adapter to run a Rails app with any supported Rack handler.
 # By default it will try to load the Rails application in the
 # current directory in the development environment.
+#
 # Options:
 #  root: Root directory of the Rails app
-#  env: Rails environment to run in (development, production or test)
+#  environment: Rails environment to run in (development [default], production or test)
+#  prefix: Set the relative URL root.
+#
 # Based on http://fuzed.rubyforge.org/ Rails adapter
 module Rack
   module Adapter 
     class Rails
+      FILE_METHODS = %w(GET HEAD).freeze
+      
       def initialize(options={})
         @root   = options[:root]         || Dir.pwd
         @env    = options[:environment]  || 'development'
@@ -53,16 +58,20 @@ module Rack
       
       def call(env)
         path        = env['PATH_INFO'].chomp('/')
+        method      = env['REQUEST_METHOD']
         cached_path = (path.empty? ? 'index' : path) + ActionController::Base.page_cache_extension
         
-        if file_exist?(path)              # Serve the file if it's there
-          serve_file(env)
-        elsif file_exist?(cached_path)    # Serve the page cache if it's there
-          env['PATH_INFO'] = cached_path
-          serve_file(env)
-        else                              # No static file, let Rails handle it
-          serve_rails(env)
+        if FILE_METHODS.include?(method)
+          if file_exist?(path)              # Serve the file if it's there
+            return serve_file(env)
+          elsif file_exist?(cached_path)    # Serve the page cache if it's there
+            env['PATH_INFO'] = cached_path
+            return serve_file(env)
+          end
         end
+        
+        # No static file, let Rails handle it
+        serve_rails(env)
       end
     
       protected

data/lib/thin.rb

@@ -37,6 +37,7 @@ module Thin
 end
 
 require 'rack'
+require 'rack/adapter/loader'
 
 module Rack
   module Handler

data/lib/thin/backends/base.rb

@@ -4,6 +4,12 @@ module Thin
     # * connection/disconnection to the server
     # * initialization of the connections
     # * manitoring of the active connections.
+    #
+    # == Implementing your own backend
+    # You can create your own minimal backend by inheriting this class and
+    # defining the +connect+ and +disconnect+ method.
+    # If your backend is not based on EventMachine you also need to redefine
+    # the +start+, +stop+, <tt>stop!</tt> and +config+ methods.
     class Base
       # Server serving the connections throught the backend
       attr_accessor :server
@@ -17,6 +23,10 @@ module Thin
       # Maximum number of connections that can be persistent
       attr_accessor :maximum_persistent_connections
       
+      # Allow using threads in the backend.
+      attr_writer :threaded
+      def threaded?; @threaded end
+      
       # Number of persistent connections currently opened
       attr_accessor :persistent_connection_count
       
@@ -28,6 +38,7 @@ module Thin
         @maximum_persistent_connections = Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
       end
       
+      # Start the backend and connect it.
       def start
         @stopping = false
         
@@ -37,6 +48,7 @@ module Thin
         end
       end
       
+      # Stop of the backend from accepting new connections.
       def stop
         @running  = false
         @stopping = true
@@ -46,6 +58,7 @@ module Thin
         stop! if @connections.empty?
       end
       
+      # Force stop of the backend NOW, too bad for the current connections.
       def stop!
         @running  = false
         @stopping = false
@@ -55,6 +68,8 @@ module Thin
         close
       end
       
+      # Configure the backend. This method will be called before droping superuser privileges,
+      # so you can do crazy stuff that require godlike powers here.
       def config
         # See http://rubyeventmachine.com/pub/rdoc/files/EPOLL.html
         EventMachine.epoll
@@ -69,6 +84,7 @@ module Thin
       def close
       end
       
+      # Returns +true+ if the backend is connected and running.
       def running?
         @running
       end
@@ -98,6 +114,7 @@ module Thin
           connection.backend                 = self
           connection.app                     = @server.app
           connection.comm_inactivity_timeout = @timeout
+          connection.threaded                = @threaded
 
           # We control the number of persistent connections by keeping
           # a count of the total one allowed yet.

data/lib/thin/backends/swiftiply_client.rb

@@ -1,14 +1,15 @@
 module Thin
   module Backends
+    # Backend to act as a Swiftiply client (http://swiftiply.swiftcore.org).
     class SwiftiplyClient < Base
       attr_accessor :key
       
       attr_accessor :host, :port
       
-      def initialize(host, port, key=nil)
+      def initialize(host, port, options={})
         @host = host
         @port = port.to_i
-        @key  = key || ''
+        @key  = options[:swiftiply].to_s
         super()
       end
 

data/lib/thin/backends/tcp_server.rb

@@ -1,6 +1,6 @@
 module Thin
   module Backends
-    # Connectior to act as a TCP socket server.
+    # Backend to act as a TCP socket server.
     class TcpServer < Base
       # Address and port on which the server is listening for connections.
       attr_accessor :host, :port

data/lib/thin/connection.rb

@@ -7,7 +7,7 @@ module Thin
   class Connection < EventMachine::Connection
     include Logging
     
-    # Rack application served by this connection.
+    # Rack application (adapter) served by this connection.
     attr_accessor :app
     
     # Backend to the server
@@ -16,13 +16,19 @@ module Thin
     # Current request served by the connection
     attr_accessor :request
     
-    # Next response sent through connection
+    # Next response sent through the connection
     attr_accessor :response
     
+    # Calling the application in a threaded allowing
+    # concurrent processing of requests.
+    attr_accessor :threaded
+    
     # Get the connection ready to process a request.
     def post_init
       @request  = Request.new
       @response = Response.new
+      
+      @request.threaded = threaded      
     end
     
     # Called when data is received from the client.
@@ -36,13 +42,31 @@ module Thin
     end
     
     # Called when all data was received and the request
-    # is ready to being processed.
+    # is ready to be processed.
     def process
+      if @threaded
+        EventMachine.defer(method(:pre_process), method(:post_process))
+      else
+        post_process(pre_process)
+      end
+    end
+    
+    def pre_process
       # Add client info to the request env
       @request.remote_address = remote_address
       
-      # Process the request
-      @response.status, @response.headers, @response.body = @app.call(@request.env)
+      # Process the request calling the Rack adapter
+      @app.call(@request.env)
+    rescue
+      handle_error
+      terminate_request
+      nil # Signal to post_process that the request could not be processed
+    end
+    
+    def post_process(result)
+      return unless result
+      
+      @response.status, @response.headers, @response.body = result
       
       # Make the response persistent if requested by the client
       @response.persistent! if @request.persistent?
@@ -57,10 +81,18 @@ module Thin
       close_connection_after_writing unless persistent?
       
     rescue
+      handle_error
+    ensure
+      terminate_request
+    end
+    
+    def handle_error
       log "!! Unexpected error while processing request: #{$!.message}"
       log_error
       close_connection rescue nil
-    ensure
+    end
+    
+    def terminate_request
       @request.close  rescue nil
       @response.close rescue nil
       

data/lib/thin/controllers/controller.rb

@@ -1,15 +1,23 @@
 require 'yaml'
 
 module Thin
-  module Controllers
-    # Raised when a mandatory option is missing to run a command.
-    class OptionRequired < RuntimeError
-      def initialize(option)
-        super("#{option} option required")
-      end
+  # Error raised that will abort the process and print not backtrace.
+  class RunnerError < RuntimeError; end
+  
+  # Raised when a mandatory option is missing to run a command.
+  class OptionRequired < RunnerError
+    def initialize(option)
+      super("#{option} option required")
     end
+  end
   
-    # Controls a Thin server.
+  # Raised when an option is not valid.
+  class InvalidOption < RunnerError; end
+  
+  # Build and control Thin servers.
+  # Hey Controller pattern is not only for web apps yo!
+  module Controllers  
+    # Controls one Thin server.
     # Allow to start, stop, restart and configure a single thin server.
     class Controller
       include Logging
@@ -27,35 +35,38 @@ module Thin
       end
     
       def start
+        # Select proper backend
         server = case
+        when @options.has_key?(:backend)
+          Server.new(@options[:address], @options[:port], :backend => eval(@options[:backend], TOPLEVEL_BINDING))
         when @options.has_key?(:socket)
           Server.new(@options[:socket])
-        when @options.has_key?(:swiftiply)
-          Server.new(Backends::SwiftiplyClient.new(@options[:address], @options[:port], @options[:swiftiply]))
         else
           Server.new(@options[:address], @options[:port])
         end
-
+        
+        # Set options
         server.pid_file                       = @options[:pid]
         server.log_file                       = @options[:log]
         server.timeout                        = @options[:timeout]
         server.maximum_connections            = @options[:max_conns]
         server.maximum_persistent_connections = @options[:max_persistent_conns]
+        server.threaded                       = @options[:threaded]
 
+        # Detach the process, after this line the current process returns
         server.daemonize if @options[:daemonize]
 
-        server.config # Must be called before changing privileges since it might require superuser power.
+        # +config+ must be called before changing privileges since it might require superuser power.
+        server.config
         
         server.change_privilege @options[:user], @options[:group] if @options[:user] && @options[:group]
 
         # If a Rack config file is specified we eval it inside a Rack::Builder block to create
-        # a Rack adapter from it. DHH was hacker of the year a couple years ago so we default
-        # to Rails adapter.
+        # a Rack adapter from it. Or else we guess which adapter to use and load it.
         if @options[:rackup]
-          rackup_code = File.read(@options[:rackup])
-          server.app  = eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, @options[:rackup])
+          server.app = load_rackup_config
         else
-          server.app = Rack::Adapter::Rails.new(@options.merge(:root => @options[:chdir]))
+          server.app = load_adapter
         end
 
         # If a prefix is required, wrap in Rack URL mapper
@@ -64,7 +75,8 @@ module Thin
         # If a stats URL is specified, wrap in Stats adapter
         server.app = Stats::Adapter.new(server.app, @options[:stats]) if @options[:stats]
 
-        # Register restart procedure
+        # Register restart procedure which just start another process with same options,
+        # so that's why this is done here.
         server.on_restart { Command.run(:start, @options) }
 
         server.start
@@ -141,6 +153,20 @@ module Thin
           sleep 1 if File.exist?(file) # HACK Give the thread a little time to open the file
           tail_thread
         end
+
+      private
+        def load_adapter
+          adapter = @options[:adapter] || Rack::Adapter.guess(@options[:chdir])
+          log ">> Using #{adapter} adapter"
+          Rack::Adapter.for(adapter, @options)
+        rescue Rack::AdapterNotFound => e
+          raise InvalidOption, e.message
+        end
+        
+        def load_rackup_config
+          rackup_code = File.read(@options[:rackup])
+          eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, @options[:rackup])
+        end
     end
   end
 end

data/lib/thin/logging.rb

@@ -15,7 +15,7 @@ module Thin
       def silent?;  @silent            end
     end
     
-    # Deprecated silencer methods, those are now a module methods
+    # Deprecated silencer methods, those are now module methods
     def silent
       warn "`#{self.class.name}\#silent` deprecated, use `Thin::Logging.silent?` instead"
       Logging.silent?

data/lib/thin/request.rb

@@ -12,6 +12,7 @@ module Thin
     # and into a tempfile for reading.
     MAX_BODY          = 1024 * (80 + 32)
     BODY_TMPFILE      = 'thin-body'.freeze
+    MAX_HEADER        = 1024 * (80 + 32)
     
     # Freeze some HTTP header names & values
     SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
@@ -60,7 +61,7 @@ module Thin
         RACK_RUN_ONCE     => false
       }
     end
-    
+        
     # Parse a chunk of data into the request environment
     # Raises a +InvalidRequest+ if invalid.
     # Returns +true+ if the parsing is complete.
@@ -69,6 +70,8 @@ module Thin
         body << data        
       else                  # Parse more header using the super parser
         @data << data
+        raise InvalidRequest, 'Header longer than allowed' if @data.size > MAX_HEADER 
+        
         @nparsed = @parser.execute(@env, @data, @nparsed)
 
         # Transfert to a tempfile if body is very big
@@ -119,6 +122,10 @@ module Thin
       @env[FORWARDED_FOR]
     end
     
+    def threaded=(value)
+      @env[RACK_MULTITHREAD] = value
+    end
+    
     # Close any resource used by the request
     def close
       @body.delete if @body.class == Tempfile

data/lib/thin/runner.rb

@@ -1,7 +1,7 @@
 require 'optparse'
 require 'yaml'
 
-module Thin
+module Thin  
   # CLI runner.
   # Parse options and send command to the correct Controller.
   class Runner
@@ -62,14 +62,19 @@ module Thin
         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("-y", "--swiftiply [KEY]", "Run using swiftiply")                       { |key| @options[:swiftiply] = key }
-        opts.on("-e", "--environment ENV", "Rails environment " +                       
-                                           "(default: #{@options[:environment]})")      { |env| @options[:environment] = env }
+        opts.on("-A", "--adapter NAME", "Rack adapter to use (default: autodetect)",
+                                        "(#{Rack::ADAPTERS.keys.join(', ')})")          { |name| @options[:adapter] = name }
+        opts.on("-R", "--rackup FILE", "Load a Rack config file instead of " +
+                                       "Rack adapter")                                  { |file| @options[:rackup] = file }
         opts.on("-c", "--chdir DIR", "Change to dir before starting")                   { |dir| @options[:chdir] = File.expand_path(dir) }
-        opts.on("-r", "--rackup FILE", "Load a Rack config file instead of " +
-                                       "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 }
         
+        opts.separator ""
+        opts.separator "Adapter options:"
+        opts.on("-e", "--environment ENV", "Framework environment " +                       
+                                           "(default: #{@options[:environment]})")      { |env| @options[:environment] = env }
+        opts.on(      "--prefix PATH", "Mount the app under PATH (start with /)")       { |path| @options[:prefix] = path }
+        
         unless Thin.win? # Daemonizing not supported on Windows
           opts.separator ""
           opts.separator "Daemon options:"
@@ -94,6 +99,7 @@ module Thin
         opts.separator ""
         opts.separator "Tuning options:"
         
+        opts.on("-b", "--backend CLASS", "Backend to use, full classname")              { |name| @options[:backend] = name }
         opts.on("-t", "--timeout SEC", "Request or command timeout in sec " +            
                                        "(default: #{@options[:timeout]})")              { |sec| @options[:timeout] = sec.to_i }
         opts.on(      "--max-conns NUM", "Maximum number of connections " +
@@ -102,10 +108,13 @@ module Thin
         opts.on(      "--max-persistent-conns NUM",
                                        "Maximum number of persistent connections",
                                        "(default: #{@options[:max_persistent_conns]})") { |num| @options[:max_persistent_conns] = num.to_i }
+        opts.on(      "--threaded", "Call the Rack application in threads " +
+                                    "[experimental]")                                   { @options[:threaded] = true }
         
         opts.separator ""
         opts.separator "Common options:"
 
+        opts.on_tail("-r", "--require FILE", "require the library")                     { |file| ruby_require file }
         opts.on_tail("-D", "--debug", "Set debbuging on")                               { Logging.debug = true }
         opts.on_tail("-V", "--trace", "Set tracing on (log raw request/response)")      { Logging.trace = true }
         opts.on_tail("-h", "--help", "Show this message")                               { puts opts; exit }
@@ -153,7 +162,11 @@ module Thin
       end
       
       if controller.respond_to?(@command)
-        controller.send(@command, *@arguments)
+        begin
+          controller.send(@command, *@arguments)
+        rescue RunnerError => e
+          abort e.message
+        end
       else
         abort "Invalid options for command: #{@command}"
       end
@@ -175,5 +188,14 @@ module Thin
           YAML.load_file(file).each { |key, value| @options[key.to_sym] = value }
         end
       end
+      
+      def ruby_require(file)
+        if File.extname(file) == '.ru'
+          warn 'WARNING: Use the -R option to load a Rack config file'
+          @options[:rackup] = file
+        else
+          require file
+        end
+      end
   end
 end