thin 0.8.2 → 1.0.0

data/CHANGELOG

@@ -1,3 +1,18 @@
+== 1.0.0 That's What She Said release
+ * Fixed vlad.rake to allow TCP or socket [hellekin]
+ * Updated Mack adapter to handle both <0.8.0 and >0.8.0 [Mark Bates]
+ * rails rack adapter uses File.readable_real? so it recognizes ACL permissions [Ricardo Chimal]
+ * Log a warning if Rack application returns nil body [Michael S. Klishin]
+ * Handle nil and Time header values correctly [#76 state:resolved] [tmm1]
+ * Add Content-Length header to response automatically when possible [#74 state:resolved] [dkubb]
+ * Runner now remembers -r, -D and -V parameters so that clustered servers inherit those and
+   `restart` keep your parameters.
+ * Make Set-Cookie header, in Rails adapter, compatible with current Rack spec [Pedro Belo]
+   [#73, state:resolved]
+ * Add --no-epoll option to disable epoll usage on Linux [#61 state:resolved]
+ * Add --force (-f) option to force stopping of a daemonized server [#72 state:resolved]
+ * Update halycon adapter loader [mtodd]
+
 == 0.8.2 Double Margarita release
  * Require EventMachine 0.12.0
  * [bug] Fix timeout handling when running command

data/README

@@ -57,7 +57,7 @@ You need to setup a config.ru file and pass it to the thin script:
  
  run app
 
- thin start -r config.ru
+ thin start -R config.ru
  
 See example directory for more samples and run 'thin -h' for usage.
 

data/example/adapter.rb

@@ -8,10 +8,7 @@ class SimpleAdapter
     body = ["hello!"]
     [
       200,
-      {
-        'Content-Type'   => 'text/plain',
-        'Content-Length' => body.join.size.to_s,
-      },
+      { 'Content-Type' => 'text/plain' },
       body
     ]
   end
@@ -31,5 +28,5 @@ end
 #
 #   app = Rack::URLMap.new('/test'  => SimpleAdapter.new,
 #                          '/files' => Rack::File.new('.'))
-#   Thin::Server.new('0.0.0.0', 3000, app).start
+#   Thin::Server.start('0.0.0.0', 3000, app)
 #

data/example/config.ru

@@ -1,6 +1,6 @@
 # Run with: rackup -s thin
 # then browse to http://localhost:9292
-# Or with: thin start -r config.ru
+# Or with: thin start -R config.ru
 # then browse to http://localhost:3000
 # 
 # Check Rack::Builder doc for more details on this file format:
@@ -15,10 +15,7 @@ app = proc do |env|
   
   [
     200,                                        # Status code
-    {
-      'Content-Type' => 'text/html',            # Reponse headers
-      'Content-Length' => body.join.size.to_s
-    },
+    { 'Content-Type' => 'text/html' },          # Reponse headers
     body                                        # Body of the response
   ]
 end

data/example/vlad.rake

@@ -15,7 +15,7 @@ namespace :vlad do
   set :thin_log_file,      nil
   set :thin_pid_file,      nil
   set :thin_port,          nil
-  set :thin_socket,        "/tmp/thin.sock"
+  set :thin_socket,        nil
   set :thin_prefix,        nil
   set :thin_servers,       2
   set :thin_user,          nil
@@ -24,10 +24,13 @@ namespace :vlad do
 configuration is set via the thin_* variables.".cleanup
 
   remote_task :setup_app, :roles => :app do
+  
+    raise(ArgumentError, "Please provide either thin_socket or thin_port") if thin_port.nil? && thin_socket.nil?
+  
     cmd = [
            "#{thin_command} config",
            "-s #{thin_servers}",
-           "-S #{thin_socket}",
+           ("-S #{thin_socket}" if thin_socket),
            "-e #{thin_environment}",
            "-a #{thin_address}",
            "-c #{current_path}",
@@ -58,4 +61,4 @@ configuration is set via the thin_* variables.".cleanup
   remote_task :stop_app, :roles => :app do
     run thin("stop -s #{thin_servers}")
   end
-end
+end

data/lib/rack/adapter/loader.rb

@@ -1,25 +1,29 @@
 module Rack
   class AdapterNotFound < RuntimeError; end
-
-  # Hash used to guess which adapter to use in <tt>Adapter.for</tt>.
-  # Framework name => file unique to this framework.
+  
+  # Mapping used to guess which adapter to use in <tt>Adapter.for</tt>.
+  # Framework <name> => <file unique to this framework> in order they will
+  # be tested.
   # +nil+ for value to never guess.
-  ADAPTERS = {
-    :rails   => "config/environment.rb",
-    :ramaze  => "start.rb",
-    :merb    => "config/init.rb",
-    :halcyon => 'runner.ru',
-    :mack    => 'config/app_config/default.yml',
-    :file    => nil
-  }
-    
-  module Adapter    
+  # NOTE: If a framework has a file that is not unique, make sure to place
+  # it at the end.
+  ADAPTERS = [
+    [:rails,   'config/environment.rb'],
+    [:ramaze,  'start.rb'],
+    [:halcyon, 'runner.ru'],
+    [:merb,    'config/init.rb'],
+    [:mack,    'config/app_config/default.yml'],
+    [:mack,    'config/configatron/default.rb'],
+    [:file,    nil]
+  ]
+  
+  module Adapter
     # Guess which adapter to use based on the directory structure
     # or file content.
     # Returns a symbol representing the name of the adapter to use
     # to load the application under <tt>dir/</tt>.
     def self.guess(dir)
-      ADAPTERS.each_pair do |adapter, file|
+      ADAPTERS.each do |adapter, file|
         return adapter if file && ::File.exist?(::File.join(dir, file))
       end
       raise AdapterNotFound, "No adapter found for #{dir}"
@@ -33,39 +37,39 @@ module Rack
       
       when :ramaze
         require "#{options[:chdir]}/start"
-
+        
         Ramaze.trait[:essentials].delete Ramaze::Adapter
         Ramaze.start :force => true
-
+        
         return Ramaze::Adapter::Base
-
+        
       when :merb
         require 'merb-core'
-
+        
         Merb::Config.setup(:merb_root   => options[:chdir],
                            :environment => options[:environment])
         Merb.environment = Merb::Config[:environment]
         Merb.root = Merb::Config[:merb_root]
         Merb::BootLoader.run
-
+        
         return Merb::Rack::Application.new
-      
+        
       when :halcyon
         require 'halcyon'
         
         $:.unshift(Halcyon.root/'lib')
-        Halcyon::Runner.load_config Halcyon.root/'config'/'config.yml'
         
         return Halcyon::Runner.new
-      
+        
       when :mack
         ENV["MACK_ENV"] = options[:environment]
         load(::File.join(options[:chdir], "Rakefile"))
         require 'mack'
         return Mack::Utils::Server.build_app
+        
       when :file
         return Rack::File.new(options[:chdir])
-      
+        
       else
         raise AdapterNotFound, "Adapter not found: #{name}"
         

data/lib/rack/adapter/rails.rb

@@ -37,7 +37,7 @@ module Rack
       # TODO refactor this in File#can_serve?(path) ??
       def file_exist?(path)
         full_path = ::File.join(@file_server.root, Utils.unescape(path))
-        ::File.file?(full_path) && ::File.readable?(full_path)
+        ::File.file?(full_path) && ::File.readable_real?(full_path)
       end
       
       def serve_file(env)
@@ -112,10 +112,16 @@ module Rack
                   when Hash  then cookie.each { |_, c| cookies << c.to_s }
                   else            cookies << cookie.to_s
                 end
-        
+                
                 @output_cookies.each { |c| cookies << c.to_s } if @output_cookies
                 
-                @response['Set-Cookie'] = [@response['Set-Cookie'], cookies].compact.join("\n")
+                @response['Set-Cookie'] = [@response['Set-Cookie'], cookies].compact
+                # See http://groups.google.com/group/rack-devel/browse_thread/thread/e8759b91a82c5a10/a8dbd4574fe97d69?#a8dbd4574fe97d69
+                if Thin.ruby_18?
+                  @response['Set-Cookie'].flatten!
+                else
+                  @response['Set-Cookie'] = @response['Set-Cookie'].join("\n")
+                end
               end
               
               options.each { |k,v| @response[k] = v }

data/lib/thin/backends/base.rb

@@ -30,22 +30,32 @@ module Thin
       # Number of persistent connections currently opened
       attr_accessor :persistent_connection_count
       
+      # Disable the use of epoll under Linux
+      attr_accessor :no_epoll
+      
       def initialize
         @connections                    = []
         @timeout                        = Server::DEFAULT_TIMEOUT
         @persistent_connection_count    = 0
         @maximum_connections            = Server::DEFAULT_MAXIMUM_CONNECTIONS
         @maximum_persistent_connections = Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
+        @no_epoll                       = false
       end
       
       # Start the backend and connect it.
       def start
         @stopping = false
-        
-        EventMachine.run do
+        starter   = proc do
           connect
           @running = true
         end
+        
+        # Allow for early run up of eventmachine.
+        if EventMachine.reactor_running?
+          starter.call
+        else
+          EventMachine.run(&starter)
+        end
       end
       
       # Stop of the backend from accepting new connections.
@@ -72,7 +82,7 @@ module Thin
       # so you can do crazy stuff that require godlike powers here.
       def config
         # See http://rubyeventmachine.com/pub/rdoc/files/EPOLL.html
-        EventMachine.epoll
+        EventMachine.epoll unless @no_epoll
         
         # Set the maximum number of socket descriptors that the server may open.
         # The process needs to have required privilege to set it higher the 1024 on

data/lib/thin/command.rb

@@ -1,7 +1,7 @@
 require 'open3'
 
 module Thin
-  # Run a command though the +thin+ command-line script.
+  # Run a command through the +thin+ command-line script.
   class Command
     include Logging
     
@@ -34,12 +34,14 @@ module Thin
     # Turn into a runnable shell command
     def shellify
       shellified_options = @options.inject([]) do |args, (name, value)|
-        args << case value
+        case value
         when NilClass,
-             TrueClass then "--#{name}"
+             TrueClass then args << "--#{name}"
         when FalseClass
-        else                "--#{name.to_s.tr('_', '-')}=#{value.inspect}"
+        when Array     then value.each { |v| args << "--#{name}=#{v.inspect}" }
+        else                args << "--#{name.to_s.tr('_', '-')}=#{value.inspect}"
         end
+        args
       end
       
       raise ArgumentError, "Path to thin script can't be found, set Command.script" unless self.class.script
@@ -47,4 +49,4 @@ module Thin
       "#{self.class.script} #{@name} #{shellified_options.compact.join(' ')}"
     end
   end
-end
+end

data/lib/thin/connection.rb

@@ -5,30 +5,34 @@ module Thin
   # This class is instanciated by EventMachine on each new connection
   # that is opened.
   class Connection < EventMachine::Connection
+    CONTENT_LENGTH    = 'Content-Length'.freeze
+    TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+    CHUNKED_REGEXP    = /\bchunked\b/i.freeze
+
     include Logging
-    
+
     # Rack application (adapter) served by this connection.
     attr_accessor :app
-    
+
     # Backend to the server
     attr_accessor :backend
-    
+
     # Current request served by the connection
     attr_accessor :request
-    
+
     # Next response sent through the connection
     attr_accessor :response
-    
+
     # Calling the application in a threaded allowing
     # concurrent processing of requests.
     attr_writer :threaded
-    
+
     # Get the connection ready to process a request.
     def post_init
       @request  = Request.new
       @response = Response.new
     end
-    
+
     # Called when data is received from the client.
     def receive_data(data)
       trace { data }
@@ -38,7 +42,7 @@ module Thin
       log_error e
       close_connection
     end
-    
+
     # Called when all data was received and the request
     # is ready to be processed.
     def process
@@ -50,63 +54,72 @@ module Thin
         post_process(pre_process)
       end
     end
-    
+
     def pre_process
       # Add client info to the request env
       @request.remote_address = remote_address
-      
+
       # Process the request calling the Rack adapter
       @app.call(@request.env)
-    rescue Object
+    rescue Exception
       handle_error
       terminate_request
       nil # Signal to post_process that the request could not be processed
     end
-    
+
     def post_process(result)
       return unless result
-      
+
+      # Set the Content-Length header if possible
+      set_content_length(result) if need_content_length?(result)
+
       @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?
       # Make the response persistent if requested by the client
       @response.persistent! if @request.persistent?
-      
+
       # Send the response
       @response.each do |chunk|
         trace { chunk }
         send_data chunk
       end
-      
+
       # If no more request on that same connection, we close it.
       close_connection_after_writing unless persistent?
-      
-    rescue Object
+
+    rescue Exception
       handle_error
     ensure
       terminate_request
     end
-    
+
+    # Logs catched exception and closes the connection.
     def handle_error
       log "!! Unexpected error while processing request: #{$!.message}"
       log_error
       close_connection rescue nil
     end
-    
+
+    # Does request and response cleanup (closes open IO streams and
+    # deletes created temporary files).
+    # Re-initializes response and request if client supports persistent
+    # connection.
     def terminate_request
       @request.close  rescue nil
       @response.close rescue nil
-      
+
       # Prepare the connection for another request if the client
       # supports HTTP pipelining (persistent connection).
       post_init if persistent?
     end
-    
+
     # Called when the connection is unbinded from the socket
     # and can no longer be used to process requests.
     def unbind
       @backend.connection_finished(self)
     end
-    
+
     # Allows this connection to be persistent.
     def can_persist!
       @can_persist = true
@@ -122,25 +135,52 @@ module Thin
     def persistent?
       @can_persist && @response.persistent?
     end
-    
+
     # +true+ if <tt>app.call</tt> will be called inside a thread.
     # You can set all requests as threaded setting <tt>Connection#threaded=true</tt>
     # or on a per-request case returning +true+ in <tt>app.deferred?</tt>.
     def threaded?
       @threaded || (@app.respond_to?(:deferred?) && @app.deferred?(@request.env))
     end
-    
+
     # IP Address of the remote client.
     def remote_address
       @request.forwarded_for || socket_address
-    rescue Object
+    rescue Exception
       log_error
       nil
     end
-    
+
     protected
+
+      # Returns IP address of peer as a string.
       def socket_address
         Socket.unpack_sockaddr_in(get_peername)[1]
       end
+
+    private
+      def need_content_length?(result)
+        status, headers, body = result
+        return false if headers.has_key?(CONTENT_LENGTH)
+        return false if (100..199).include?(status) || status == 204 || status == 304
+        return false if headers.has_key?(TRANSFER_ENCODING) && headers[TRANSFER_ENCODING] =~ CHUNKED_REGEXP
+        return false unless body.kind_of?(String) || body.kind_of?(Array)
+        true
+      end
+
+      def set_content_length(result)
+        headers, body = result[1..2]
+        case body
+        when String
+          # See http://redmine.ruby-lang.org/issues/show/203
+          headers[CONTENT_LENGTH] = (body.respond_to?(:bytesize) ? body.bytesize : body.size).to_s
+        when Array
+           bytes = 0
+           body.each do |p|
+             bytes += p.respond_to?(:bytesize) ? p.bytesize : p.size
+           end
+           headers[CONTENT_LENGTH] = bytes.to_s
+        end
+      end
   end
-end
+end

data/lib/thin/controllers/controller.rb

@@ -49,6 +49,7 @@ module Thin
         server.maximum_connections            = @options[:max_conns]
         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=)
 
         # Detach the process, after this line the current process returns
         server.daemonize if @options[:daemonize]
@@ -83,7 +84,7 @@ module Thin
         raise OptionRequired, :pid unless @options[:pid]
       
         tail_log(@options[:log]) do
-          if Server.kill(@options[:pid], @options[:timeout] || 60)
+          if Server.kill(@options[:pid], @options[:force] ? 0 : (@options[:timeout] || 60))
             wait_for_file :deletion, @options[:pid]
           end
         end

data/lib/thin/daemonizing.rb

@@ -89,22 +89,16 @@ module Thin
     end
     
     module ClassMethods
-      # Send a QUIT signal the process which PID is stored in +pid_file+.
+      # Send a QUIT or INT (if timeout is +0+) signal the process which
+      # PID is stored in +pid_file+.
       # If the process is still running after +timeout+, KILL signal is
       # sent.
       def kill(pid_file, timeout=60)
-        if pid = send_signal('QUIT', pid_file)
-          Timeout.timeout(timeout) do
-            sleep 0.1 while Process.running?(pid)
-          end
+        if timeout == 0
+          send_signal('INT', pid_file, timeout)
+        else
+          send_signal('QUIT', pid_file, timeout)
         end
-      rescue Timeout::Error
-        print "Timeout! "
-        send_signal('KILL', pid_file)
-      rescue Interrupt
-        send_signal('KILL', pid_file)
-      ensure
-        File.delete(pid_file) if File.exist?(pid_file)
       end
       
       # Restart the server by sending HUP signal.
@@ -113,20 +107,31 @@ module Thin
       end
       
       # Send a +signal+ to the process which PID is stored in +pid_file+.
-      def send_signal(signal, pid_file)
-        if File.exist?(pid_file) && pid = open(pid_file).read
+      def send_signal(signal, pid_file, timeout=60)
+        if File.file?(pid_file) && pid = File.read(pid_file)
           pid = pid.to_i
-          print "Sending #{signal} signal to process #{pid} ... "
+          Logging.log "Sending #{signal} signal to process #{pid} ... "
           Process.kill(signal, pid)
-          puts
-          pid
+          Timeout.timeout(timeout) do
+            sleep 0.1 while Process.running?(pid)
+          end
+          Logging.log ""
         else
           puts "Can't stop process, no PID found in #{pid_file}"
-          nil
         end
+      rescue Timeout::Error
+        Logging.log "Timeout!"
+        force_kill pid_file
+      rescue Interrupt
+        force_kill pid_file
       rescue Errno::ESRCH # No such process
-        puts "process not found!"
-        nil
+        Logging.log "process not found!"
+        force_kill pid_file
+      end
+      
+      def force_kill(pid_file)
+        Process.kill("KILL", File.read(pid_file))      rescue nil
+        File.delete(pid_file) if File.exist?(pid_file) rescue nil
       end
     end
     

data/lib/thin/headers.rb

@@ -16,6 +16,14 @@ module Thin
     def []=(key, value)
       if !@sent.has_key?(key) || ALLOWED_DUPLICATES.include?(key)
         @sent[key] = true
+        value = case value
+                when Time
+                  value.httpdate
+                when NilClass
+                  return
+                else
+                  value.to_s
+                end
         @out << HEADER_FORMAT % [key, value]
       end
     end

data/lib/thin/logging.rb

@@ -15,35 +15,40 @@ module Thin
       def silent?;  @silent            end
     end
     
-    # Deprecated silencer methods, those are now module methods
+    # Global silencer methods
     def silent
-      warn "`#{self.class.name}\#silent` deprecated, use `Thin::Logging.silent?` instead"
       Logging.silent?
     end
     def silent=(value)
-      warn "`#{self.class.name}\#silent=` deprecated, use `Thin::Logging.silent = #{value}` instead"
       Logging.silent = value
     end
     
-    protected
-      # Log a message to the console
-      def log(msg)
-        puts msg unless Logging.silent?
-      end
-      
-      # Log a message to the console if tracing is activated
-      def trace(msg=nil)
-        log msg || yield if Logging.trace?
-      end
-      
-      # Log a message to the console if debugging is activated
-      def debug(msg=nil)
-        log msg || yield if Logging.debug?
-      end
-      
-      # Log an error backtrace if debugging is activated
-      def log_error(e=$!)
-        debug "#{e}\n\t" + e.backtrace.join("\n\t")
-      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
+    def trace(msg=nil)
+      log msg || yield if Logging.trace?
+    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=$!)
+      debug "#{e}\n\t" + e.backtrace.join("\n\t")
+    end
+    module_function :log_error
+    public :log_error
   end
 end