gross 1.7.2

data/lib/thin/controllers/controller.rb

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

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

@@ -0,0 +1,39 @@
+#!/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

@@ -0,0 +1,180 @@
+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
+    
+    # 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.exists?(@pid_file)
+
+        # Change process ownership
+        Process.initgroups(user, target_gid)
+        Process::GID.change_privilege(target_gid)
+        Process::UID.change_privilege(target_uid)
+      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
+      
+      # 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)
+          Timeout.timeout(timeout) do
+            sleep 0.1 while Process.running?(pid)
+          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.exists?(@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