thin 0.6.2-x86-mswin32-60 → 0.6.3-x86-mswin32-60

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

data/lib/thin/controllers/service.rb

@@ -0,0 +1,73 @@
+require 'erb'
+
+module Thin
+  module Controllers
+    # System service controller to launch all servers which
+    # config files are in a directory.
+    class Service < Controller
+      INITD_PATH          = '/etc/init.d/thin'
+      DEFAULT_CONFIG_PATH = '/etc/thin'
+      TEMPLATE            = File.dirname(__FILE__) + '/service.sh.erb'
+    
+      def initialize(options)
+        @options = options
+      
+        raise PlatformNotSupported, 'Running as a service only supported on Linux' unless Thin.linux?
+      end
+    
+      def config_path
+        @options[:all] || DEFAULT_CONFIG_PATH
+      end
+    
+      def start
+        run :start
+      end
+    
+      def stop
+        run :stop
+      end
+    
+      def restart
+        run :restart
+      end
+    
+      def install(config_files_path=DEFAULT_CONFIG_PATH)
+        if File.exist?(INITD_PATH)
+          log ">> Thin service already installed at #{INITD_PATH}"
+        else
+          log ">> Installing thin service at #{INITD_PATH} ..."
+          sh "mkdir -p #{File.dirname(INITD_PATH)}"
+          log "writing #{INITD_PATH}"        
+          File.open(INITD_PATH, 'w') do |f|
+            f << ERB.new(File.read(TEMPLATE)).result(binding)
+          end
+          sh "chmod +x #{INITD_PATH}" # Make executable
+        end
+      
+        sh "mkdir -p #{config_files_path}"
+
+        log ''
+        log "To configure thin to start at system boot:"
+        log "on RedHat like systems:"
+        log "  sudo /sbin/chkconfig --level 345 #{NAME} on"
+        log "on Debian like systems (Ubuntu):"
+        log "  sudo /usr/sbin/update-rc.d -f #{NAME} defaults"
+        log ''
+        log "Then put your config files in #{config_files_path}"
+      end
+    
+      private
+        def run(command)
+          Dir[config_path + '/*'].each do |config|
+            log "[#{command}] #{config} ..."
+            Command.run(command, :config => config, :daemonize => true)
+          end
+        end
+      
+        def sh(cmd)
+          log cmd
+          system(cmd)
+        end
+    end
+  end
+end