thin 1.8.0 → 2.0.0.pre

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.exists?(@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.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

data/lib/thin/headers.rb

@@ -1,40 +0,0 @@
-module Thin
-  # Store HTTP header name-value pairs direcly to a string
-  # and allow duplicated entries on some names.
-  class Headers
-    HEADER_FORMAT      = "%s: %s\r\n".freeze
-    ALLOWED_DUPLICATES = %w(set-cookie set-cookie2 warning www-authenticate).freeze
-    
-    def initialize
-      @sent = {}
-      @out = []
-    end
-    
-    # Add <tt>key: value</tt> pair to the headers.
-    # Ignore if already sent and no duplicates are allowed
-    # for this +key+.
-    def []=(key, value)
-      downcase_key = key.downcase
-      if !@sent.has_key?(downcase_key) || ALLOWED_DUPLICATES.include?(downcase_key)
-        @sent[downcase_key] = true
-        value = case value
-                when Time
-                  value.httpdate
-                when NilClass
-                  return
-                else
-                  value.to_s
-                end
-        @out << HEADER_FORMAT % [key, value]
-      end
-    end
-    
-    def has_key?(key)
-      @sent[key.downcase]
-    end
-    
-    def to_s
-      @out.join
-    end
-  end
-end

data/lib/thin/logging.rb

@@ -1,174 +0,0 @@
-require 'logger'
-
-module Thin
-  # To be included in classes to allow some basic logging
-  # that can be silenced (<tt>Logging.silent=</tt>) or made
-  # more verbose.
-  # <tt>Logging.trace=</tt>:  log all raw request and response and
-  #                           messages logged with +trace+.
-  # <tt>Logging.silent=</tt>: silence all log all log messages
-  #                           altogether.
-  module Logging
-    # Simple formatter which only displays the message.
-    # Taken from ActiveSupport
-    class SimpleFormatter < Logger::Formatter
-      def call(severity, timestamp, progname, msg)
-        "#{timestamp} #{String === msg ? msg : msg.inspect}\n"
-      end
-    end
-
-    @trace_logger = nil
-
-    class << self
-      attr_reader :logger
-      attr_reader :trace_logger
-
-      def trace=(enabled)
-        if enabled
-          @trace_logger ||= Logger.new(STDOUT)
-        else
-          @trace_logger = nil
-        end
-      end
-
-      def trace?
-        !@trace_logger.nil?
-      end
-
-      def silent=(shh)
-        if shh
-          @logger = nil
-        else
-          @logger ||= Logger.new(STDOUT)
-        end
-      end
-
-      def silent?
-        !@logger.nil?
-      end
-
-      def level
-        @logger ? @logger.level : nil # or 'silent'
-      end
-
-      def level=(value)
-        # If logging has been silenced, then re-enable logging
-        @logger = Logger.new(STDOUT) if @logger.nil?
-        @logger.level = value
-      end
-
-      # Allow user to specify a custom logger to use.
-      # This object must respond to:
-      # +level+, +level=+ and +debug+, +info+, +warn+, +error+, +fatal+
-      def logger=(custom_logger)
-        [ :level   ,
-          :level=  ,
-          :debug   ,
-          :info    ,
-          :warn    ,
-          :error   ,
-          :fatal   ,
-          :unknown ,
-        ].each do |method|
-          if not custom_logger.respond_to?(method)
-            raise ArgumentError, "logger must respond to #{method}"
-          end
-        end
-
-        @logger = custom_logger
-      end
-
-      def trace_logger=(custom_tracer)
-        [ :level   ,
-          :level=  ,
-          :debug   ,
-          :info    ,
-          :warn    ,
-          :error   ,
-          :fatal   ,
-          :unknown ,
-        ].each do |method|
-          if not custom_tracer.respond_to?(method)
-            raise ArgumentError, "trace logger must respond to #{method}"
-          end
-        end
-
-        @trace_logger = custom_tracer
-      end
-
-      def log_msg(msg, level=Logger::INFO)
-        return unless @logger
-        @logger.add(level, msg)
-      end
-
-      def trace_msg(msg)
-        return unless @trace_logger
-        @trace_logger.info(msg)
-      end
-
-      # Provided for backwards compatibility.
-      # Callers should be using the +level+ (on the +Logging+ module
-      # or on the instance) to figure out what the log level is.
-      def debug?
-        self.level == Logger::DEBUG
-      end
-      def debug=(val)
-        self.level = (val ? Logger::DEBUG : Logger::INFO)
-      end
-
-    end # module methods
-
-    # Default logger to stdout.
-    self.logger           = Logger.new(STDOUT)
-    self.logger.level     = Logger::INFO
-    self.logger.formatter = Logging::SimpleFormatter.new
-
-    def silent
-      Logging.silent?
-    end
-
-    def silent=(value)
-      Logging.silent = value
-    end
-
-    # Log a message if tracing is activated
-    def trace(msg=nil)
-      Logging.trace_msg(msg) if msg
-    end
-    module_function :trace
-    public :trace
-
-    # Log a message at DEBUG level
-    def log_debug(msg=nil)
-      Logging.log_msg(msg || yield, Logger::DEBUG)
-    end
-    module_function :log_debug
-    public :log_debug
-
-    # Log a message at INFO level
-    def log_info(msg)
-      Logging.log_msg(msg || yield, Logger::INFO)
-    end
-    module_function :log_info
-    public :log_info
-
-    # Log a message at ERROR level (and maybe a backtrace)
-    def log_error(msg, e=nil)
-      log_msg = msg
-      if e
-        log_msg += ": #{e}\n\t" + e.backtrace.join("\n\t") + "\n"
-      end
-      Logging.log_msg(log_msg, Logger::ERROR)
-    end
-    module_function :log_error
-    public :log_error
-
-    # For backwards compatibility
-    def log msg
-      STDERR.puts('#log has been deprecated, please use the ' \
-                  'log_level function instead (e.g. - log_info).')
-      log_info(msg)
-    end
-
-  end
-end