thin 1.2.6-x86-mingw32

data/lib/thin/backends/swiftiply_client.rb

@@ -0,0 +1,56 @@
+module Thin
+  module Backends
+    # Backend to act as a Swiftiply client (http://swiftiply.swiftcore.org).
+    class SwiftiplyClient < Base
+      attr_accessor :key
+      
+      attr_accessor :host, :port
+      
+      def initialize(host, port, options={})
+        @host = host
+        @port = port.to_i
+        @key  = options[:swiftiply].to_s
+        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(@backend.key)
+    end
+    
+    def persistent?
+      true
+    end
+    
+    def unbind
+      super
+      EventMachine.add_timer(rand(2)) { reconnect(@backend.host, @backend.port) } if @backend.running?
+    end
+    
+    protected
+      def swiftiply_handshake(key)
+        'swiftclient' << host_ip.collect { |x| sprintf('%02x', x.to_i)}.join << sprintf('%04x', @backend.port) << sprintf('%02x', key.length) << key
+      end
+      
+      # For some reason Swiftiply request the current host
+      def host_ip
+        Socket.gethostbyname(@backend.host)[3].unpack('CCCC') rescue [0,0,0,0]
+      end
+  end
+end

data/lib/thin/backends/tcp_server.rb

@@ -0,0 +1,29 @@
+module Thin
+  module Backends
+    # Backend to act as a TCP socket server.
+    class TcpServer < Base
+      # Address and port on which the server is listening for connections.
+      attr_accessor :host, :port
+      
+      def initialize(host, port)
+        @host = host
+        @port = port
+        super()
+      end
+      
+      # Connect the server
+      def connect
+        @signature = EventMachine.start_server(@host, @port, Connection, &method(:initialize_connection))
+      end
+      
+      # Stops the server
+      def disconnect
+        EventMachine.stop_server(@signature)
+      end
+            
+      def to_s
+        "#{@host}:#{@port}"
+      end
+    end
+  end
+end

data/lib/thin/backends/unix_server.rb

@@ -0,0 +1,51 @@
+module Thin
+  module Backends
+    # Backend to act as a UNIX domain socket server.
+    class UnixServer < Base
+      # UNIX domain socket on which the server is listening for connections.
+      attr_accessor :socket
+      
+      def initialize(socket)
+        raise PlatformNotSupported, 'UNIX domain sockets not available on Windows' if Thin.win?
+        @socket = socket
+        super()
+      end
+      
+      # Connect the server
+      def connect
+        at_exit { remove_socket_file } # In case it crashes
+        EventMachine.start_unix_domain_server(@socket, UnixConnection, &method(:initialize_connection))
+        # HACK EventMachine.start_unix_domain_server doesn't return the connection signature
+        #      so we have to go in the internal stuff to find it.
+        @signature = EventMachine.instance_eval{@acceptors.keys.first}
+      end
+      
+      # Stops the server
+      def disconnect
+        EventMachine.stop_server(@signature)
+      end
+      
+      # Free up resources used by the backend.
+      def close
+        remove_socket_file
+      end
+      
+      def to_s
+        @socket
+      end
+      
+      protected
+        def remove_socket_file
+          File.delete(@socket) if @socket && File.exist?(@socket)
+        end
+    end    
+  end
+
+  # Connection through a UNIX domain socket.
+  class UnixConnection < Connection
+    protected
+      def socket_address        
+        '127.0.0.1' # Unix domain sockets can only be local
+      end
+  end
+end

data/lib/thin/command.rb

@@ -0,0 +1,53 @@
+require 'open3'
+
+module Thin
+  # Run a command through the +thin+ command-line script.
+  class Command
+    include Logging
+    
+    class << self
+      # Path to the +thin+ script used to control the servers.
+      # Leave this to default to use the one in the path.
+      attr_accessor :script
+    end
+    
+    def initialize(name, options={})
+      @name    = name
+      @options = options
+    end
+    
+    def self.run(*args)
+      new(*args).run
+    end
+    
+    # Send the command to the +thin+ script
+    def run
+      shell_cmd = shellify
+      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?
+      end
+    end
+    
+    # Turn into a runnable shell command
+    def shellify
+      shellified_options = @options.inject([]) do |args, (name, value)|
+        option_name = name.to_s.tr("_", "-")
+        case value
+        when NilClass,
+             TrueClass then args << "--#{option_name}"
+        when FalseClass
+        when Array     then value.each { |v| args << "--#{option_name}=#{v.inspect}" }
+        else                args << "--#{option_name}=#{value.inspect}"
+        end
+        args
+      end
+      
+      raise ArgumentError, "Path to thin script can't be found, set Command.script" unless self.class.script
+      
+      "#{self.class.script} #{@name} #{shellified_options.compact.join(' ')}"
+    end
+  end
+end

data/lib/thin/connection.rb

@@ -0,0 +1,222 @@
+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
+    CONTENT_LENGTH    = 'Content-Length'.freeze
+    TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+    CHUNKED_REGEXP    = /\bchunked\b/i.freeze
+
+    include Logging
+    
+    # This is a template async response. N.B. Can't use string for body on 1.9
+    AsyncResponse = [-1, {}, []].freeze
+    
+    # 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 }
+      process if @request.parse(data)
+    rescue InvalidRequest => e
+      log "!! Invalid request"
+      log_error e
+      close_connection
+    end
+
+    # Called when all data was received and the request
+    # is ready to be processed.
+    def process
+      if threaded?
+        @request.threaded = true
+        EventMachine.defer(method(:pre_process), method(:post_process))
+      else
+        @request.threaded = false
+        post_process(pre_process)
+      end
+    end
+
+    def pre_process
+      # Add client info to the request env
+      @request.remote_address = remote_address
+
+      # Connection may be closed unless the App#call response was a [-1, ...]
+      # It should be noted that connection objects will linger until this 
+      # callback is no longer referenced, so be tidy!
+      @request.async_callback = method(:post_process)
+      
+      # When we're under a non-async framework like rails, we can still spawn
+      # off async responses using the callback info, so there's little point
+      # in removing this.
+      response = AsyncResponse
+      catch(:async) do
+        # Process the request calling the Rack adapter
+        response = @app.call(@request.env)
+      end
+      response
+    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
+      result = result.to_a
+      
+      # Status code -1 indicates that we're going to respond later (async).
+      return if result.first == AsyncResponse.first
+
+      # 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
+
+    rescue Exception
+      handle_error
+    ensure
+      # If the body is being deferred, then terminate afterward.
+      if @response.body.respond_to?(:callback) && @response.body.respond_to?(:errback)
+        @response.body.callback { terminate_request }
+        @response.body.errback  { terminate_request }
+      else
+        # Don't terminate the response if we're going async.
+        terminate_request unless result && result.first == AsyncResponse.first
+      end
+    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
+
+    def close_request_response
+      @request.async_close.succeed if @request.async_close
+      @request.close  rescue nil
+      @response.close 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
+      unless persistent?
+        close_connection_after_writing rescue nil
+        close_request_response
+      else
+        close_request_response
+        # Prepare the connection for another request if the client
+        # supports HTTP pipelining (persistent connection).
+        post_init
+      end
+    end
+
+    # Called when the connection is unbinded from the socket
+    # and can no longer be used to process requests.
+    def unbind
+      @request.async_close.succeed if @request.async_close
+      @response.body.fail if @response.body.respond_to?(:fail)
+      @backend.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
+
+    # +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
+      socket_address
+    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 status == -1
+        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

data/lib/thin/controllers/cluster.rb

@@ -0,0 +1,178 @@
+require 'socket'
+
+module Thin
+  # An exception class to handle the event that server didn't start on time
+  class RestartTimeout < RuntimeError; end
+  
+  module Controllers
+    # Control a set of servers.
+    # * Generate start and stop commands and run them.
+    # * Inject the port or socket number in the pid and log filenames.
+    # Servers are started throught the +thin+ command-line script.
+    class Cluster < Controller
+      # Cluster only options that should not be passed in the command sent
+      # to the indiviual servers.
+      CLUSTER_OPTIONS = [:servers, :only, :onebyone, :wait]
+      
+      # Maximum wait time for the server to be restarted
+      DEFAULT_WAIT_TIME = 30    # seconds
+      
+      # Create a new cluster of servers launched using +options+.
+      def initialize(options)
+        super
+        # Cluster can only contain daemonized servers
+        @options.merge!(:daemonize => true)
+      end
+      
+      def first_port; @options[:port]     end
+      def address;    @options[:address]  end
+      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 onebyone;   @options[:onebyone] end
+      def wait;       @options[:wait]     end
+      
+      def swiftiply?
+        @options.has_key?(:swiftiply)
+      end
+    
+      # Start the servers
+      def start
+        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, number
+      end
+  
+      # Stop the servers
+      def stop
+        with_each_server { |n| stop_server n }
+      end
+    
+      # Stop a single server
+      def stop_server(number)
+        log "Stopping server on #{server_id(number)} ... "
+      
+        run :stop, number
+      end
+    
+      # Stop and start the servers.
+      def restart
+        unless onebyone
+          # Let's do a normal restart by defaults
+          stop
+          sleep 0.1 # Let's breath a bit shall we ?
+          start
+        else
+          with_each_server do |n| 
+            stop_server(n)
+            sleep 0.1 # Let's breath a bit shall we ?
+            start_server(n)
+            wait_until_server_started(n)
+          end
+        end
+      end
+      
+      def test_socket(number)
+        if socket
+          UNIXSocket.new(socket_for(number))
+        else
+          TCPSocket.new(address, number)
+        end
+      rescue
+        nil
+      end
+      
+      # 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 ..."
+        STDOUT.flush # Need this to make sure user got the message
+        
+        tries = 0
+        loop do
+          if test_socket = test_socket(number)
+            test_socket.close
+            break
+          elsif tries < wait
+            sleep 1
+            tries += 1
+          else
+            raise RestartTimeout, "The server didn't start in time. Please look at server's log file " +
+                                  "for more information, or set the value of 'wait' in your config " +
+                                  "file to be higher (defaults: 30)."
+          end
+        end
+      end
+    
+      def server_id(number)
+        if socket
+          socket_for(number)
+        elsif swiftiply?
+          [address, first_port, number].join(':')
+        else
+          [address, number].join(':')
+        end
+      end
+    
+      def log_file_for(number)
+        include_server_number log_file, number
+      end
+    
+      def pid_file_for(number)
+        include_server_number pid_file, number
+      end
+    
+      def socket_for(number)
+        include_server_number socket, number
+      end
+    
+      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, 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
+          Command.run(cmd, cmd_options)
+        end
+      
+        def with_each_server
+          if only
+            if first_port && only < 80
+              # interpret +only+ as a sequence number
+              yield first_port + only
+            else
+              # interpret +only+ as an absolute port number
+              yield only
+            end
+          elsif socket || swiftiply?
+            size.times { |n| yield n }
+          else
+            size.times { |n| yield first_port + n }
+          end
+        end
+      
+        # Add the server port or number in the filename
+        # so each instance get its own file
+        def include_server_number(path, number)
+          ext = File.extname(path)
+          path.gsub(/#{ext}$/, ".#{number}#{ext}")
+        end
+    end
+  end
+end