thin 0.6.4 → 0.7.0

data/CHANGELOG

@@ -1,3 +1,23 @@
+== 0.7.0 Spherical Cow release
+ * Add --max-persistent-conns option to sets the maximum number of persistent connections.
+   Set to 0 to disable Keep-Alive.
+ * INT signal now force stop and QUIT signal gracefully stops.
+ * Warn when descriptors table size can't be set as high as expected.
+ * Eval Rackup config file using top level bindings.
+ * Remove daemons gem dependency on Windows plateform, fixes #45.
+ * Change default timeout from 60 to 30 seconds.
+ * Add --max-conns option to sets the maximum number of file or socket descriptors that
+   your process may open, defaults to 1024.
+ * Tail logfile when stopping and restarting a demonized server, fixes #26.
+ * Wrap application in a Rack::CommonLogger adapter in debug mode.
+ * --debug (-D) option no longer set $DEBUG so logging will be less verbose
+   and Ruby won't be too strict, fixes #36.
+ * Deprecate Server#silent in favour of Logging.silent.
+ * Persistent connection (keep-alive) & HTTP pipelining support.
+ * Fix -s option not being included in generated config file, fixes #37.
+ * Add Swiftiply support. Use w/ the --swiftiply (-y) option in the thin script,
+   closes #28 [Alex MacCaw]
+
 == 0.6.4 Sexy Lobster release
  * Fix error when stopping server on UNIX domain socket, fixes #42
  * Rescue errors in Connection#get_peername more gracefully, setting REMOTE_ADDR to nil, fixes #43

data/README

@@ -2,9 +2,10 @@
 Tiny, fast & funny HTTP server
 
 Thin is a Ruby web server that glues together 3 of the best Ruby libraries in web history:
- * the Mongrel parser: the root of Mongrel speed and security
- * Event Machine: a network I/O library with extremely high scalability, performance and stability
- * Rack: a minimal interface between webservers and Ruby frameworks
+* the Mongrel parser: the root of Mongrel speed and security
+* Event Machine: a network I/O library with extremely high scalability, performance and stability
+* Rack: a minimal interface between webservers and Ruby frameworks
+
 Which makes it, with all humility, the most secure, stable, fast and extensible Ruby web server
 bundled in an easy to use gem for your own pleasure.
 
@@ -24,17 +25,15 @@ Or from source:
  rake install
 
 === Usage
-A +thin+ script is offered to easily start your Rails application:
+A +thin+ script offers an easy way to start your Rails application:
 
  cd to/your/rails/app
  thin start
 
-But Thin is also usable through Rack +rackup+ command.
-You need to setup a config.ru file and require thin in it:
+But Thin is also usable with a Rack config file.
+You need to setup a config.ru file and pass it to the thin script:
   
- cat <<EOS
- require 'thin'
- 
+ cat config.ru
  app = proc do |env|
   [
     200,
@@ -47,10 +46,10 @@ You need to setup a config.ru file and require thin in it:
  end
  
  run app
- EOS
- rackup -s thin
+
+ thin start -r config.ru
  
-See example/config.ru for details and rackup -h
+See example directory for more samples and run 'thin -h' for usage.
 
 === License
 Ruby License, http://www.ruby-lang.org/en/LICENSE.txt.

data/benchmark/abc

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# Automate benchmarking with ab with various concurrency levels.
+require 'optparse'
+
+options = {
+  :address  => '0.0.0.0',
+  :port     => 3000,
+  :requests => 1000,
+  :start    => 1,
+  :end      => 100,
+  :step     => 10
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
+
+  opts.on("-n", "--requests NUM", "Number of requests")         { |num| options[:requests] = num }
+  opts.on("-a", "--address HOST", "Address (default: 0.0.0.0)") { |host| options[:address] = host }
+  opts.on("-p", "--port PORT", "use PORT (default: 3000)")      { |port| options[:port] = port.to_i }
+  opts.on("-s", "--start N", "First concurrency level")         { |n| options[:start] = n.to_i }
+  opts.on("-e", "--end N", "Last concurrency level")            { |n| options[:end] = n.to_i }
+  opts.on("-S", "--step N", "Concurrency level step")           { |n| options[:step] = n.to_i }
+  opts.on("-u", "--uri PATH", "Path to send to")                { |u| options[:uri] = u }
+  opts.on("-k", "--keep-alive", "Use Keep-Alive")               { options[:keep_alive] = true }
+  
+  opts.on_tail("-h", "--help", "Show this message")     { puts opts; exit }
+end.parse!(ARGV)
+
+puts 'request   concurrency   req/s    failures'
+puts '=' * 42
+
+c = options[:start]
+until c >= options[:end]
+  sleep 0.5
+  out = `nice -n20 ab #{'-k' if options[:keep_alive]} -c #{c} -n #{options[:requests]} #{options[:address]}:#{options[:port]}/#{options[:uri]} 2> /dev/null`
+
+  r = if requests = out.match(/^Requests.+?(\d+\.\d+)/)
+    requests[1].to_i
+  else
+    0
+  end
+  f = if requests = out.match(/^Failed requests.+?(\d+)/)
+    requests[1].to_i
+  else
+    0
+  end
+  
+  puts "#{options[:requests].to_s.ljust(9)} #{c.to_s.ljust(13)} #{r.to_s.ljust(8)} #{f}"
+  
+  c += options[:step]
+end

data/benchmark/benchmarker.rb

@@ -0,0 +1,80 @@
+require 'rack/lobster'
+
+class Benchmarker
+  PORT    = 7000
+  ADDRESS = '0.0.0.0'
+  
+  attr_accessor :requests, :concurrencies, :servers, :keep_alive
+  
+  def initialize
+    @servers = %w(Mongrel EMongrel Thin)
+    @requests = 1000
+    @concurrencies = [1, 10, 100]
+  end
+  
+  def writer(&block)
+    @writer = block
+  end
+  
+  def run!
+    @concurrencies.each do |concurrency|
+      @servers.each do |server|
+        req_sec, failed = run_one(server, concurrency)
+        @writer.call(server, @requests, concurrency, req_sec, failed)
+      end
+    end
+  end
+  
+  private
+    def start_server(handler_name)
+      @server = fork do
+        [STDOUT, STDERR].each { |o| o.reopen "/dev/null" }
+
+        case handler_name
+        when 'EMongrel'
+          require 'swiftcore/evented_mongrel'
+          handler_name = 'Mongrel'
+        end
+
+        app = proc do |env|
+          [200, {'Content-Type' => 'text/html', 'Content-Length' => '11'}, ['hello world']]
+        end
+
+        handler = Rack::Handler.const_get(handler_name)
+        handler.run app, :Host => ADDRESS, :Port => PORT
+      end
+    
+      sleep 2
+    end
+  
+    def stop_server
+      Process.kill('SIGKILL', @server)
+      Process.wait
+    end
+  
+    def run_ab(concurrency)
+      `nice -n20 ab -c #{concurrency} -n #{@requests} #{@keep_alive ? '-k' : ''} #{ADDRESS}:#{PORT}/ 2> /dev/null`
+    end
+  
+    def run_one(handler_name, concurrency)
+      start_server(handler_name)
+
+      out = run_ab(concurrency)
+
+      stop_server
+
+      req_sec = if matches = out.match(/^Requests.+?(\d+\.\d+)/)
+        matches[1].to_i
+      else
+        0
+      end
+    
+      failed = if matches = out.match(/^Failed requests.+?(\d+)/)
+        matches[1].to_i
+      else
+        0
+      end
+    
+      [req_sec, failed]
+    end
+end

data/benchmark/runner

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+# Simple benchmark to compare Thin performance against
+# other webservers supported by Rack.
+#
+# Run with:
+#
+#  ruby simple.rb [num of request] [print|graph] [concurrency levels]
+#
+require File.dirname(__FILE__) + '/../lib/thin'
+require File.dirname(__FILE__) + '/benchmarker'
+require 'optparse'
+
+options = {
+  :requests      => 1000,
+  :concurrencies => [1, 10, 100],
+  :keep_alive    => false,
+  :output        => :table
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
+
+  opts.on("-n", "--requests NUM", "Number of requests")         { |num| options[:requests] = num.to_i }
+  opts.on("-c", "--concurrencies EXP", "Concurrency levels")    { |exp| options[:concurrencies] = eval(exp).to_a }
+  opts.on("-k", "--keep-alive", "Use persistent connections")   { options[:keep_alive] = true }
+  opts.on("-t", "--table", "Output as text table")              { options[:output] = :table }
+  opts.on("-g", "--graph", "Output as graph")                   { options[:output] = :graph }
+  
+  opts.on_tail("-h", "--help", "Show this message")     { puts opts; exit }
+end.parse!(ARGV)
+
+# benchmark output_type, %w(WEBrick Mongrel EMongrel Thin), request, levels
+b = Benchmarker.new
+b.requests = options[:requests]
+b.concurrencies = options[:concurrencies]
+b.keep_alive = options[:keep_alive]
+
+case options[:output]
+when :table
+  puts 'server     request   concurrency   req/s    failures'
+  puts '=' * 52
+  
+  b.writer do |server, requests, concurrency, req_sec, failed|
+    puts "#{server.ljust(8)}   #{requests}      #{concurrency.to_s.ljust(4)}          #{req_sec.to_s.ljust(8)} #{failed}"
+  end
+  
+  b.run!
+
+when :graph
+  require '/usr/local/lib/ruby/gems/1.8/gems/gruff-0.2.9/lib/gruff'
+  g = Gruff::Area.new
+  g.title = "#{options[:requests]} requests"
+  g.title << ' w/ Keep-Alive' if options[:keep_alive]
+  
+  g.x_axis_label  = 'Concurrency'
+  g.y_axis_label  = 'Requests / sec'
+  g.maximum_value = 0
+  g.minimum_value = 0
+  g.labels        = {}
+  b.concurrencies.each_with_index { |c, i| g.labels[i] = c.to_s }
+  
+  results = {}
+  
+  b.writer do |server, requests, concurrency, req_sec, failed|
+    print '.'
+    results[server] ||= []
+    results[server] << req_sec
+  end
+  
+  b.run!
+  puts
+  
+  results.each do |server, concurrencies|
+    g.data(server, concurrencies)    
+  end
+  
+  g.write('bench.png')
+  `open bench.png`
+end

data/example/adapter.rb

@@ -9,8 +9,8 @@ class SimpleAdapter
     [
       200,
       {
-        'Content-Type' => 'text/plain',
-        'Content-Type' => body.join.size.to_s
+        'Content-Type'   => 'text/plain',
+        'Content-Length' => body.join.size.to_s,
       },
       body
     ]
@@ -32,4 +32,4 @@ end
 #   app = Rack::URLMap.new('/test'  => SimpleAdapter.new,
 #                          '/files' => Rack::File.new('.'))
 #   Thin::Server.new('0.0.0.0', 3000, app).start
-#
+#

data/example/thin.god

@@ -1,6 +1,6 @@
 # == God config file
 # http://god.rubyforge.org/
-# Author: Gump
+# Authors: Gump and michael@glauche.de
 #
 # Config file for god that configures watches for each instance of a thin server for
 # each thin configuration file found in /etc/thin.
@@ -16,28 +16,32 @@ Dir[config_path + "/*.yml"].each do |file|
   config = YAML.load_file(file)
   num_servers = config["servers"] ||= 1
 
-  for i in 0...num_servers
+  (0...num_servers).each do |i|
+    # UNIX socket cluster use number 0 to 2 (for 3 servers)
+    # and tcp cluster use port number 3000 to 3002.
+    number = config['socket'] ? i : (config['port'] + i)
+    
     God.watch do |w|
       w.group = "thin-" + File.basename(file, ".yml")
-      w.name = w.group + "-#{i}"
+      w.name = w.group + "-#{number}"
       
       w.interval = 30.seconds
       
       w.uid = config["user"]
       w.gid = config["group"]
       
-      w.start = "thin start -C #{file} -o #{i}"
+      w.start = "thin start -C #{file} -o #{number}"
       w.start_grace = 10.seconds
       
-      w.stop = "thin stop -C #{file} -o #{i}"
+      w.stop = "thin stop -C #{file} -o #{number}"
       w.stop_grace = 10.seconds
       
-      w.restart = "thin restart -C #{file} -o #{i}"
+      w.restart = "thin restart -C #{file} -o #{number}"
 
       pid_path = config["chdir"] + "/" + config["pid"]
       ext = File.extname(pid_path)
 
-      w.pid_file = pid_path.gsub(/#{ext}$/, ".#{i}#{ext}")
+      w.pid_file = pid_path.gsub(/#{ext}$/, ".#{number}#{ext}")
       
       w.behavior(:clean_pid_file)
 

data/lib/thin.rb

@@ -11,27 +11,28 @@ require 'thin/version'
 require 'thin/statuses'
 
 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'
+  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 Connectors
-    autoload :Connector,  'thin/connectors/connector'
-    autoload :TcpServer,  'thin/connectors/tcp_server'
-    autoload :UnixServer, 'thin/connectors/unix_server'
+    autoload :Connector,        'thin/connectors/connector'
+    autoload :SwiftiplyClient,  'thin/connectors/swiftiply_client'
+    autoload :TcpServer,        'thin/connectors/tcp_server'
+    autoload :UnixServer,       'thin/connectors/unix_server'
   end
   
   module Controllers
-    autoload :Cluster,    'thin/controllers/cluster'
-    autoload :Controller, 'thin/controllers/controller'
-    autoload :Service,    'thin/controllers/service'
+    autoload :Cluster,          'thin/controllers/cluster'
+    autoload :Controller,       'thin/controllers/controller'
+    autoload :Service,          'thin/controllers/service'
   end
 end
 

data/lib/thin/command.rb

@@ -1,3 +1,5 @@
+require 'open3'
+
 module Thin
   # Run a command though the +thin+ command-line script.
   class Command
@@ -22,16 +24,20 @@ module Thin
     def run
       shell_cmd = shellify
       trace shell_cmd
-      ouput = `#{shell_cmd}`.chomp
-      log "  " + ouput.gsub("\n", "  \n") unless ouput.empty?
+      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?
+      end
     end
     
     # Turn into a runnable shell command
     def shellify
       shellified_options = @options.inject([]) do |args, (name, value)|
         args << case value
-        when NilClass
-        when TrueClass then "--#{name}"
+        when NilClass,
+             TrueClass then "--#{name}"
+        when FalseClass
         else                "--#{name.to_s.tr('_', '-')}=#{value.inspect}"
         end
       end

data/lib/thin/connection.rb

@@ -2,6 +2,8 @@ require 'socket'
 
 module Thin
   # Connection between the server and client.
+  # This class is instanciated by EventMachine on each new connection
+  # that is opened.
   class Connection < EventMachine::Connection
     include Logging
     
@@ -11,62 +13,93 @@ module Thin
     # Connector to the server
     attr_accessor :connector
     
-    attr_accessor :request, :response
+    # Current request served by the connection
+    attr_accessor :request
     
+    # Next response sent through connection
+    attr_accessor :response
+    
+    # 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 }
       process if @request.parse(data)
     rescue InvalidRequest => e
-      log "Invalid request"
+      log "!! Invalid request"
       log_error e
       close_connection
     end
     
+    # Called when all data was received and the request
+    # is ready to being processed.
     def process
       # Add client info to the request env
-      @request.env[Request::REMOTE_ADDR] = remote_address
+      @request.remote_address = remote_address
       
       # Process the request
       @response.status, @response.headers, @response.body = @app.call(@request.env)
       
+      # 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
       
-      close_connection_after_writing
+      # If no more request on that same connection, we close it.
+      close_connection_after_writing unless persistent?
       
-    rescue Object => e
-      log "Unexpected error while processing request: #{e.message}"
-      log_error e
+    rescue
+      log "!! Unexpected error while processing request: #{$!.message}"
+      log_error
       close_connection rescue nil
     ensure
       @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
       @connector.connection_finished(self)
     end
     
+    # Allows this connection to be persistent.
+    def can_persist!
+      @can_persist = true
+    end
+
+    # Return +true+ if this connection is allowed to stay open and be persistent.
+    def can_persist?
+      @can_persist
+    end
+
+    # Return +true+ if the connection must be left open
+    # and ready to be reused for another request.
+    def persistent?
+      @can_persist && @response.persistent?
+    end    
+    
+    # IP Address of the remote client.
     def remote_address
-      @request.env[Request::FORWARDED_FOR] || (has_peername? ? socket_address : nil)
+      @request.forwarded_for || socket_address
     rescue
-      log_error($!)
+      log_error
       nil
     end
     
     protected
-      def has_peername?
-        !get_peername.nil? && !get_peername.empty?
-      end
-      
       def socket_address
         Socket.unpack_sockaddr_in(get_peername)[1]
       end