Class: WEBrick::HTTPServer

Class | WEBrick::HTTPServer
In: | webrick/httpserver.rb
Parent: | ::WEBrick::GenericServer

### Methods

access_log do_OPTIONS lookup_server mount mount_proc new run search_servlet service umount unmount virtual_host

### Classes and Modules

Class WEBrick::HTTPServer::MountTable

### Public Class methods

new(config={}, default=Config::HTTP)

[Source]

    # File webrick/httpserver.rb, line 23
        def initialize(config={}, default=Config::HTTP)
          super
          @http_version = HTTPVersion::convert(@config[:HTTPVersion])

          @mount_tab = MountTable.new
          if @config[:DocumentRoot]
            mount("/", HTTPServlet::FileHandler, @config[:DocumentRoot],
                  @config[:DocumentRootOptions])
          end

          unless @config[:AccessLog]
            @config[:AccessLog] = [
              [ $stderr, AccessLog::COMMON_LOG_FORMAT ],
              [ $stderr, AccessLog::REFERER_LOG_FORMAT ]
            ]
          end

          @virtual_hosts = Array.new
        end

### Public Instance methods

access_log(config, req, res)

[Source]

    # File webrick/httpserver.rb, line 156
        def access_log(config, req, res)
          param = AccessLog::setup_params(config, req, res)
          @config[:AccessLog].each{|logger, fmt|
            logger << AccessLog::format(fmt+"\n", param)
          }
        end

do_OPTIONS(req, res)

[Source]

    # File webrick/httpserver.rb, line 107
        def do_OPTIONS(req, res)
          res["allow"] = "GET,HEAD,POST,OPTIONS"
        end

lookup_server(req)

[Source]

    # File webrick/httpserver.rb, line 147
        def lookup_server(req)
          @virtual_hosts.find{|s|
            (s[:BindAddress].nil? || req.addr[3] == s[:BindAddress]) &&
            (s[:Port].nil?        || req.port == s[:Port])           &&
            ((s[:ServerName].nil?  || req.host == s[:ServerName]) ||
             (!s[:ServerAlias].nil? && s[:ServerAlias].find{|h| h === req.host}))
          }
        end

mount(dir, servlet, *options)

[Source]

    # File webrick/httpserver.rb, line 111
        def mount(dir, servlet, *options)
          @logger.debug(sprintf("%s is mounted on %s.", servlet.inspect, dir))
          @mount_tab[dir] = [ servlet, options ]
        end

mount_proc(dir, proc=nil, &block)

[Source]

    # File webrick/httpserver.rb, line 116
        def mount_proc(dir, proc=nil, &block)
          proc ||= block
          raise HTTPServerError, "must pass a proc or block" unless proc
          mount(dir, HTTPServlet::ProcHandler.new(proc))
        end

run(sock)

[Source]

    # File webrick/httpserver.rb, line 43
        def run(sock)
          while true
            res = HTTPResponse.new(@config)
            req = HTTPRequest.new(@config)
            server = self
            begin
              timeout = @config[:RequestTimeout]
              while timeout > 0
                break if IO.select([sock], nil, nil, 0.5)
                timeout = 0 if @status != :Running
                timeout -= 0.5
              end
              raise HTTPStatus::EOFError if timeout <= 0 || sock.eof?
              req.parse(sock)
              res.request_method = req.request_method
              res.request_uri = req.request_uri
              res.request_http_version = req.http_version
              res.keep_alive = req.keep_alive?
              server = lookup_server(req) || self
              if callback = server[:RequestCallback] || server[:RequestHandler]
                callback.call(req, res)
              end
              server.service(req, res)
            rescue HTTPStatus::EOFError, HTTPStatus::RequestTimeout => ex
              res.set_error(ex)
            rescue HTTPStatus::Error => ex
              @logger.error(ex.message)
              res.set_error(ex)
            rescue HTTPStatus::Status => ex
              res.status = ex.code
            rescue StandardError => ex
              @logger.error(ex)
              res.set_error(ex, true)
            ensure
              if req.request_line
                req.fixup()
                res.send_response(sock)
                server.access_log(@config, req, res)
              end
            end
            break if @http_version < "1.1"
            break unless req.keep_alive?
            break unless res.keep_alive?
          end
        end

search_servlet(path)

[Source]

    # File webrick/httpserver.rb, line 128
        def search_servlet(path)
          script_name, path_info = @mount_tab.scan(path)
          servlet, options = @mount_tab[script_name]
          if servlet
            [ servlet, options, script_name, path_info ]
          end
        end

service(req, res)

[Source]

    # File webrick/httpserver.rb, line 89
        def service(req, res)
          if req.unparsed_uri == "*"
            if req.request_method == "OPTIONS"
              do_OPTIONS(req, res)
              raise HTTPStatus::OK
            end
            raise HTTPStatus::NotFound, "`#{req.unparsed_uri}' not found."
          end

          servlet, options, script_name, path_info = search_servlet(req.path)
          raise HTTPStatus::NotFound, "`#{req.path}' not found." unless servlet
          req.script_name = script_name
          req.path_info = path_info
          si = servlet.get_instance(self, *options)
          @logger.debug(format("%s is invoked.", si.class.name))
          si.service(req, res)
        end

umount(dir)

Alias for unmount

unmount(dir)

[Source]

    # File webrick/httpserver.rb, line 122
        def unmount(dir)
          @logger.debug(sprintf("unmount %s.", inspect, dir))
          @mount_tab.delete(dir)
        end

virtual_host(server)

[Source]

    # File webrick/httpserver.rb, line 136
        def virtual_host(server)
          @virtual_hosts << server
          @virtual_hosts = @virtual_hosts.sort_by{|s|
            num = 0
            num -= 4 if s[:BindAddress]
            num -= 2 if s[:Port]
            num -= 1 if s[:ServerName]
            num
          }
        end

[Validate]