thin 1.5.1 → 1.6.0

data/ext/thin_parser/parser.rl

@@ -109,7 +109,7 @@ size_t thin_http_parser_execute(http_parser *parser, const char *buffer, size_t
   pe = buffer+len;
 
   assert(*pe == '\0' && "pointer does not end on NUL");
-  assert(pe - p == len - off && "pointers aren't same distance");
+  assert(pe - p == (long)(len - off) && "pointers aren't same distance");
 
 
   %% write exec;
@@ -132,6 +132,14 @@ size_t thin_http_parser_execute(http_parser *parser, const char *buffer, size_t
   return(parser->nread);
 }
 
+int thin_http_parser_has_error(http_parser *parser) {
+  return parser->cs == http_parser_error;
+}
+
+int thin_http_parser_is_finished(http_parser *parser) {
+  return parser->cs == http_parser_first_final;
+}
+
 int thin_http_parser_finish(http_parser *parser)
 {
   int cs = parser->cs;
@@ -147,11 +155,3 @@ int thin_http_parser_finish(http_parser *parser)
     return 0;
   }
 }
-
-int thin_http_parser_has_error(http_parser *parser) {
-  return parser->cs == http_parser_error;
-}
-
-int thin_http_parser_is_finished(http_parser *parser) {
-  return parser->cs == http_parser_first_final;
-}

data/ext/thin_parser/thin.c

@@ -71,7 +71,6 @@ DEF_MAX_LENGTH(REQUEST_PATH, 1024);
 DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
 DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
 
-
 static void http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen)
 {
   char *ch, *end;
@@ -87,10 +86,10 @@ static void http_field(void *data, const char *field, size_t flen, const char *v
   f = rb_str_buf_cat(f, field, flen); 
 
   for(ch = RSTRING_PTR(f) + RSTRING_LEN(global_http_prefix), end = RSTRING_PTR(f) + RSTRING_LEN(f); ch < end; ch++) {
-    if(*ch == '-') {
+    if (*ch >= 'a' && *ch <= 'z') {
+      *ch &= ~0x20; // upcase
+    } else if (*ch == '-') {
       *ch = '_';
-    } else {
-      *ch = toupper(*ch);
     }
   }
 

data/lib/thin/backends/base.rb

@@ -22,11 +22,18 @@ module Thin
       
       # Maximum number of connections that can be persistent
       attr_accessor :maximum_persistent_connections
-      
+
+      #allows setting of the eventmachine threadpool size
+      attr_reader :threadpool_size
+      def threadpool_size=(size)
+        @threadpool_size = size
+        EventMachine.threadpool_size = size
+      end
+
       # Allow using threads in the backend.
       attr_writer :threaded
       def threaded?; @threaded end
-      
+            
       # Allow using SSL in the backend.
       attr_writer :ssl, :ssl_options
       def ssl?; @ssl end
@@ -46,6 +53,7 @@ module Thin
         @no_epoll                       = false
         @ssl                            = nil
         @threaded                       = nil
+        @started_reactor                = false
       end
       
       # Start the backend and connect it.
@@ -53,6 +61,7 @@ module Thin
         @stopping = false
         starter   = proc do
           connect
+          yield if block_given?
           @running = true
         end
         
@@ -60,6 +69,7 @@ module Thin
         if EventMachine.reactor_running?
           starter.call
         else
+          @started_reactor = true
           EventMachine.run(&starter)
         end
       end
@@ -81,7 +91,7 @@ module Thin
         @running  = false
         @stopping = false
         
-        EventMachine.stop if EventMachine.reactor_running?
+        EventMachine.stop if @started_reactor && EventMachine.reactor_running?
         @connections.each_value { |connection| connection.close_connection }
         close
       end

data/lib/thin/command.rb

@@ -26,8 +26,8 @@ module Thin
       trace shell_cmd
       trap('INT') {} # Ignore INT signal to pass CTRL+C to subprocess
       Open3.popen3(shell_cmd) do |stdin, stdout, stderr|
-        log stdout.gets until stdout.eof?
-        log stderr.gets until stderr.eof?
+        log_info stdout.gets until stdout.eof?
+        log_info stderr.gets until stderr.eof?
       end
     end
     

data/lib/thin/connection.rb

@@ -10,6 +10,8 @@ module Thin
     # This is a template async response. N.B. Can't use string for body on 1.9
     AsyncResponse = [-1, {}, []].freeze
 
+    EMPTY_BODY = [].freeze
+
     # Rack application (adapter) served by this connection.
     attr_accessor :app
 
@@ -35,11 +37,10 @@ module Thin
     # Called when data is received from the client.
     def receive_data(data)
       @idle = false
-      trace { data }
+      trace data
       process if @request.parse(data)
     rescue InvalidRequest => e
-      log "!! Invalid request"
-      log_error e
+      log_error("Invalid request", e)
       post_process Response::BAD_REQUEST
     end
 
@@ -81,8 +82,8 @@ module Thin
         response = @app.call(@request.env)
       end
       response
-    rescue Exception
-      handle_error
+    rescue Exception => e
+      unexpected_error(e)
       # Pass through error response
       can_persist? && @request.persistent? ? Response::PERSISTENT_ERROR : Response::ERROR
     end
@@ -96,19 +97,23 @@ module Thin
 
       @response.status, @response.headers, @response.body = *result
 
-      log "!! Rack application returned nil body. Probably you wanted it to be an empty string?" if @response.body.nil?
+      log_error("Rack application returned nil body. " \
+                "Probably you wanted it to be an empty string?") if @response.body.nil?
+
+      # HEAD requests should not return a body.
+      @response.body = EMPTY_BODY if @request.head?
 
       # Make the response persistent if requested by the client
       @response.persistent! if @request.persistent?
 
       # Send the response
       @response.each do |chunk|
-        trace { chunk }
+        trace chunk
         send_data chunk
       end
 
-    rescue Exception
-      handle_error
+    rescue Exception => e
+      unexpected_error(e)
       # Close connection since we can't handle response gracefully
       close_connection
     ensure
@@ -122,10 +127,9 @@ module Thin
       end
     end
 
-    # Logs catched exception and closes the connection.
-    def handle_error
-      log "!! Unexpected error while processing request: #{$!.message}"
-      log_error
+    # Logs information about an unexpected exceptional condition
+    def unexpected_error(e)
+      log_error("Unexpected error while processing request", e)
     end
 
     def close_request_response
@@ -192,8 +196,8 @@ module Thin
     # IP Address of the remote client.
     def remote_address
       socket_address
-    rescue Exception
-      log_error
+    rescue Exception => e
+      log_error('Could not infer remote address', e)
       nil
     end
 

data/lib/thin/controllers/cluster.rb

@@ -45,7 +45,7 @@ module Thin
     
       # Start a single server
       def start_server(number)
-        log "Starting server on #{server_id(number)} ... "
+        log_info "Starting server on #{server_id(number)} ... "
       
         run :start, number
       end
@@ -57,7 +57,7 @@ module Thin
     
       # Stop a single server
       def stop_server(number)
-        log "Stopping server on #{server_id(number)} ... "
+        log_info "Stopping server on #{server_id(number)} ... "
       
         run :stop, number
       end
@@ -91,7 +91,7 @@ module Thin
       
       # Make sure the server is running before moving on to the next one.
       def wait_until_server_started(number)
-        log "Waiting for server to start ..."
+        log_info "Waiting for server to start ..."
         STDOUT.flush # Need this to make sure user got the message
         
         tries = 0
@@ -175,4 +175,4 @@ module Thin
         end
     end
   end
-end
+end

data/lib/thin/controllers/controller.rb

@@ -37,7 +37,7 @@ module Thin
       def start
         # Constantize backend class
         @options[:backend] = eval(@options[:backend], TOPLEVEL_BINDING) if @options[:backend]
-        
+
         server = Server.new(@options[:socket] || @options[:address], # Server detects kind of socket
                             @options[:port],                         # Port ignored on UNIX socket
                             @options)
@@ -50,6 +50,7 @@ module Thin
         server.maximum_persistent_connections = @options[:max_persistent_conns]
         server.threaded                       = @options[:threaded]
         server.no_epoll                       = @options[:no_epoll] if server.backend.respond_to?(:no_epoll=)
+        server.threadpool_size                = @options[:threadpool_size] if server.threaded?
 
         # ssl support
         if @options[:ssl]
@@ -113,7 +114,7 @@ module Thin
         @options.keys.each { |o| @options[o.to_s] = @options.delete(o) }
 
         File.open(config_file, 'w') { |f| f << @options.to_yaml }
-        log ">> Wrote configuration to #{config_file}"
+        log_info "Wrote configuration to #{config_file}"
       end
       
       protected
@@ -165,7 +166,7 @@ module Thin
       private
         def load_adapter
           adapter = @options[:adapter] || Rack::Adapter.guess(@options[:chdir])
-          log ">> Using #{adapter} adapter"
+          log_info "Using #{adapter} adapter"
           Rack::Adapter.for(adapter, @options)
         rescue Rack::AdapterNotFound => e
           raise InvalidOption, e.message
@@ -185,4 +186,4 @@ module Thin
         end
     end
   end
-end
+end

data/lib/thin/controllers/service.rb

@@ -33,11 +33,11 @@ module Thin
     
       def install(config_files_path=DEFAULT_CONFIG_PATH)
         if File.exist?(INITD_PATH)
-          log ">> Thin service already installed at #{INITD_PATH}"
+          log_info "Thin service already installed at #{INITD_PATH}"
         else
-          log ">> Installing thin service at #{INITD_PATH} ..."
+          log_info "Installing thin service at #{INITD_PATH} ..."
           sh "mkdir -p #{File.dirname(INITD_PATH)}"
-          log "writing #{INITD_PATH}"        
+          log_info "writing #{INITD_PATH}"        
           File.open(INITD_PATH, 'w') do |f|
             f << ERB.new(File.read(TEMPLATE)).result(binding)
           end
@@ -46,30 +46,30 @@ module Thin
       
         sh "mkdir -p #{config_files_path}"
 
-        log ''
-        log "To configure thin to start at system boot:"
-        log "on RedHat like systems:"
-        log "  sudo /sbin/chkconfig --level 345 #{NAME} on"
-        log "on Debian-like systems (Ubuntu):"
-        log "  sudo /usr/sbin/update-rc.d -f #{NAME} defaults"
-        log "on Gentoo:"
-        log "  sudo rc-update add #{NAME} default"
-        log ''
-        log "Then put your config files in #{config_files_path}"
+        log_info ''
+        log_info "To configure thin to start at system boot:"
+        log_info "on RedHat like systems:"
+        log_info "  sudo /sbin/chkconfig --level 345 #{NAME} on"
+        log_info "on Debian-like systems (Ubuntu):"
+        log_info "  sudo /usr/sbin/update-rc.d -f #{NAME} defaults"
+        log_info "on Gentoo:"
+        log_info "  sudo rc-update add #{NAME} default"
+        log_info ''
+        log_info "Then put your config files in #{config_files_path}"
       end
     
       private
         def run(command)
           Dir[config_path + '/*'].each do |config|
-            log "[#{command}] #{config} ..."
+            log_info "[#{command}] #{config} ..."
             Command.run(command, :config => config, :daemonize => true)
           end
         end
       
         def sh(cmd)
-          log cmd
+          log_info cmd
           system(cmd)
         end
     end
   end
-end
+end

data/lib/thin/daemonizing.rb

@@ -55,10 +55,8 @@ module Thin
       
       write_pid_file
 
-      self.after_daemonize if self.respond_to? :after_daemonize
-      
       at_exit do
-        log ">> Exiting!"
+        log_info "Exiting!"
         remove_pid_file
       end
     end
@@ -66,7 +64,7 @@ module Thin
     # Change privileges of the process
     # to the specified user and group.
     def change_privilege(user, group=user)
-      log ">> Changing process privilege to #{user}:#{group}"
+      log_info "Changing process privilege to #{user}:#{group}"
       
       uid, gid = Process.euid, Process.egid
       target_uid = Etc.getpwnam(user).uid
@@ -82,7 +80,7 @@ module Thin
         Process::UID.change_privilege(target_uid)
       end
     rescue Errno::EPERM => e
-      log "Couldn't change user and group to #{user}:#{group}: #{e}"
+      log_info "Couldn't change user and group to #{user}:#{group}: #{e}"
     end
     
     # Register a proc to be called to restart the server.
@@ -93,7 +91,7 @@ module Thin
     # Restart the server.
     def restart
       if @on_restart
-        log '>> Restarting ...'
+        log_info 'Restarting ...'
         stop
         remove_pid_file
         @on_restart.call
@@ -122,7 +120,7 @@ module Thin
       # Send a +signal+ to the process which PID is stored in +pid_file+.
       def send_signal(signal, pid_file, timeout=60)
         if pid = read_pid_file(pid_file)
-          Logging.log "Sending #{signal} signal to process #{pid} ... "
+          Logging.log_info "Sending #{signal} signal to process #{pid} ... "
           Process.kill(signal, pid)
           Timeout.timeout(timeout) do
             sleep 0.1 while Process.running?(pid)
@@ -131,17 +129,17 @@ module Thin
           raise PidFileNotFound, "Can't stop process, no PID found in #{pid_file}"
         end
       rescue Timeout::Error
-        Logging.log "Timeout!"
+        Logging.log_info "Timeout!"
         force_kill(pid, pid_file)
       rescue Interrupt
         force_kill(pid, pid_file)
       rescue Errno::ESRCH # No such process
-        Logging.log "process not found!"
+        Logging.log_info "process not found!"
         force_kill(pid, pid_file)
       end
       
       def force_kill(pid, pid_file)
-        Logging.log "Sending KILL signal to process #{pid} ... "
+        Logging.log_info "Sending KILL signal to process #{pid} ... "
         Process.kill("KILL", pid)
         File.delete(pid_file) if File.exist?(pid_file)
       end
@@ -161,7 +159,7 @@ module Thin
       end
     
       def write_pid_file
-        log ">> Writing PID to #{@pid_file}"
+        log_info "Writing PID to #{@pid_file}"
         open(@pid_file,"w") { |f| f.write(Process.pid) }
         File.chmod(0644, @pid_file)
       end
@@ -173,7 +171,7 @@ module Thin
             raise PidFileExist, "#{@pid_file} already exists, seems like it's already running (process ID: #{pid}). " +
                                 "Stop the process or delete #{@pid_file}."
           else
-            log ">> Deleting stale PID file #{@pid_file}"
+            log_info "Deleting stale PID file #{@pid_file}"
             remove_pid_file
           end
         end

data/lib/thin/logging.rb

@@ -1,54 +1,165 @@
+require 'logger'
+
 module Thin
   # To be included in classes to allow some basic logging
   # that can be silenced (<tt>Logging.silent=</tt>) or made
   # more verbose.
-  # <tt>Logging.debug=</tt>: log all error backtrace and messages
-  #                          logged with +debug+.
-  # <tt>Logging.trace=</tt>: log all raw request and response and
-  #                          messages logged with +trace+.
+  # <tt>Logging.trace=</tt>:  log all raw request and response and
+  #                           messages logged with +trace+.
+  # <tt>Logging.silent=</tt>: silence all log all log messages
+  #                           altogether.
   module Logging
+    # Simple formatter which only displays the message.
+    # Taken from ActiveSupport
+    class SimpleFormatter < Logger::Formatter
+      def call(severity, timestamp, progname, msg)
+        "#{String === msg ? msg : msg.inspect}\n"
+      end
+    end
+
     class << self
-      attr_writer :trace, :debug, :silent
-      
-      def trace?;  !@silent && @trace  end
-      def debug?;  !@silent && @debug  end
-      def silent?;  @silent            end
-    end
-    
-    # Global silencer methods
+
+      attr_reader :logger
+      attr_reader :trace_logger
+
+      def trace=(enabled)
+        if enabled
+          @trace_logger ||= Logger.new(STDOUT)
+        else
+          @trace_logger = nil
+        end
+      end
+
+      def trace?
+        !@trace_logger.nil?
+      end
+
+      def silent=(shh)
+        if shh
+          @logger = nil
+        else
+          @logger ||= Logger.new(STDOUT)
+        end
+      end
+
+      def silent?
+        !@logger.nil?
+      end
+
+      def level
+        @logger ? @logger.level : nil # or 'silent'
+      end
+
+      def level=(value)
+        # If logging has been silenced, then re-enable logging
+        @logger = Logger.new(STDOUT) if @logger.nil?
+        @logger.level = value
+      end
+
+      # Allow user to specify a custom logger to use.
+      # This object must respond to:
+      # +level+, +level=+ and +debug+, +info+, +warn+, +error+, +fatal+
+      def logger=(custom_logger)
+        [ :level   ,
+          :level=  ,
+          :debug   ,
+          :info    ,
+          :warn    ,
+          :error   ,
+          :fatal   ,
+          :unknown ,
+        ].each do |method|
+          if not custom_logger.respond_to?(method)
+            raise ArgumentError, "logger must respond to #{method}"
+          end
+        end
+
+        @logger = custom_logger
+      end
+
+      def trace_logger=(custom_tracer)
+        [ :level   ,
+          :level=  ,
+          :debug   ,
+          :info    ,
+          :warn    ,
+          :error   ,
+          :fatal   ,
+          :unknown ,
+        ].each do |method|
+          if not custom_tracer.respond_to?(method)
+            raise ArgumentError, "trace logger must respond to #{method}"
+          end
+        end
+
+        @trace_logger = custom_tracer
+      end
+
+      def log_msg(msg, level=Logger::INFO)
+        return unless @logger
+        @logger.add(level, msg)
+      end
+
+      def trace_msg(msg)
+        return unless @trace_logger
+        @trace_logger.info(msg)
+      end
+
+      # Provided for backwards compatibility.
+      # Callers should be using the +level+ (on the +Logging+ module
+      # or on the instance) to figure out what the log level is.
+      def debug?
+        self.level == Logger::DEBUG
+      end
+      def debug=(val)
+        self.level = (val ? Logger::DEBUG : Logger::INFO)
+      end
+
+    end # module methods
+
     def silent
       Logging.silent?
     end
+
     def silent=(value)
       Logging.silent = value
     end
-    
-    # Log a message to the console
-    def log(msg)
-      puts msg unless Logging.silent?
-    end
-    module_function :log
-    public :log
-    
-    # Log a message to the console if tracing is activated
+
+    # Log a message if tracing is activated
     def trace(msg=nil)
-      log msg || yield if Logging.trace?
+      Logging.trace_msg(msg) if msg
     end
     module_function :trace
     public :trace
-    
-    # Log a message to the console if debugging is activated
-    def debug(msg=nil)
-      log msg || yield if Logging.debug?
-    end
-    module_function :debug
-    public :debug
-    
-    # Log an error backtrace if debugging is activated
-    def log_error(e=$!)
-      STDERR.print("#{e}\n\t" + e.backtrace.join("\n\t") + "\n") if Logging.debug?
+
+    # Log a message at DEBUG level
+    def log_debug(msg=nil)
+      Logging.log_msg(msg || yield, Logger::DEBUG)
+    end
+    module_function :log_debug
+    public :log_debug
+
+    # Log a message at INFO level
+    def log_info(msg)
+      Logging.log_msg(msg || yield, Logger::INFO)
+    end
+    module_function :log_info
+    public :log_info
+
+    # Log a message at ERROR level (and maybe a backtrace)
+    def log_error(msg, e=nil)
+      log_msg = msg + ": #{e}\n\t" + e.backtrace.join("\n\t") + "\n" if e
+      Logging.log_msg(log_msg, Logger::ERROR)
     end
     module_function :log_error
     public :log_error
+
+    # For backwards compatibility
+    def log msg
+      STDERR.puts('#log has been deprecated, please use the ' \
+                  'log_level function instead (e.g. - log_info).')
+      log_info(msg)
+    end
+
   end
 end