thin 0.6.2 → 0.6.3

data/lib/thin.rb

@@ -11,10 +11,6 @@ require 'thin/version'
 require 'thin/statuses'
 
 module Thin
-  NAME    = 'thin'.freeze
-  SERVER  = "#{NAME} #{VERSION::STRING} codename #{VERSION::CODENAME}".freeze  
-  
-  autoload :Cluster,      'thin/cluster'
   autoload :Command,      'thin/command'
   autoload :Connection,   'thin/connection'
   autoload :Daemonizable, 'thin/daemonizing'
@@ -22,8 +18,21 @@ module Thin
   autoload :Headers,      'thin/headers'
   autoload :Request,      'thin/request'
   autoload :Response,     'thin/response'
+  autoload :Runner,       'thin/runner'
   autoload :Server,       'thin/server'
   autoload :Stats,        'thin/stats'
+  
+  module Connectors
+    autoload :Connector,  'thin/connectors/connector'
+    autoload :TcpServer,  'thin/connectors/tcp_server'
+    autoload :UnixServer, 'thin/connectors/unix_server'
+  end
+  
+  module Controllers
+    autoload :Cluster,    'thin/controllers/cluster'
+    autoload :Controller, 'thin/controllers/controller'
+    autoload :Service,    'thin/controllers/service'
+  end
 end
 
 require 'rack'

data/lib/thin/command.rb

@@ -3,14 +3,15 @@ module Thin
   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
+    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
-      @script  = $PROGRAM_NAME
     end
     
     def self.run(*args)
@@ -34,7 +35,10 @@ module Thin
         else                "--#{name.to_s.tr('_', '-')}=#{value.inspect}"
         end
       end
-      "#{@script} #{@name} #{shellified_options.compact.join(' ')}"
+      
+      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

@@ -1,17 +1,15 @@
 require 'socket'
 
 module Thin
+  # Connection between the server and client.
   class Connection < EventMachine::Connection
     include Logging
     
     # Rack application served by this connection.
     attr_accessor :app
     
-    # +true+ if the connection is on a UNIX domain socket.
-    attr_accessor :unix_socket
-    
-    # Server owning the connection
-    attr_accessor :server
+    # Connector to the server
+    attr_accessor :connector
     
     def post_init
       @request  = Request.new
@@ -52,19 +50,12 @@ module Thin
     end
     
     def unbind
-      @server.connection_finished(self)
+      @connector.connection_finished(self)
     end
     
     protected
       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?
-          Socket.unpack_sockaddr_un(get_peername)
-        else
-          Socket.unpack_sockaddr_in(get_peername)[1]
-        end
+        @request.env[Request::FORWARDED_FOR] || Socket.unpack_sockaddr_in(get_peername)[1]
       end
   end
 end

data/lib/thin/connectors/connector.rb

@@ -0,0 +1,61 @@
+module Thin
+  module Connectors
+    # A Connector connect the server to the client. It handles:
+    # * connection/disconnection to the server
+    # * initialization of the connections
+    # * manitoring of the active connections.
+    class Connector
+      include Logging
+      
+      # Server serving the connections throught the connector
+      attr_reader :server
+      
+      # Maximum time for incoming data to arrive
+      attr_accessor :timeout
+      
+      def initialize
+        @connections = []
+        @timeout     = 60 # sec
+      end
+            
+      # Free up resources used by the connector.
+      def close
+      end
+      
+      def server=(server)
+        @server = server
+        @silent = @server.silent
+      end
+            
+      # Initialize a new connection to a client.
+      def initialize_connection(connection)
+        connection.connector               = self
+        connection.app                     = @server.app
+        connection.comm_inactivity_timeout = @timeout
+        connection.silent                  = @silent
+
+        @connections << connection
+      end
+      
+      # Close all active connections.
+      def close_connections
+        @connections.each { |connection| connection.close_connection }
+      end
+      
+      # Called by a connection when it's unbinded.
+      def connection_finished(connection)
+        @connections.delete(connection)
+      end
+      
+      # Returns +true+ if no active connection.
+      def empty?
+        @connections.empty?
+      end
+      
+      # Number of active connections.
+      def size
+        @connections.size
+      end
+    end
+  end
+end

data/lib/thin/connectors/tcp_server.rb

@@ -0,0 +1,29 @@
+module Thin
+  module Connectors
+    # Connectior to act as a TCP socket server.
+    class TcpServer < Connector
+      # 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/connectors/unix_server.rb

@@ -0,0 +1,48 @@
+module Thin
+  module Connectors
+    # Connectior to act as a UNIX domain socket server.
+    class UnixServer < Connector
+      # UNIX domain socket on which the server is listening for connections.
+      attr_accessor :socket
+      
+      def initialize(socket)
+        raise PlatformNotSupported, 'UNIX 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
+        @signature = EventMachine.start_unix_domain_server(@socket, UnixConnection, &method(:initialize_connection))
+      end
+      
+      # Stops the server
+      def disconnect
+        EventMachine.stop_server(@signature)
+      end
+      
+      # Free up resources used by the connector.
+      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
+
+  class UnixConnection < Connection
+    protected
+      def remote_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

@@ -0,0 +1,115 @@
+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
+      # Number of servers in the cluster.
+      attr_accessor :size
+        
+      # 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
+      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
+    
+      # Start the servers
+      def start
+        with_each_server { |port| start_server port }
+      end
+    
+      # Start a single server
+      def start_server(number)
+        log "Starting server on #{server_id(number)} ... "
+      
+        run :start, @options, 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, @options, 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)
+        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, options, number)
+          cmd_options = options.dup
+          cmd_options.merge!(:pid => pid_file_for(number), :log => log_file_for(number))
+          if socket
+            cmd_options.merge!(:socket => socket_for(number))
+          else
+            cmd_options.merge!(:port => number)
+          end
+          Command.run(cmd, cmd_options)
+        end
+      
+        def with_each_server
+          if @only
+            yield @only
+          else
+            @size.times do |n|
+              yield socket ? n : (first_port + n)
+            end
+          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

data/lib/thin/controllers/controller.rb

@@ -0,0 +1,85 @@
+require 'yaml'
+
+module Thin
+  module Controllers
+    # Raised when a mandatory option is missing to run a command.
+    class OptionRequired < RuntimeError
+      def initialize(option)
+        super("#{option} option required")
+      end
+    end
+  
+    # Controls a Thin server.
+    # Allow to start, stop, restart and configure a single thin server.
+    class Controller
+      include Logging
+    
+      # Command line options passed to the thin script
+      attr_accessor :options
+    
+      def initialize(options)
+        @options = options
+      end
+    
+      def start
+        if @options[:socket]
+          server = Server.new(@options[:socket])
+        else
+          server = Server.new(@options[:address], @options[:port])
+        end
+
+        server.pid_file = @options[:pid]
+        server.log_file = @options[:log]
+        server.timeout  = @options[:timeout]
+
+        if @options[:daemonize]
+          server.daemonize
+          server.change_privilege @options[:user], @options[:group] if @options[:user] && @options[:group]
+        end
+
+        # 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])
+        else
+          server.app = Rack::Adapter::Rails.new(@options.merge(:root => @options[:chdir]))
+        end
+
+        # 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
+        server.app = Stats::Adapter.new(server.app, @options[:stats]) if @options[:stats]
+
+        # Register restart procedure
+        server.on_restart { Command.run(:start, @options) }
+
+        server.start
+      end
+    
+      def stop
+        raise OptionRequired, :pid unless @options[:pid]
+      
+        Server.kill(@options[:pid], @options[:timeout] || 60)
+      end
+    
+      def restart
+        raise OptionRequired, :pid unless @options[:pid]
+      
+        Server.restart(@options[:pid])
+      end
+    
+      def config
+        config_file = @options.delete(:config) || raise(OptionRequired, :config)
+
+        # Stringify keys
+        @options.keys.each { |o| @options[o.to_s] = @options.delete(o) }
+
+        File.open(config_file, 'w') { |f| f << @options.to_yaml }
+        log ">> Wrote configuration to #{config_file}"
+      end
+    end
+  end
+end