Gecko [ beacons-mine.com ]

Name	Size	Permission	Date
httpauth	[ DIR ]	drwxr-xr-x	2026-02-18 15:11
httpservlet	[ DIR ]	drwxr-xr-x	2026-02-18 15:11
accesslog.rb	4.31 KB	-rw-r--r--	2013-12-11 09:28
cgi.rb	7.97 KB	-rw-r--r--	2013-01-26 06:42
compat.rb	912 B	-rw-r--r--	2013-12-06 07:40
config.rb	5.56 KB	-rw-r--r--	2013-01-26 06:42
cookie.rb	3.88 KB	-rw-r--r--	2013-01-26 08:01
htmlutils.rb	680 B	-rw-r--r--	2013-05-20 07:10
httpauth.rb	3.33 KB	-rw-r--r--	2011-05-11 05:07
httpproxy.rb	9.59 KB	-rw-r--r--	2014-08-08 11:04
httprequest.rb	14.78 KB	-rw-r--r--	2018-03-28 20:17
httpresponse.rb	11.83 KB	-rw-r--r--	2018-03-28 20:20
https.rb	1.87 KB	-rw-r--r--	2013-01-26 06:42
httpserver.rb	7.71 KB	-rw-r--r--	2014-05-08 06:47
httpservlet.rb	669 B	-rw-r--r--	2009-10-02 16:15
httpstatus.rb	5.16 KB	-rw-r--r--	2017-09-14 17:07
httputils.rb	12.71 KB	-rw-r--r--	2013-05-20 07:10
httpversion.rb	1.57 KB	-rw-r--r--	2013-01-26 06:42
log.rb	3.96 KB	-rw-r--r--	2017-09-14 17:07
server.rb	9.39 KB	-rw-r--r--	2014-11-10 16:35
ssl.rb	6.69 KB	-rw-r--r--	2014-11-10 16:35
utils.rb	5.86 KB	-rw-r--r--	2014-07-02 11:56
version.rb	384 B	-rw-r--r--	2013-01-26 06:42

Rename

#
# server.rb -- GenericServer Class
#
# Author: IPR -- Internet Programming with Ruby -- writers
# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
# reserved.
#
# $IPR: server.rb,v 1.62 2003/07/22 19:20:43 gotoyuzo Exp $

require 'thread'
require 'socket'
require 'webrick/config'
require 'webrick/log'

module WEBrick

##
  # Server error exception

class ServerError < StandardError; end

##
  # Base server class

class SimpleServer

##
    # A SimpleServer only yields when you start it

def SimpleServer.start
      yield
    end
  end

##
  # A generic module for daemonizing a process

class Daemon

##
    # Performs the standard operations for daemonizing a process.  Runs a
    # block, if given.

def Daemon.start
      exit!(0) if fork
      Process::setsid
      exit!(0) if fork
      Dir::chdir("/")
      File::umask(0)
      STDIN.reopen("/dev/null")
      STDOUT.reopen("/dev/null", "w")
      STDERR.reopen("/dev/null", "w")
      yield if block_given?
    end
  end

##
  # Base TCP server class.  You must subclass GenericServer and provide a #run
  # method.

class GenericServer

##
    # The server status.  One of :Stop, :Running or :Shutdown

attr_reader :status

##
    # The server configuration

attr_reader :config

##
    # The server logger.  This is independent from the HTTP access log.

attr_reader :logger

##
    # Tokens control the number of outstanding clients.  The
    # <code>:MaxClients</code> configuration sets this.

attr_reader :tokens

##
    # Sockets listening for connections.

attr_reader :listeners

##
    # Creates a new generic server from +config+.  The default configuration
    # comes from +default+.

def initialize(config={}, default=Config::General)
      @config = default.dup.update(config)
      @status = :Stop
      @config[:Logger] ||= Log::new
      @logger = @config[:Logger]

@tokens = SizedQueue.new(@config[:MaxClients])
      @config[:MaxClients].times{ @tokens.push(nil) }

webrickv = WEBrick::VERSION
      rubyv = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
      @logger.info("WEBrick #{webrickv}")
      @logger.info("ruby #{rubyv}")

@listeners = []
      @shutdown_pipe = nil
      unless @config[:DoNotListen]
        if @config[:Listen]
          warn(":Listen option is deprecated; use GenericServer#listen")
        end
        listen(@config[:BindAddress], @config[:Port])
        if @config[:Port] == 0
          @config[:Port] = @listeners[0].addr[1]
        end
      end
    end

##
    # Retrieves +key+ from the configuration

def [](key)
      @config[key]
    end

##
    # Adds listeners from +address+ and +port+ to the server.  See
    # WEBrick::Utils::create_listeners for details.

def listen(address, port)
      @listeners += Utils::create_listeners(address, port, @logger)
      setup_shutdown_pipe
    end

##
    # Starts the server and runs the +block+ for each connection.  This method
    # does not return until the server is stopped from a signal handler or
    # another thread using #stop or #shutdown.
    #
    # If the block raises a subclass of StandardError the exception is logged
    # and ignored.  If an IOError or Errno::EBADF exception is raised the
    # exception is ignored.  If an Exception subclass is raised the exception
    # is logged and re-raised which stops the server.
    #
    # To completely shut down a server call #shutdown from ensure:
    #
    #   server = WEBrick::GenericServer.new
    #   # or WEBrick::HTTPServer.new
    #
    #   begin
    #     server.start
    #   ensure
    #     server.shutdown
    #   end

def start(&block)
      raise ServerError, "already started." if @status != :Stop
      server_type = @config[:ServerType] || SimpleServer

server_type.start{
        @logger.info \
          "#{self.class}#start: pid=#{$$} port=#{@config[:Port]}"
        call_callback(:StartCallback)

shutdown_pipe = @shutdown_pipe

thgroup = ThreadGroup.new
        @status = :Running
        begin
          while @status == :Running
            begin
              if svrs = IO.select([shutdown_pipe[0], *@listeners], nil, nil, 2.0)
                if svrs[0].include? shutdown_pipe[0]
                  break
                end
                svrs[0].each{|svr|
                  @tokens.pop          # blocks while no token is there.
                  if sock = accept_client(svr)
                    sock.do_not_reverse_lookup = config[:DoNotReverseLookup]
                    th = start_thread(sock, &block)
                    th[:WEBrickThread] = true
                    thgroup.add(th)
                  else
                    @tokens.push(nil)
                  end
                }
              end
            rescue Errno::EBADF, Errno::ENOTSOCK, IOError => ex
              # if the listening socket was closed in GenericServer#shutdown,
              # IO::select raise it.
            rescue StandardError => ex
              msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
              @logger.error msg
            rescue Exception => ex
              @logger.fatal ex
              raise
            end
          end
        ensure
          cleanup_shutdown_pipe(shutdown_pipe)
          cleanup_listener
          @status = :Shutdown
          @logger.info "going to shutdown ..."
          thgroup.list.each{|th| th.join if th[:WEBrickThread] }
          call_callback(:StopCallback)
          @logger.info "#{self.class}#start done."
          @status = :Stop
        end
      }
    end

##
    # Stops the server from accepting new connections.

def stop
      if @status == :Running
        @status = :Shutdown
      end
    end

##
    # Shuts down the server and all listening sockets.  New listeners must be
    # provided to restart the server.

def shutdown
      stop

shutdown_pipe = @shutdown_pipe # another thread may modify @shutdown_pipe.
      if shutdown_pipe
        if !shutdown_pipe[1].closed?
          begin
            shutdown_pipe[1].close
          rescue IOError # closed by another thread.
          end
        end
      end
    end

##
    # You must subclass GenericServer and implement \#run which accepts a TCP
    # client socket

def run(sock)
      @logger.fatal "run() must be provided by user."
    end

private

# :stopdoc:

##
    # Accepts a TCP client socket from the TCP server socket +svr+ and returns
    # the client socket.

def accept_client(svr)
      sock = nil
      begin
        sock = svr.accept
        sock.sync = true
        Utils::set_non_blocking(sock)
        Utils::set_close_on_exec(sock)
      rescue Errno::ECONNRESET, Errno::ECONNABORTED,
             Errno::EPROTO, Errno::EINVAL
      rescue StandardError => ex
        msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
        @logger.error msg
      end
      return sock
    end

##
    # Starts a server thread for the client socket +sock+ that runs the given
    # +block+.
    #
    # Sets the socket to the <code>:WEBrickSocket</code> thread local variable
    # in the thread.
    #
    # If any errors occur in the block they are logged and handled.

def start_thread(sock, &block)
      Thread.start{
        begin
          Thread.current[:WEBrickSocket] = sock
          begin
            addr = sock.peeraddr
            @logger.debug "accept: #{addr[3]}:#{addr[1]}"
          rescue SocketError
            @logger.debug "accept: <address unknown>"
            raise
          end
          call_callback(:AcceptCallback, sock)
          block ? block.call(sock) : run(sock)
        rescue Errno::ENOTCONN
          @logger.debug "Errno::ENOTCONN raised"
        rescue ServerError => ex
          msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
          @logger.error msg
        rescue Exception => ex
          @logger.error ex
        ensure
          @tokens.push(nil)
          Thread.current[:WEBrickSocket] = nil
          if addr
            @logger.debug "close: #{addr[3]}:#{addr[1]}"
          else
            @logger.debug "close: <address unknown>"
          end
          sock.close unless sock.closed?
        end
      }
    end

##
    # Calls the callback +callback_name+ from the configuration with +args+

def call_callback(callback_name, *args)
      if cb = @config[callback_name]
        cb.call(*args)
      end
    end

def setup_shutdown_pipe
      if !@shutdown_pipe
        @shutdown_pipe = IO.pipe
      end
      @shutdown_pipe
    end

def cleanup_shutdown_pipe(shutdown_pipe)
      @shutdown_pipe = nil
      shutdown_pipe.each {|io|
        if !io.closed?
          begin
            io.close
          rescue IOError # another thread closed io.
          end
        end
      }
    end

def cleanup_listener
      @listeners.each{|s|
        if @logger.debug?
          addr = s.addr
          @logger.debug("close TCPSocket(#{addr[2]}, #{addr[1]})")
        end
        begin
          s.shutdown
        rescue Errno::ENOTCONN
          # when `Errno::ENOTCONN: Socket is not connected' on some platforms,
          # call #close instead of #shutdown.
          # (ignore @config[:ShutdownSocketWithoutClose])
          s.close
        else
          unless @config[:ShutdownSocketWithoutClose]
            s.close
          end
        end
      }
      @listeners.clear
    end
  end    # end of GenericServer
end