gross 1.7.2

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,34 @@
+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))
+        binary_name = EventMachine.get_sockname( @signature )
+        port_name = Socket.unpack_sockaddr_in( binary_name )
+        @port = port_name[0]
+        @host = port_name[1]
+        @signature
+      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,56 @@
+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
+        old_umask = File.umask(0)
+        begin
+          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}
+        ensure
+          File.umask(old_umask)
+        end
+      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_info stdout.gets until stdout.eof?
+        log_info 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,215 @@
+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
+
+    # 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)
+      @idle = false
+      trace data
+      process if @request.parse(data)
+    rescue InvalidRequest => e
+      log_error("Invalid request", e)
+      post_process Response::BAD_REQUEST
+    end
+
+    # Called when all data was received and the request
+    # is ready to be processed.
+    def process
+      if threaded?
+        @request.threaded = true
+        EventMachine.defer { post_process(pre_process) }
+      else
+        @request.threaded = false
+        post_process(pre_process)
+      end
+    end
+
+    def ssl_verify_peer(cert)
+      # In order to make the cert available later we have to have made at least
+      # a show of verifying it.
+      true
+    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)
+
+      if @backend.ssl?
+        @request.env["rack.url_scheme"] = "https"
+
+        if cert = get_peer_cert
+          @request.env['rack.peer_cert'] = cert
+        end
+      end
+
+      # 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 => e
+      unexpected_error(e)
+      # Pass through error response
+      can_persist? && @request.persistent? ? Response::PERSISTENT_ERROR : Response::ERROR
+    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
+
+      @response.status, @response.headers, @response.body = *result
+
+      log_error("Rack application returned nil body. " \
+                "Probably you wanted it to be an empty string?") if @response.body.nil?
+
+      # HEAD requests should not return a body.
+      @response.skip_body! if @request.head?
+
+      # 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 => e
+      unexpected_error(e)
+      # Close connection since we can't handle response gracefully
+      close_connection
+    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 information about an unexpected exceptional condition
+    def unexpected_error(e)
+      log_error("Unexpected error while processing request", e)
+    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
+        # Connection become idle but it's still open
+        @idle = true
+        # 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
+
+    # Return +true+ if the connection is open but is not
+    # processing any user requests
+    def idle?
+      @idle
+    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 => e
+      log_error('Could not infer remote address', e)
+      nil
+    end
+
+    protected
+      # Returns IP address of peer as a string.
+      def socket_address
+        peer = get_peername
+        Socket.unpack_sockaddr_in(peer)[1] if peer
+      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_info "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_info "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_info "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