thin 1.8.2 → 2.0.0.pre

data/lib/thin/controllers/cluster.rb

@@ -1,178 +0,0 @@
-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

data/lib/thin/controllers/controller.rb

@@ -1,189 +0,0 @@
-require 'yaml'
-
-module Thin
-  # Error raised that will abort the process and print not backtrace.
-  class RunnerError < RuntimeError; end
-  
-  # Raised when a mandatory option is missing to run a command.
-  class OptionRequired < RunnerError
-    def initialize(option)
-      super("#{option} option required")
-    end
-  end
-  
-  # Raised when an option is not valid.
-  class InvalidOption < RunnerError; end
-  
-  # Build and control Thin servers.
-  # Hey Controller pattern is not only for web apps yo!
-  module Controllers  
-    # Controls one 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
-        
-        if @options[:socket]
-          @options.delete(:address)
-          @options.delete(:port)
-        end
-      end
-    
-      def start
-        # Constantize backend class
-        @options[:backend] = eval(@options[:backend], TOPLEVEL_BINDING) if @options[:backend]
-
-        server = Server.new(@options[:socket] || @options[:address], # Server detects kind of socket
-                            @options[:port],                         # Port ignored on UNIX socket
-                            @options)
-        
-        # Set options
-        server.pid_file                       = @options[:pid]
-        server.log_file                       = @options[:log]
-        server.timeout                        = @options[:timeout]
-        server.maximum_connections            = @options[:max_conns]
-        server.maximum_persistent_connections = @options[:max_persistent_conns]
-        server.threaded                       = @options[:threaded]
-        server.no_epoll                       = @options[:no_epoll] if server.backend.respond_to?(:no_epoll=)
-        server.threadpool_size                = @options[:threadpool_size] if server.threaded?
-
-        # ssl support
-        if @options[:ssl]
-          server.ssl = true
-          server.ssl_options = { :private_key_file => @options[:ssl_key_file], :cert_chain_file => @options[:ssl_cert_file], :verify_peer => !@options[:ssl_disable_verify], :ssl_version => @options[:ssl_version], :cipher_list => @options[:ssl_cipher_list]}
-        end
-
-        # Detach the process, after this line the current process returns
-        server.daemonize if @options[:daemonize]
-
-        # +config+ must be called before changing privileges since it might require superuser power.
-        server.config
-        
-        server.change_privilege @options[:user], @options[:group] if @options[:user] && @options[:group]
-
-        # If a Rack config file is specified we eval it inside a Rack::Builder block to create
-        # a Rack adapter from it. Or else we guess which adapter to use and load it.
-        if @options[:rackup]
-          server.app = load_rackup_config
-        else
-          server.app = load_adapter
-        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 URL is specified, wrap in Stats adapter
-        server.app = Stats::Adapter.new(server.app, @options[:stats]) if @options[:stats]
-
-        # Register restart procedure which just start another process with same options,
-        # so that's why this is done here.
-        server.on_restart { Command.run(:start, @options) }
-
-        server.start
-      end
-    
-      def stop
-        raise OptionRequired, :pid unless @options[:pid]
-      
-        tail_log(@options[:log]) do
-          if Server.kill(@options[:pid], @options[:force] ? 0 : (@options[:timeout] || 60))
-            wait_for_file :deletion, @options[:pid]
-          end
-        end
-      end
-    
-      def restart
-        raise OptionRequired, :pid unless @options[:pid]
-        
-        tail_log(@options[:log]) do
-          if Server.restart(@options[:pid])
-            wait_for_file :creation, @options[:pid]
-          end
-        end
-      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_info "Wrote configuration to #{config_file}"
-      end
-      
-      protected
-        # Wait for a pid file to either be created or deleted.
-        def wait_for_file(state, file)
-          Timeout.timeout(@options[:timeout] || 30) do
-            case state
-            when :creation then sleep 0.1 until File.exist?(file)
-            when :deletion then sleep 0.1 while File.exist?(file)
-            end
-          end
-        end
-        
-        # Tail the log file of server +number+ during the execution of the block.        
-        def tail_log(log_file)
-          if log_file
-            tail_thread = tail(log_file)
-            yield
-            tail_thread.kill
-          else
-            yield
-          end
-        end
-        
-        # Acts like GNU tail command. Taken from Rails.
-        def tail(file)
-          cursor = File.exist?(file) ? File.size(file) : 0
-          last_checked = Time.now
-          tail_thread = Thread.new do
-            Thread.pass until File.exist?(file)
-            File.open(file, 'r') do |f|
-              loop do
-                f.seek cursor
-                if f.mtime > last_checked
-                  last_checked = f.mtime
-                  contents = f.read
-                  cursor += contents.length
-                  print contents
-                  STDOUT.flush
-                end
-                sleep 0.1
-              end
-            end
-          end
-          sleep 1 if File.exist?(file) # HACK Give the thread a little time to open the file
-          tail_thread
-        end
-
-      private
-        def load_adapter
-          adapter = @options[:adapter] || Rack::Adapter.guess(@options[:chdir])
-          log_info "Using #{adapter} adapter"
-          Rack::Adapter.for(adapter, @options)
-        rescue Rack::AdapterNotFound => e
-          raise InvalidOption, e.message
-        end
-        
-        def load_rackup_config
-          ENV['RACK_ENV'] = @options[:environment]
-          case @options[:rackup]
-          when /\.rb$/
-            Kernel.load(@options[:rackup])
-            Object.const_get(File.basename(@options[:rackup], '.rb').capitalize.to_sym)
-          when /\.ru$/
-            Rack::Adapter.load(@options[:rackup])
-          else
-            raise "Invalid rackup file.  please specify either a .ru or .rb file"
-          end
-        end
-    end
-  end
-end

data/lib/thin/controllers/service.rb

@@ -1,76 +0,0 @@
-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          = File.directory?('/etc/rc.d') ? '/etc/rc.d/thin' : '/etc/init.d/thin'
-      DEFAULT_CONFIG_PATH = '/etc/thin'
-      TEMPLATE            = File.dirname(__FILE__) + '/service.sh.erb'
-    
-      def initialize(options)
-        super
-      
-        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_info "Thin service already installed at #{INITD_PATH}"
-        else
-          log_info "Installing thin service at #{INITD_PATH} ..."
-          sh "mkdir -p #{File.dirname(INITD_PATH)}"
-          log_info "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_info ''
-        log_info "To configure thin to start at system boot:"
-        log_info "on RedHat like systems:"
-        log_info "  sudo /sbin/chkconfig --level 345 #{NAME} on"
-        log_info "on Debian-like systems (Ubuntu):"
-        log_info "  sudo /usr/sbin/update-rc.d -f #{NAME} defaults"
-        log_info "on Gentoo:"
-        log_info "  sudo rc-update add #{NAME} default"
-        log_info ''
-        log_info "Then put your config files in #{config_files_path}"
-      end
-    
-      private
-        def run(command)
-          Dir[config_path + '/*'].each do |config|
-            next if config.end_with?("~")
-            log_info "[#{command}] #{config} ..."
-            Command.run(command, :config => config, :daemonize => true)
-          end
-        end
-      
-        def sh(cmd)
-          log_info cmd
-          system(cmd)
-        end
-    end
-  end
-end

data/lib/thin/controllers/service.sh.erb

@@ -1,39 +0,0 @@
-#!/bin/sh
-### BEGIN INIT INFO
-# Provides:          thin
-# Required-Start:    $local_fs $remote_fs
-# Required-Stop:     $local_fs $remote_fs
-# Default-Start:     2 3 4 5
-# Default-Stop:      S 0 1 6
-# Short-Description: thin initscript
-# Description:       thin
-### END INIT INFO
-
-# Original author: Forrest Robertson
-
-# Do NOT "set -e"
-
-DAEMON=<%= Command.script %>
-SCRIPT_NAME=<%= INITD_PATH %>
-CONFIG_PATH=<%= config_files_path %>
-
-# Exit if the package is not installed
-[ -x "$DAEMON" ] || exit 0
-
-case "$1" in
-  start)
-	$DAEMON start --all $CONFIG_PATH
-	;;
-  stop)
-	$DAEMON stop --all $CONFIG_PATH
-	;;
-  restart)
-	$DAEMON restart --all $CONFIG_PATH
-	;;
-  *)
-	echo "Usage: $SCRIPT_NAME {start|stop|restart}" >&2
-	exit 3
-	;;
-esac
-
-:

data/lib/thin/daemonizing.rb

@@ -1,199 +0,0 @@
-require 'etc'
-require 'daemons' unless Thin.win?
-
-module Process
-  # Returns +true+ the process identied by +pid+ is running.
-  def running?(pid)
-    Process.getpgid(pid) != -1
-  rescue Errno::EPERM
-    true
-  rescue Errno::ESRCH
-    false
-  end
-  module_function :running?
-end
-
-module Thin
-  # Raised when the pid file already exist starting as a daemon.
-  class PidFileExist < RuntimeError; end
-  class PidFileNotFound < RuntimeError; end
-  
-  # Module included in classes that can be turned into a daemon.
-  # Handle stuff like:
-  # * storing the PID in a file
-  # * redirecting output to the log file
-  # * changing process privileges
-  # * killing the process gracefully
-  module Daemonizable
-    attr_accessor :pid_file, :log_file
-    
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    def pid
-      File.exist?(pid_file) && !File.zero?(pid_file) ? open(pid_file).read.to_i : nil
-    end
-
-    def kill(timeout = 60)
-      if File.exist?(@pid_file)
-        self.class.kill(@pid_file, timeout)
-      end
-    end
-
-    # Turns the current script into a daemon process that detaches from the console.
-    def daemonize
-      raise PlatformNotSupported, 'Daemonizing is not supported on Windows'     if Thin.win?
-      raise ArgumentError,        'You must specify a pid_file to daemonize' unless @pid_file
-      
-      remove_stale_pid_file
-      
-      pwd = Dir.pwd # Current directory is changed during daemonization, so store it
-      
-      # HACK we need to create the directory before daemonization to prevent a bug under 1.9
-      #      ignoring all signals when the directory is created after daemonization.
-      FileUtils.mkdir_p File.dirname(@pid_file)
-      FileUtils.mkdir_p File.dirname(@log_file)
-      
-      Daemonize.daemonize(File.expand_path(@log_file), name)
-      
-      Dir.chdir(pwd)
-      
-      write_pid_file
-
-      at_exit do
-        log_info "Exiting!"
-        remove_pid_file
-      end
-    end
-
-    # Change privileges of the process
-    # to the specified user and group.
-    def change_privilege(user, group=user)
-      log_info "Changing process privilege to #{user}:#{group}"
-      
-      uid, gid = Process.euid, Process.egid
-      target_uid = Etc.getpwnam(user).uid
-      target_gid = Etc.getgrnam(group).gid
-
-      if uid != target_uid || gid != target_gid
-        # Change PID file ownership
-        File.chown(target_uid, target_gid, @pid_file) if File.exist?(@pid_file)
-
-        # Change process ownership
-        Process.initgroups(user, target_gid)
-        Process::GID.change_privilege(target_gid)
-        Process::UID.change_privilege(target_uid)
-
-        # Correct environment variables
-        ENV.store('USER', user)
-        ENV.store('HOME', File.expand_path("~#{user}"))
-      end
-    rescue Errno::EPERM => e
-      log_info "Couldn't change user and group to #{user}:#{group}: #{e}"
-    end
-    
-    # Register a proc to be called to restart the server.
-    def on_restart(&block)
-      @on_restart = block
-    end
-    
-    # Restart the server.
-    def restart
-      if @on_restart
-        log_info 'Restarting ...'
-        stop
-        remove_pid_file
-        @on_restart.call
-        EM.next_tick { exit! }
-      end
-    end
-    
-    module ClassMethods
-      # Send a QUIT or INT (if timeout is +0+) signal the process which
-      # PID is stored in +pid_file+.
-      # If the process is still running after +timeout+, KILL signal is
-      # sent.
-      def kill(pid_file, timeout=60)
-        if timeout == 0
-          send_signal('INT', pid_file, timeout)
-        else
-          send_signal('QUIT', pid_file, timeout)
-        end
-      end
-      
-      # Restart the server by sending HUP signal.
-      def restart(pid_file)
-        send_signal('HUP', pid_file)
-      end
-
-      def monotonic_time
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      # Send a +signal+ to the process which PID is stored in +pid_file+.
-      def send_signal(signal, pid_file, timeout=60)
-        if pid = read_pid_file(pid_file)
-          Logging.log_info "Sending #{signal} signal to process #{pid} ... "
-
-          Process.kill(signal, pid)
-
-          # This loop seems kind of racy to me...
-          started_at = monotonic_time
-          while Process.running?(pid)
-            sleep 0.1
-            raise Timeout::Error if (monotonic_time - started_at) > timeout
-          end
-        else
-          raise PidFileNotFound, "Can't stop process, no PID found in #{pid_file}"
-        end
-      rescue Timeout::Error
-        Logging.log_info "Timeout!"
-        force_kill(pid, pid_file)
-      rescue Interrupt
-        force_kill(pid, pid_file)
-      rescue Errno::ESRCH # No such process
-        Logging.log_info "process not found!"
-        force_kill(pid, pid_file)
-      end
-      
-      def force_kill(pid, pid_file)
-        Logging.log_info "Sending KILL signal to process #{pid} ... "
-        Process.kill("KILL", pid)
-        File.delete(pid_file) if File.exist?(pid_file)
-      end
-      
-      def read_pid_file(file)
-        if File.file?(file) && pid = File.read(file)
-          pid.to_i
-        else
-          nil
-        end
-      end
-    end
-    
-    protected
-      def remove_pid_file
-        File.delete(@pid_file) if @pid_file && File.exist?(@pid_file)
-      end
-    
-      def write_pid_file
-        log_info "Writing PID to #{@pid_file}"
-        open(@pid_file,"w") { |f| f.write(Process.pid) }
-        File.chmod(0644, @pid_file)
-      end
-      
-      # If PID file is stale, remove it.
-      def remove_stale_pid_file
-        if File.exist?(@pid_file)
-          if pid && Process.running?(pid)
-            raise PidFileExist, "#{@pid_file} already exists, seems like it's already running (process ID: #{pid}). " +
-                                "Stop the process or delete #{@pid_file}."
-          else
-            log_info "Deleting stale PID file #{@pid_file}"
-            remove_pid_file
-          end
-        end
-      end
-  end
-end