michaelyta-thin 1.2.2

data/lib/thin/backends/tcp_server.rb

@@ -0,0 +1,68 @@
+require 'neverblock'
+require File.expand_path(File.dirname(__FILE__) + '/../connection')
+
+module Thin
+  module Backends
+    # Backend to act as a TCP socket server.
+    class TcpServer < Base
+      
+      # Allow using fibers in the backend.
+      def fibered?; true; end
+            
+      def initialize(host, port, options={})
+        @host    = host
+        @port    = port.to_i
+        @timeout = 30
+      end
+          
+      def start
+        @reactor = NB.reactor
+        @server_socket = TCPServer.new(@host, @port)
+        @server_socket.listen(511)
+        @reactor.attach(:read, @server_socket) do |server, reactor|
+          begin
+            loop do
+              connection = accept_connection
+            end
+          rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EINTR
+          rescue Exception => e
+          end
+        end        
+        loop do
+          begin
+            @reactor.run
+            break unless @reactor.running?
+          rescue Exception => e
+          end
+        end
+        @server_socket.close
+      end
+      
+      def stop;@reactor.stop;end
+      
+      alias :stop! :stop
+            
+      def trace=(trace);@trace = trace;end
+      
+      def maxfds=(maxfds);raise "not implemented";end
+      
+      def maxfds;raise "not implemented";end
+      
+      def to_s;"#{@host}:#{@port} (NeverBlock)";end
+      
+      def running?;@reactor.running?;end
+      
+      protected
+        
+        def accept_connection
+          socket = @server_socket.accept_nonblock
+          connection = ::Thin::ReactorConnection.new(socket, @reactor)
+          connection.backend                 = self
+          connection.app                     = @server.app
+          connection.threaded                = false
+          connection.post_init
+        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,214 @@
+require 'neverblock/io/io'
+ 
+module Thin
+  # Connection between the server and client.
+  # This class is instanciated by EventMachine on each new connection
+  # that is opened.
+  class ReactorConnection
+ 
+    CONTENT_LENGTH    = 'Content-Length'.freeze
+    TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+    CHUNKED_REGEXP    = /\bchunked\b/i.freeze
+ 
+    # whenever we accumulate this buffer size we flush to the socket
+    # when flush is called the buffer is emptied (and the conn is blocked)
+    BUFFER_SIZE = 256*1024  
+
+    include Logging
+        
+    # 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
+ 
+    # Calling the application in a fiber allowing
+    # concurrent processing of requests.
+    attr_writer :fibered
+    attr_writer :reactor 
+    attr_writer :socket 
+    
+    def initialize(socket, reactor)
+      @socket = socket
+      @reactor = reactor
+      @data = ""
+      @sends = 0
+      @t = Time.now
+      @request  = Request.new
+      @response = Response.new
+    end
+    
+    def post_init
+      @request  = Request.new
+      @response = Response.new
+      @reactor.attach(:read, @socket) do |socket, reactor|
+        begin          
+          receive_data(@socket.read_nonblock(8*1024))
+        rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EINTR
+        rescue Exception => e
+          close_connection
+        end
+      end
+    end
+  
+    def close_connection(after_writing=false)
+      unless after_writing
+        @reactor.detach(:read, @socket)
+      end
+      if after_writing        
+        @reactor.detach(:read, @socket) unless @reactor.attached?(:read, @socket)
+        @socket.close unless @socket.closed?
+      end
+    end
+
+    def close_connection_after_writing
+      close_connection(true)
+    end
+    
+    def send_data(data)
+      @data << data 
+      flush_data if @data.length >= BUFFER_SIZE
+    end
+
+    def flush_data
+      return if @data.blank?
+      begin
+        @socket.syswrite(@data)
+      rescue Exception => e
+        puts e
+        close_connection
+        return 
+      end
+      @data = ''      
+    end
+
+    # Called when data is received from the client.
+    def receive_data(data)  
+      trace { data }
+      post_process(pre_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 pre_process
+      @app.call(@request.env)
+    rescue Exception
+      handle_error
+      terminate_request
+      nil # Signal to post_process that the request could not be processed
+    end
+ 
+    def post_process(result)
+      begin
+        return unless result
+        result = result.to_a
+        # 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?
+        # Send the response
+        @response.each do |chunk|
+          trace { chunk }
+          send_data chunk
+        end
+        flush_data
+      rescue Exception
+        handle_error
+      ensure
+        terminate_request
+      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.close  rescue nil
+      @response.close rescue nil
+    end
+ 
+    def terminate_request
+      close_connection_after_writing rescue nil
+      close_request_response
+    end
+  
+    # Allows this connection to be persistent.
+    def can_persist!
+    end
+ 
+    # Return +true+ if this connection is allowed to stay open and be persistent.
+    def can_persist?
+      false
+    end
+ 
+    # Return +true+ if the connection must be left open
+    # and ready to be reused for another request.
+    def persistent?
+      false
+    end
+ 
+    def threaded?
+      false
+    end
+ 
+    # IP Address of the remote client.
+    def remote_address
+      @request.forwarded_for || 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,127 @@
+module Thin
+  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]
+      
+      # 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 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
+        stop
+        sleep 0.1 # Let's breath a bit shall we ?
+        start
+      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