thin 0.6.4-x86-mswin32-60 → 0.7.0-x86-mswin32-60

data/lib/thin/connectors/connector.rb

@@ -4,27 +4,32 @@ module Thin
     # * connection/disconnection to the server
     # * initialization of the connections
     # * manitoring of the active connections.
-    class Connector
-      include Logging
-      
+    class Connector      
       # Server serving the connections throught the connector
-      attr_reader :server
+      attr_accessor :server
       
       # Maximum time for incoming data to arrive
       attr_accessor :timeout
       
+      # Maximum number of connections that can be persistent
+      attr_accessor :maximum_persistent_connections
+      
+      # Number of persistent connections currently opened
+      attr_accessor :persistent_connection_count
+      
       def initialize
-        @connections = []
-        @timeout     = 60 # sec
+        @connections                    = []
+        @timeout                        = Server::DEFAULT_TIMEOUT
+        @persistent_connection_count    = 0
+        @maximum_persistent_connections = Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
       end
             
       # Free up resources used by the connector.
       def close
       end
       
-      def server=(server)
-        @server = server
-        @silent = @server.silent
+      def running?
+        @server.running?
       end
             
       # Initialize a new connection to a client.
@@ -32,7 +37,13 @@ module Thin
         connection.connector               = self
         connection.app                     = @server.app
         connection.comm_inactivity_timeout = @timeout
-        connection.silent                  = @silent
+        
+        # We control the number of persistent connections by keeping
+        # a count of the total one allowed yet.
+        if @persistent_connection_count < @maximum_persistent_connections
+          connection.can_persist!
+          @persistent_connection_count += 1
+        end
 
         @connections << connection
       end
@@ -44,6 +55,7 @@ module Thin
       
       # Called by a connection when it's unbinded.
       def connection_finished(connection)
+        @persistent_connection_count -= 1 if connection.can_persist?
         @connections.delete(connection)
       end
       

data/lib/thin/connectors/swiftiply_client.rb

@@ -0,0 +1,55 @@
+module Thin
+  module Connectors
+    class SwiftiplyClient < Connector
+      attr_accessor :key
+      
+      attr_accessor :host, :port
+      
+      def initialize(host, port, key=nil)
+        @host = host
+        @port = port.to_i
+        @key  = key || ''
+        super()
+      end
+
+      # Connect the server
+      def connect
+        EventMachine.connect(@host, @port, SwiftiplyConnection, &method(:initialize_connection))
+      end
+
+      # Stops the server
+      def disconnect
+        EventMachine.stop
+      end
+
+      def to_s
+        "#{@host}:#{@port} swiftiply"
+      end
+    end    
+  end
+
+  class SwiftiplyConnection < Connection
+    def connection_completed
+      send_data swiftiply_handshake(@connector.key)
+    end
+    
+    def persistent?
+      true
+    end
+    
+    def unbind
+      super
+      EventMachine.add_timer(rand(2)) { reconnect(@connector.host, @connector.port) } if @connector.running?
+    end
+    
+    protected
+      def swiftiply_handshake(key)
+        'swiftclient' << host_ip.collect { |x| sprintf('%02x', x.to_i)}.join << sprintf('%04x', @connector.port) << sprintf('%02x', key.length) << key
+      end
+      
+      # For some reason Swiftiply request the current host
+      def host_ip
+        Socket.gethostbyname(@connector.host)[3].unpack('CCCC') rescue [0,0,0,0]
+      end
+  end
+end

data/lib/thin/connectors/unix_server.rb

@@ -43,12 +43,10 @@ module Thin
 
   # Connection through a UNIX domain socket.
   class UnixConnection < Connection
-    def remote_address
-      # FIXME not sure about this, does it even make sense on a UNIX socket?
-      Socket.unpack_sockaddr_un(get_peername)
-    rescue
-      log_error($!)
-      nil
-    end
+    protected
+      def socket_address
+        # FIXME not sure about this, does it even make sense on a UNIX socket?
+        Socket.unpack_sockaddr_un(get_peername)
+      end
   end
 end

data/lib/thin/controllers/cluster.rb

@@ -5,19 +5,15 @@ module Thin
     # * Inject the port or socket number in the pid and log filenames.
     # Servers are started throught the +thin+ command-line script.
     class Cluster < Controller
-      # Number of servers in the cluster.
-      attr_accessor :size
-        
+      # Cluster only options that should not be passed in the command sent
+      # to the indiviual servers.
+      CLUSTER_OPTIONS = [:servers, :only]
+      
       # Create a new cluster of servers launched using +options+.
       def initialize(options)
-        @options = options.merge(:daemonize => true)
-        @size    = @options.delete(:servers)
-        @only    = @options.delete(:only)
-      
-        if socket
-          @options.delete(:address)
-          @options.delete(:port)
-        end
+        super
+        # Cluster can only contain daemonized servers
+        @options.merge!(:daemonize => true)
       end
     
       def first_port; @options[:port]     end
@@ -25,17 +21,23 @@ module Thin
       def socket;     @options[:socket]   end
       def pid_file;   @options[:pid]      end
       def log_file;   @options[:log]      end
+      def size;       @options[:servers]  end
+      def only;       @options[:only]     end
+
+      def swiftiply?
+        @options.has_key?(:swiftiply)
+      end
     
       # Start the servers
       def start
-        with_each_server { |port| start_server port }
+        with_each_server { |n| start_server n }
       end
     
       # Start a single server
       def start_server(number)
         log "Starting server on #{server_id(number)} ... "
       
-        run :start, @options, number
+        run :start, number
       end
   
       # Stop the servers
@@ -47,7 +49,7 @@ module Thin
       def stop_server(number)
         log "Stopping server on #{server_id(number)} ... "
       
-        run :stop, @options, number
+        run :stop, number
       end
     
       # Stop and start the servers.
@@ -60,6 +62,8 @@ module Thin
       def server_id(number)
         if socket
           socket_for(number)
+        elsif swiftiply?
+          [address, first_port, number].join(':')
         else
           [address, number].join(':')
         end
@@ -80,14 +84,16 @@ module Thin
       def pid_for(number)
         File.read(pid_file_for(number)).chomp.to_i
       end
-    
+      
       private
         # Send the command to the +thin+ script
-        def run(cmd, options, number)
-          cmd_options = options.dup
+        def run(cmd, number)
+          cmd_options = @options.reject { |option, value| CLUSTER_OPTIONS.include?(option) }
           cmd_options.merge!(:pid => pid_file_for(number), :log => log_file_for(number))
           if socket
             cmd_options.merge!(:socket => socket_for(number))
+          elsif swiftiply?
+            cmd_options.merge!(:port => first_port)
           else
             cmd_options.merge!(:port => number)
           end
@@ -95,12 +101,12 @@ module Thin
         end
       
         def with_each_server
-          if @only
-            yield @only
+          if only
+            yield only
+          elsif socket || swiftiply?
+            size.times { |n| yield n }
           else
-            @size.times do |n|
-              yield socket ? n : (first_port + n)
-            end
+            size.times { |n| yield first_port + n }
           end
         end
       

data/lib/thin/controllers/controller.rb

@@ -19,30 +19,41 @@ module Thin
     
       def initialize(options)
         @options = options
+        
+        if @options[:socket]
+          @options.delete(:address)
+          @options.delete(:port)
+        end
       end
     
       def start
-        if @options[:socket]
-          server = Server.new(@options[:socket])
+        server = case
+        when @options.has_key?(:socket)
+          Server.new(@options[:socket])
+        when @options.has_key?(:swiftiply)
+          Server.new(Connectors::SwiftiplyClient.new(@options[:address], @options[:port], @options[:swiftiply]))
         else
-          server = Server.new(@options[:address], @options[:port])
+          Server.new(@options[:address], @options[:port])
         end
 
-        server.pid_file = @options[:pid]
-        server.log_file = @options[:log]
-        server.timeout  = @options[:timeout]
+        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]
 
-        if @options[:daemonize]
-          server.daemonize
-          server.change_privilege @options[:user], @options[:group] if @options[:user] && @options[:group]
-        end
+        server.daemonize if @options[:daemonize]
+
+        # Must be called before changing privileges since it might require superuser power.
+        server.set_descriptor_table_size!
+        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.
         if @options[:rackup]
           rackup_code = File.read(@options[:rackup])
-          server.app  = eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", nil, @options[:rackup])
+          server.app  = eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, @options[:rackup])
         else
           server.app = Rack::Adapter::Rails.new(@options.merge(:root => @options[:chdir]))
         end
@@ -50,7 +61,7 @@ module Thin
         # If a prefix is required, wrap in Rack URL mapper
         server.app = Rack::URLMap.new(@options[:prefix] => server.app) if @options[:prefix]
 
-        # If a stats are required, wrap in Stats adapter
+        # 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
@@ -62,13 +73,19 @@ module Thin
       def stop
         raise OptionRequired, :pid unless @options[:pid]
       
-        Server.kill(@options[:pid], @options[:timeout] || 60)
+        tail_log(@options[:log]) do
+          Server.kill(@options[:pid], @options[:timeout] || 60)
+          wait_for_file :deletion, @options[:pid]
+        end
       end
     
       def restart
         raise OptionRequired, :pid unless @options[:pid]
       
-        Server.restart(@options[:pid])
+        tail_log(@options[:log]) do
+          Server.restart(@options[:pid])
+          wait_for_file :creation, @options[:pid]
+        end
       end
     
       def config
@@ -80,6 +97,49 @@ module Thin
         File.open(config_file, 'w') { |f| f << @options.to_yaml }
         log ">> Wrote configuration to #{config_file}"
       end
+      
+      protected
+        # Wait for a pid file to either be created or deleted.
+        def wait_for_file(state, file)
+          case state
+          when :creation then sleep 0.1 until File.exist?(file)
+          when :deletion then sleep 0.1 while File.exist?(file)
+          end
+        end
+        
+        # Tail the log file of server +number+ during the execution of the block.        
+        def tail_log(log_file)
+          if log_file
+            tail_thread = tail(log_file)
+            yield
+            tail_thread.kill
+          else
+            yield
+          end
+        end
+        
+        # Acts like GNU tail command. Taken from Rails.
+        def tail(file)
+          tail_thread = Thread.new do
+            Thread.pass until File.exist?(file)
+            cursor = File.size(file)
+            last_checked = Time.now
+            File.open(file, 'r') do |f|
+              loop do
+                f.seek cursor
+                if f.mtime > last_checked
+                  last_checked = f.mtime
+                  contents = f.read
+                  cursor += contents.length
+                  print contents
+                  STDOUT.flush
+                end
+                sleep 0.1
+              end
+            end
+          end
+          tail_thread
+        end
     end
   end
 end

data/lib/thin/controllers/service.rb

@@ -10,7 +10,7 @@ module Thin
       TEMPLATE            = File.dirname(__FILE__) + '/service.sh.erb'
     
       def initialize(options)
-        @options = options
+        super
       
         raise PlatformNotSupported, 'Running as a service only supported on Linux' unless Thin.linux?
       end

data/lib/thin/daemonizing.rb

@@ -1,5 +1,5 @@
 require 'etc'
-require 'daemons'
+require 'daemons' unless Thin.win?
 
 module Process
   # Returns +true+ the process identied by +pid+ is running.
@@ -89,17 +89,19 @@ module Thin
     end
     
     module ClassMethods
-      # Send a INT signal the process which PID is stored in +pid_file+.
+      # Send a QUIT 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('INT', pid_file)
+        if pid = send_signal('QUIT', pid_file)
           begin
             Timeout.timeout(timeout) do
               sleep 0.1 while Process.running?(pid)
             end
           rescue Timeout::Error
-            print "timeout! "
+            print "Timeout! "
+            send_signal('KILL', pid_file)
+          rescue Interrupt
             send_signal('KILL', pid_file)
           end
         end

data/lib/thin/headers.rb

@@ -20,6 +20,10 @@ module Thin
       end
     end
     
+    def has_key?(key)
+      @sent[key]
+    end
+    
     def to_s
       @out.join
     end

data/lib/thin/logging.rb

@@ -1,24 +1,49 @@
 module Thin
-  # To be included into classes to allow some basic logging
-  # that can be silented (+silent+) or made more verbose ($DEBUG=true).
+  # To be included in classes to allow some basic logging
+  # that can be silented (<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+.
   module Logging
-    # Don't output any message if +true+.
-    attr_accessor :silent
+    class << self
+      attr_writer :trace, :debug, :silent
+      
+      def trace?;  !@silent && @trace  end
+      def debug?;  !@silent && @debug  end
+      def silent?;  @silent            end
+    end
+    
+    # Deprecated silencer methods, those are now a module 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 @silent
+        puts msg unless Logging.silent?
       end
       
       # Log a message to the console if tracing is activated
       def trace(msg=nil)
-        puts msg || yield if ($DEBUG || $TRACE) && !@silent
+        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 tracing is activated
-      def log_error(e)
-        trace { "#{e}\n\t" + e.backtrace.join("\n\t") }
+      # Log an error backtrace if debugging is activated
+      def log_error(e=$!)
+        debug "#{e}\n\t" + e.backtrace.join("\n\t")
       end
   end
 end