giga-smart-mod 0.0.1

data/thin-2.0.1/lib/thin/daemonizing.rb

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

data/thin-2.0.1/lib/thin/env.rb

@@ -0,0 +1,35 @@
+
+module Thin
+  module Env
+    def self.with_defaults(env)
+      if ::Rack.release >= "3"
+        rack_env_class = Rack3
+      else
+        rack_env_class = Rack2
+      end
+
+      rack_env_class.env.merge(env)
+    end
+  end
+
+  private
+
+  class Rack2
+    RACK_VERSION = [1, 0].freeze
+
+    def self.env
+      {
+        ::Thin::Request::RACK_VERSION      => RACK_VERSION,
+        ::Thin::Request::RACK_MULTITHREAD  => false,
+        ::Thin::Request::RACK_MULTIPROCESS => false,
+        ::Thin::Request::RACK_RUN_ONCE     => false
+      }
+    end
+  end
+
+  class Rack3
+    def self.env
+      {}
+    end
+  end
+end

data/thin-2.0.1/lib/thin/headers.rb

@@ -0,0 +1,47 @@
+module Thin
+  # Raised when an header is not valid
+  # and the server can not process it.
+  class InvalidHeader < StandardError; end
+
+  # 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
+    CR_OR_LF           = /[\r\n]/.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
+                when CR_OR_LF
+                  raise InvalidHeader, "Header contains CR or LF"
+                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/thin-2.0.1/lib/thin/logging.rb

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

data/thin-2.0.1/lib/thin/rackup/handler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../server"
+
+module Thin
+  module Rackup
+    class Handler
+      def self.run(app, **options)
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        host = options.delete(:Host) || default_host
+        port = options.delete(:Port) || 8080
+        args = [host, port, app, options]
+
+        server = ::Thin::Server.new(*args)
+        yield server if block_given?
+
+        server.start
+      end
+
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
+    end
+  end
+end

data/thin-2.0.1/lib/thin/request.rb

@@ -0,0 +1,159 @@
+require 'tempfile'
+require_relative './env'
+
+module Thin
+  # Raised when an incoming request is not valid
+  # and the server can not process it.
+  class InvalidRequest < IOError; end
+
+  # A request sent by the client to the server.
+  class Request
+    # Maximum request body size before it is moved out of memory
+    # and into a tempfile for reading.
+    MAX_BODY          = 1024 * (80 + 32)
+    BODY_TMPFILE      = 'thin-body'.freeze
+    MAX_HEADER        = 1024 * (80 + 32)
+
+    INITIAL_BODY      = String.new
+    # Force external_encoding of request's body to ASCII_8BIT
+    INITIAL_BODY.encode!(Encoding::ASCII_8BIT) if INITIAL_BODY.respond_to?(:encode!) && defined?(Encoding::ASCII_8BIT)
+
+    # Freeze some HTTP header names & values
+    SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
+    SERVER_NAME       = 'SERVER_NAME'.freeze
+    REQUEST_METHOD    = 'REQUEST_METHOD'.freeze
+    LOCALHOST         = 'localhost'.freeze
+    REQUEST_HTTP_VERSION      = 'thin.request_http_version'.freeze
+    HTTP_1_0          = 'HTTP/1.0'.freeze
+    REMOTE_ADDR       = 'REMOTE_ADDR'.freeze
+    CONTENT_LENGTH    = 'CONTENT_LENGTH'.freeze
+    CONNECTION        = 'HTTP_CONNECTION'.freeze
+    KEEP_ALIVE_REGEXP = /\bkeep-alive\b/i.freeze
+    CLOSE_REGEXP      = /\bclose\b/i.freeze
+    HEAD              = 'HEAD'.freeze
+
+    # Freeze some Rack header names
+    RACK_INPUT        = 'rack.input'.freeze
+    RACK_VERSION      = 'rack.version'.freeze
+    RACK_ERRORS       = 'rack.errors'.freeze
+    RACK_MULTITHREAD  = 'rack.multithread'.freeze
+    RACK_MULTIPROCESS = 'rack.multiprocess'.freeze
+    RACK_RUN_ONCE     = 'rack.run_once'.freeze
+    ASYNC_CALLBACK    = 'async.callback'.freeze
+    ASYNC_CLOSE       = 'async.close'.freeze
+
+    # CGI-like request environment variables
+    attr_reader :env
+
+    # Unparsed data of the request
+    attr_reader :data
+
+    # Request body
+    attr_reader :body
+
+    def initialize
+      @parser   = Thin::HttpParser.new
+      @data     = String.new
+      @nparsed  = 0
+      @body     = StringIO.new(INITIAL_BODY.dup)
+      @env      = Env.with_defaults({
+        SERVER_SOFTWARE   => SERVER,
+        SERVER_NAME       => LOCALHOST,
+
+        # Rack stuff
+        RACK_INPUT        => @body,
+        RACK_ERRORS       => STDERR,
+      })
+    end
+
+    # Parse a chunk of data into the request environment
+    # Raises an +InvalidRequest+ if invalid.
+    # Returns +true+ if the parsing is complete.
+    def parse(data)
+      if data.size > 0 && finished? # headers and body already fully satisfied. more data is erroneous.
+        raise InvalidRequest, 'Content longer than specified'
+      elsif @parser.finished?  # Header finished, can only be some more body
+        @body << data
+      else                  # Parse more header using the super parser
+        @data << data
+        raise InvalidRequest, 'Header longer than allowed' if @data.size > MAX_HEADER
+
+        @nparsed = @parser.execute(@env, @data, @nparsed)
+
+        # Transfer to a tempfile if body is very big
+        move_body_to_tempfile if @parser.finished? && content_length > MAX_BODY
+      end
+
+
+      if finished?   # Check if header and body are complete
+        @data = nil
+        @body.rewind
+        true         # Request is fully parsed
+      else
+        false        # Not finished, need more data
+      end
+    end
+
+    # +true+ if headers and body are finished parsing
+    def finished?
+      @parser.finished? && @body.size >= content_length
+    end
+
+    # Expected size of the body
+    def content_length
+      @env[CONTENT_LENGTH].to_i
+    end
+
+    # Returns +true+ if the client expects the connection to be persistent.
+    def persistent?
+      # Clients and servers SHOULD NOT assume that a persistent connection
+      # is maintained for HTTP versions less than 1.1 unless it is explicitly
+      # signaled. (http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html)
+      if @env[REQUEST_HTTP_VERSION] == HTTP_1_0
+        @env[CONNECTION] =~ KEEP_ALIVE_REGEXP
+
+      # HTTP/1.1 client intends to maintain a persistent connection unless
+      # a Connection header including the connection-token "close" was sent
+      # in the request
+      else
+        @env[CONNECTION].nil? || @env[CONNECTION] !~ CLOSE_REGEXP
+      end
+    end
+
+    def remote_address=(address)
+      @env[REMOTE_ADDR] = address
+    end
+
+    def threaded=(value)
+      @env[RACK_MULTITHREAD] = value
+    end
+
+    def async_callback=(callback)
+      @env[ASYNC_CALLBACK] = callback
+      @env[ASYNC_CLOSE] = EventMachine::DefaultDeferrable.new
+    end
+
+    def async_close
+      @async_close ||= @env[ASYNC_CLOSE]
+    end
+
+    def head?
+      @env[REQUEST_METHOD] == HEAD
+    end
+
+    # Close any resource used by the request
+    def close
+      @body.close! if @body.class == Tempfile
+    end
+
+    private
+      def move_body_to_tempfile
+        current_body = @body
+        current_body.rewind
+        @body = Tempfile.new(BODY_TMPFILE)
+        @body.binmode
+        @body << current_body.read
+        @env[RACK_INPUT] = @body
+      end
+  end
+end