thin 0.6.1-x86-mswin32-60 → 0.6.2-x86-mswin32-60

data/CHANGELOG

@@ -1,3 +1,27 @@
+== 0.6.2 Rambo release
+ * Server now let current connections finish before stopping, fixes #18
+ * Fix uploading hanging bug when body is moved to a tempfile,
+   also delete the tempfile properly upon completion, fixes #25
+ * 'thin restart' now sends HUP signals rather then stopping & starting, closes #17
+ * HUP signal now launches a new process with the same options.
+ * Add PID and more info from the last request to the Stats adapter
+   mostly taken from Rack::ShowException.
+ * pid and log files in cluster are no longer required to be relative to the
+   app directory (chdir option), fixes #24
+ * Revert to using #each when building response headers under Ruby 1.8,
+   solves an issue w/ Camping adapter, fixes #22
+ * Restructure thin script options in 3 sections: server, daemon and cluster
+ * Add --only (-o) option to control only one server of a cluster.
+ * Stylize stats page and make the url configurable from the thin script.
+ * Raise error if attempting to use unix sockets on windows.
+ * Add example config files for http://www.tildeslash.com/monit useage.
+   Include the example file using "include /path/to/thin/monit/file" in your monitrc file.
+   The group settings let you do this to manage your clusters:
+   
+     sudo monit -g blog restart all
+    
+   There are examples of thin listening on sockets and thin listening on unix sockets.
+
 == 0.6.1 Cheesecake release
  * Remove socket file when server stops.
  * Set back cluster to use 'thin' command to launch servers.

data/benchmark/simple.rb

@@ -3,12 +3,13 @@
 #
 # Run with:
 #
-#  ruby simple.rb [num of request]
+#  ruby simple.rb [num of request] [print|graph] [concurrency levels]
 #
 require File.dirname(__FILE__) + '/../lib/thin'
 require File.dirname(__FILE__) + '/utils'
 
-request = (ARGV[0] || 1000).to_i # Number of request to send (ab -n option)
+request     = (ARGV[0] || 1000).to_i # Number of request to send (ab -n option)
 output_type = (ARGV[1] || 'print')
+levels      = eval(ARGV[2] || '[1, 10, 100]').to_a
 
-benchmark output_type, %w(WEBrick Mongrel EMongrel Thin), request, [1, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+benchmark output_type, %w(WEBrick Mongrel EMongrel Thin), request, levels

data/benchmark/utils.rb

@@ -29,7 +29,7 @@ def run(handler_name, n=1000, c=1)
 
   sleep 2
 
-  out = `nice -n20 ab -c #{c} -n #{n} http://127.0.0.1:port/ 2> /dev/null`
+  out = `nice -n20 ab -c #{c} -n #{n} http://127.0.0.1:#{port}/ 2> /dev/null`
 
   Process.kill('SIGKILL', server)
   Process.wait

data/bin/thin

@@ -34,20 +34,29 @@ opts = OptionParser.new do |opts|
   opts.on("-S", "--socket PATH", "bind to unix domain socket")                    { |file| options[:socket] = file }
   opts.on("-e", "--environment ENV", "Rails environment (default: development)")  { |env| options[:environment] = env }
   opts.on("-c", "--chdir PATH", "Change to dir before starting")                  { |dir| options[:chdir] = File.expand_path(dir) }
-  opts.on("-s", "--servers NUM", "Number of servers to start",
-                                 "set a value >1 to start a cluster")             { |num| options[:servers] = num.to_i }
+  opts.on("-t", "--timeout SEC", "Request or command timeout in sec",            
+                                 "(default: #{options[:timeout]})")               { |sec| options[:timeout] = sec.to_i }
+  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 "Daemon options:"
+  
   opts.on("-d", "--daemonize", "Run daemonized in the background")                { options[:daemonize] = true }
   opts.on("-l", "--log FILE", "File to redirect output",
                               "(default: #{options[:log]})")                      { |file| options[:log] = file }
   opts.on("-P", "--pid FILE", "File to store PID",
                               "(default: #{options[:pid]})")                      { |file| options[:pid] = file }
-  opts.on("-t", "--timeout SEC", "Request or command timeout in sec",            
-                                 "(default: #{options[:timeout]})")               { |sec| options[:timeout] = sec.to_i }
   opts.on("-u", "--user NAME", "User to run daemon as (use with -g)")             { |user| options[:user] = user }
   opts.on("-g", "--group NAME", "Group to run daemon as (use with -u)")           { |group| options[:group] = group }
-  opts.on(      "--prefix PATH", "Mount the app under PATH (start with /)")       { |path| options[:prefix] = path }
-  opts.on("-C", "--config PATH", "Load option from a config file")                { |file| options[:config] = file }
-  opts.on(      "--stats", "Install the Stats adapter at /stats")                 { options[:stats] = true }
+  
+  opts.separator ""
+  opts.separator "Cluster options:"
+  
+  opts.on("-s", "--servers NUM", "Number of servers to start",
+                                 "set a value >1 to start a cluster")             { |num| options[:servers] = num.to_i }
+  opts.on("-o", "--only NUM", "Send command to only one server of the cluster")   { |only| options[:only] = only }
+  opts.on("-C", "--config PATH", "Load options from a config file")               { |file| options[:config] = file }
   
   opts.separator ""
   opts.separator "Common options:"
@@ -62,7 +71,7 @@ end
 # == Utilities
 
 def cluster?(options)
-  options[:servers] && options[:servers] > 1
+  options[:only] || (options[:servers] && options[:servers] > 1)
 end
 
 def load_options_from_config_file!(options)
@@ -101,9 +110,12 @@ def start(options)
     server.app = Rack::URLMap.new(options[:prefix] => server.app) if options[:prefix]
     
     # If a stats are required, wrap in Stats adapter
-    server.app = Thin::Stats::Adapter.new(server.app) if options[:stats]
+    server.app = Thin::Stats::Adapter.new(server.app, options[:stats]) if options[:stats]
     
-    server.start!
+    # Register restart procedure
+    server.on_restart { Thin::Command.run(:start, options) }
+    
+    server.start
   end  
 end
 
@@ -113,7 +125,7 @@ def stop(options)
   if cluster?(options)
     Thin::Cluster.new(options).stop
   else
-    Thin::Server.kill options[:pid], options[:timeout]
+    Thin::Server.kill(options[:pid], options[:timeout])
   end
 end
 
@@ -123,11 +135,7 @@ def restart(options)
   if cluster?(options)
     Thin::Cluster.new(options).restart
   else
-    # Restart only make sense when running as a daemon
-    options.update :daemonize => true
-  
-    stop(options)
-    start(options)
+    Thin::Server.restart(options[:pid])
   end
 end
 

data/example/adapter.rb

@@ -1,17 +1,35 @@
-require 'rubygems'
-require 'thin'
+# Run with: ruby adapter.rb
+# Then browse to http://localhost:3000/test
+# and http://localhost:3000/files/adapter.rb
+require File.dirname(__FILE__) + '/../lib/thin'
 
 class SimpleAdapter
   def call(env)
+    body = ["hello!"]
     [
       200,
-      { 'Content-Type' => 'text/plain' },
-      ["hello!\n"]
+      {
+        'Content-Type' => 'text/plain',
+        'Content-Type' => body.join.size.to_s
+      },
+      body
     ]
   end
 end
 
-app = Rack::URLMap.new('/test'  => SimpleAdapter.new,
-                       '/files' => Rack::File.new('.'))
+Thin::Server.start('0.0.0.0', 3000) do
+  use Rack::CommonLogger
+  map '/test' do
+    run SimpleAdapter.new
+  end
+  map '/files' do
+    run Rack::File.new('.')
+  end
+end
 
-Thin::Server.new('0.0.0.0', 3000, app).start!
+# You could also start the server like this:
+#
+#   app = Rack::URLMap.new('/test'  => SimpleAdapter.new,
+#                          '/files' => Rack::File.new('.'))
+#   Thin::Server.new('0.0.0.0', 3000, app).start
+#

data/example/monit_sockets

@@ -0,0 +1,20 @@
+check process blog1
+    with pidfile /u/apps/blog/shared/pids/thin.14000.pid
+    start program = "/usr/local/bin/ruby /usr/local/bin/thin start -d -e production -u nobody -g nobody -p 14000 -a 127.0.0.1 -P tmp/pids/thin.14000.pid -c /u/apps/blog/current"
+    stop program  = "/usr/local/bin/ruby /usr/local/bin/thin stop -P /u/apps/blog/shared/pids/thin.14000.pid"
+    if totalmem > 90.0 MB for 5 cycles then restart
+    if failed port 14000 then restart
+    if cpu usage > 95% for 3 cycles then restart
+    if 5 restarts within 5 cycles then timeout
+		group blog
+
+check process blog2
+    with pidfile /u/apps/blog/shared/pids/thin.14001.pid
+    start program = "/usr/local/bin/ruby /usr/local/bin/thin start -d -e production -u nobody -g nobody -p 14001 -a 127.0.0.1 -P tmp/pids/thin.14001.pid -c /u/apps/blog/current"
+    stop program  = "/usr/local/bin/ruby /usr/local/bin/thin stop -P /u/apps/blog/shared/pids/thin.14001.pid"
+    if totalmem > 90.0 MB for 5 cycles then restart
+    if failed port 14001 then restart
+    if cpu usage > 95% for 3 cycles then restart
+    if 5 restarts within 5 cycles then timeout
+		group blog
+

data/example/monit_unixsock

@@ -0,0 +1,20 @@
+check process blog1
+    with pidfile /u/apps/blog/shared/pids/thin.1.pid
+    start program = "/usr/local/bin/ruby /usr/local/bin/thin start -d -e production -S /u/apps/blog/shared/pids/thin.1.sock -P tmp/pids/thin.1.pid -c /u/apps/blog/current"
+    stop program  = "/usr/local/bin/ruby /usr/local/bin/thin stop -P /u/apps/blog/shared/pids/thin.1.pid"
+    if totalmem > 90.0 MB for 5 cycles then restart
+		if failed unixsocket /u/apps/blog/shared/pids/thin.1.sock then restart
+    if cpu usage > 95% for 3 cycles then restart
+    if 5 restarts within 5 cycles then timeout
+		group blog
+
+check process blog2
+    with pidfile /u/apps/blog/shared/pids/thin.2.pid
+    start program = "/usr/local/bin/ruby /usr/local/bin/thin start -d -e production -S /u/apps/blog/shared/pids/thin.2.sock -P tmp/pids/thin.2.pid -c /u/apps/blog/current"
+    stop program  = "/usr/local/bin/ruby /usr/local/bin/thin stop -P /u/apps/blog/shared/pids/thin.2.pid"
+    if totalmem > 90.0 MB for 5 cycles then restart
+		if failed unixsocket /u/apps/blog/shared/pids/thin.2.sock then restart
+    if cpu usage > 95% for 3 cycles then restart
+    if 5 restarts within 5 cycles then timeout
+		group blog
+

data/lib/thin.rb

@@ -15,6 +15,7 @@ module Thin
   SERVER  = "#{NAME} #{VERSION::STRING} codename #{VERSION::CODENAME}".freeze  
   
   autoload :Cluster,      'thin/cluster'
+  autoload :Command,      'thin/command'
   autoload :Connection,   'thin/connection'
   autoload :Daemonizable, 'thin/daemonizing'
   autoload :Logging,      'thin/logging'

data/lib/thin/cluster.rb

@@ -1,8 +1,8 @@
 module Thin
   # Control a set of servers.
   # * Generate start and stop commands and run them.
-  # * Inject the port number in the pid and log filenames.
-  # Servers are started throught the +thin+ commandline script.
+  # * Inject the port or socket number in the pid and log filenames.
+  # Servers are started throught the +thin+ command-line script.
   class Cluster
     include Logging
     
@@ -20,7 +20,8 @@ module Thin
     def initialize(options)
       @options = options.merge(:daemonize => true)
       @size    = @options.delete(:servers)
-      @script  = 'thin'
+      @only    = @options.delete(:only)
+      @script  = $PROGRAM_NAME
       
       if socket
         @options.delete(:address)
@@ -31,8 +32,8 @@ module Thin
     def first_port; @options[:port]     end
     def address;    @options[:address]  end
     def socket;     @options[:socket]   end
-    def pid_file;   File.expand_path File.join(@options[:chdir], @options[:pid]) end
-    def log_file;   File.expand_path File.join(@options[:chdir], @options[:log]) end
+    def pid_file;   @options[:pid]      end
+    def log_file;   @options[:log]      end
     
     # Start the servers
     def start
@@ -99,27 +100,16 @@ module Thin
         else
           cmd_options.merge!(:port => number)
         end
-        shell_cmd = shellify(cmd, cmd_options)
-        trace shell_cmd
-        ouput = `#{shell_cmd}`.chomp
-        log "  " + ouput.gsub("\n", "  \n") unless ouput.empty?
-      end
-      
-      # Turn into a runnable shell command
-      def shellify(cmd, options)
-        shellified_options = options.inject([]) do |args, (name, value)|
-          args << case value
-          when NilClass
-          when TrueClass then "--#{name}"
-          else                "--#{name.to_s.tr('_', '-')}=#{value.inspect}"
-          end
-        end
-        "#{@script} #{cmd} #{shellified_options.compact.join(' ')}"
+        Command.run(cmd, cmd_options)
       end
       
       def with_each_server
-        @size.times do |n|
-          yield socket ? n : (first_port + n)
+        if @only
+          yield @only
+        else
+          @size.times do |n|
+            yield socket ? n : (first_port + n)
+          end
         end
       end
       

data/lib/thin/command.rb

@@ -0,0 +1,40 @@
+module Thin
+  # Run a command though the +thin+ command-line script.
+  class Command
+    include Logging
+    
+    # Path to the +thin+ script used to control the servers.
+    # Leave this to default to use the one in the path.
+    attr_accessor :script
+    
+    def initialize(name, options={})
+      @name    = name
+      @options = options
+      @script  = $PROGRAM_NAME
+    end
+    
+    def self.run(*args)
+      new(*args).run
+    end
+    
+    # Send the command to the +thin+ script
+    def run
+      shell_cmd = shellify
+      trace shell_cmd
+      ouput = `#{shell_cmd}`.chomp
+      log "  " + ouput.gsub("\n", "  \n") unless ouput.empty?
+    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}"
+        else                "--#{name.to_s.tr('_', '-')}=#{value.inspect}"
+        end
+      end
+      "#{@script} #{@name} #{shellified_options.compact.join(' ')}"
+    end
+  end
+end

data/lib/thin/connection.rb

@@ -10,6 +10,9 @@ module Thin
     # +true+ if the connection is on a UNIX domain socket.
     attr_accessor :unix_socket
     
+    # Server owning the connection
+    attr_accessor :server
+    
     def post_init
       @request  = Request.new
       @response = Response.new
@@ -25,13 +28,11 @@ module Thin
     end
     
     def process
-      env = @request.env
-      
       # Add client info to the request env
-      env[Request::REMOTE_ADDR] = remote_address(env)
+      @request.env[Request::REMOTE_ADDR] = remote_address
       
       # Process the request
-      @response.status, @response.headers, @response.body = @app.call(env)
+      @response.status, @response.headers, @response.body = @app.call(@request.env)
       
       # Send the response
       @response.each do |chunk|
@@ -46,13 +47,17 @@ module Thin
       log_error e
       close_connection rescue nil
     ensure
-      @request.close rescue nil
+      @request.close  rescue nil
       @response.close rescue nil
     end
     
+    def unbind
+      @server.connection_finished(self)
+    end
+    
     protected
-      def remote_address(env)
-        if remote_addr = env[Request::FORWARDED_FOR]
+      def remote_address
+        if remote_addr = @request.env[Request::FORWARDED_FOR]
           remote_addr
         elsif @unix_socket
           # FIXME not sure about this, does it even make sense on a UNIX socket?

data/lib/thin/daemonizing.rb

@@ -31,7 +31,7 @@ module Thin
     
     # Turns the current script into a daemon process that detaches from the console.
     def daemonize
-      check_plateform_support
+      raise PlatformNotSupported, 'Daemonizing not supported on Windows' if Thin.win?
       raise ArgumentError, 'You must specify a pid_file to deamonize' unless @pid_file
       
       pwd = Dir.pwd # Current directory is changed during daemonization, so store it
@@ -39,8 +39,10 @@ module Thin
       Daemonize.daemonize(File.expand_path(@log_file))
       
       Dir.chdir(pwd)
-      
+            
       write_pid_file
+      
+      trap('HUP') { restart }
       at_exit do
         log ">> Exiting!"
         remove_pid_file
@@ -50,7 +52,6 @@ module Thin
     # Change privileges of the process
     # to the specified user and group.
     def change_privilege(user, group=user)
-      check_plateform_support
       log ">> Changing process privilege to #{user}:#{group}"
       
       uid, gid = Process.euid, Process.egid
@@ -67,41 +68,67 @@ module Thin
       log "Couldn't change user and group to #{user}:#{group}: #{e}"
     end
     
+    # Registerer a proc to be called to restart the server.
+    def on_restart(&block)
+      @on_restart = block
+    end
+    
+    # Restart the server
+    def restart
+      raise ArgumentError, "Can't restart, no 'on_restart' proc specified" unless @on_restart
+      log '>> Restarting ...'
+      stop
+      remove_pid_file
+      @on_restart.call
+      exit!
+    end
+    
     module ClassMethods
-      # Kill the process which PID is stored in +pid_file+.
+      # Send a INT 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 = open(pid_file).read
-          pid = pid.to_i
-          print "Sending INT signal to process #{pid} ... "
+        if pid = send_signal('INT', pid_file)
           begin
-            Process.kill('INT', pid)
             Timeout.timeout(timeout) do
               sleep 0.1 while Process.running?(pid)
             end
           rescue Timeout::Error
-            print "timeout, Sending KILL signal ... "
-            Process.kill('KILL', pid)
+            print "timeout! "
+            send_signal('KILL', pid_file)
           end
-          puts "stopped!"
+        end
+        File.delete(pid_file) if File.exist?(pid_file)
+      end
+      
+      # Restart the server by sending HUP signal
+      def restart(pid_file)
+        send_signal('HUP', pid_file)
+      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
+          pid = pid.to_i
+          print "Sending #{signal} signal to process #{pid} ... "
+          Process.kill(signal, pid)
+          puts
+          pid
         else
-          puts "Can't stop process, no PID found in #{@pid_file}"
+          puts "Can't stop process, no PID found in #{pid_file}"
+          nil
         end
       rescue Errno::ESRCH # No such process
         puts "process not found!"
-      ensure
-        File.delete(pid_file) rescue nil
+        nil
       end
     end
     
-    private
-      def check_plateform_support
-        raise RuntimeError, 'Daemonizing not supported on Windows' if RUBY_PLATFORM =~ /mswin/
-      end
-      
+    protected
       def remove_pid_file
         File.delete(@pid_file) if @pid_file && File.exists?(@pid_file)
       end
-      
+    
       def write_pid_file
         log ">> Writing PID to #{@pid_file}"
         FileUtils.mkdir_p File.dirname(@pid_file)