thin 1.2.3-x86-mswin32

data/lib/thin/controllers/controller.rb

@@ -0,0 +1,183 @@
+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=)
+
+        # 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 ">> 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 ">> 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$/
+            rackup_code = File.read(@options[:rackup])
+            eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, @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,75 @@
+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)
+        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 ">> 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 "on Gentoo:"
+        log "  sudo rc-update add #{NAME} default"
+        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

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,174 @@
+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::ESRCH
+    false
+  end
+  module_function :running?
+end
+
+module Thin
+  # Raised when the pid file already exist starting as a daemon.
+  class PidFileExist < 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 processs 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) ? 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
+      
+      Daemonize.daemonize(File.expand_path(@log_file), name)
+      
+      Dir.chdir(pwd)
+      
+      write_pid_file
+      
+      trap('HUP') { restart }
+      at_exit do
+        log ">> Exiting!"
+        remove_pid_file
+      end
+    end
+
+    # Change privileges of the process
+    # to the specified user and group.
+    def change_privilege(user, group=user)
+      log ">> 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 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 "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
+      raise ArgumentError, "Can't restart, no 'on_restart' proc specified" unless @on_restart
+      log '>> Restarting ...'
+      stop
+      remove_pid_file
+      @on_restart.call
+      exit!
+    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 "Sending #{signal} signal to process #{pid} ... "
+          Process.kill(signal, pid)
+          Timeout.timeout(timeout) do
+            sleep 0.1 while Process.running?(pid)
+          end
+        else
+          Logging.log "Can't stop process, no PID found in #{pid_file}"
+        end
+      rescue Timeout::Error
+        Logging.log "Timeout!"
+        force_kill pid_file
+      rescue Interrupt
+        force_kill pid_file
+      rescue Errno::ESRCH # No such process
+        Logging.log "process not found!"
+        force_kill pid_file
+      end
+      
+      def force_kill(pid_file)
+        if pid = read_pid_file(pid_file)
+          Logging.log "Sending KILL signal to process #{pid} ... "
+          Process.kill("KILL", pid)
+          File.delete(pid_file) if File.exist?(pid_file)
+        else
+          Logging.log "Can't stop process, no PID found in #{pid_file}"
+        end
+      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 ">> Writing PID to #{@pid_file}"
+        FileUtils.mkdir_p File.dirname(@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 ">> Deleting stale PID file #{@pid_file}"
+            remove_pid_file
+          end
+        end
+      end
+  end
+end