webrick源码分析──主要流程

10 Jan 2010

webrick作为ruby自带的一个http server,很适合拿来作为学习之用。首先来看看最简单的使用webrick的示例吧

require 'webrick'

server = WEBrick::HTTPServer.new({:Port => 3000, :DocumentRoot => '/home/flyerhzm/public_html'})

['INT', 'TERM'].each { |signal|
   trap(signal) { server.shutdown }
}

server.start

这段代码主要是定义了http服务器监听3000端口,根目录在/home/flyerhzm/public_html下,在接收INT或TERM信号时,关闭服务器,然后启动服务器。

我们分两部分来看,首先看看服务器初始化时做了些什么

class GenericServer
  attr_reader :status, :config, :logger, :tokens, :listeners

  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 = []
    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
end

class HTTPServer  ::WEBrick::GenericServer
  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
end

WEBrick::HTTPServer继承自WEBrick::GenericServer

WEBrick::GenericServer初始化时

首先记录所有的配置信息,预定义的WEBrick::Config::HTTP和用户定义的配置信息,包括监听端口,请求超时时间,文档根目录等等。

接着生成一个定长的队列SizedQueue,用来控制最大的客户端连接数。注意这里的SizedQueue放入的并不是一个线程,而是nil。

然后打印当前的WEBrick版本号和Ruby版本号。

最后调用listen方法,生成TCPServer,监听端口。这里可能生成两个TCPServer,一个是IPv4的,一个是IPv6的。

WEBrick::HTTPServer初始化时主要是定义了http版本号,根据配置信息mount根目录,这里将http://localhost/映射到/home/flyerhzm/public_html/目录,默认DirectoryIndex为[index.html,index.htm,index.cgi,index.rhtml],即请求为目录时,显示目录下的index.html, index.htm, index.cgi或者index.rhtml,DocumentRootOptions为{ :FancyIndexing = true },即请求为目录且目录下没有DirectoryIndex定义的文件时,显示目录下的所有文件。这些都是在WEBrick::HTTPServlet::FileHandler中定义的,我会在之后的文章介绍。

介绍完初始化,下面来看看start方法是如何实现的

def start()
  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)

    thgroup = ThreadGroup.new
    @status = :Running
    while @status == :Running
      begin
        if svrs = IO.select(@listeners, nil, nil, 2.0)
          svrs[0].each{|svr|
            @tokens.pop          # blocks while no token is there.
            if sock = accept_client(svr)
              th = start_thread(sock, block)
              th[:WEBrickThread] = true
              thgroup.add(th)
            else
              @tokens.push(nil)
            end
          }
        end
      rescue Errno::EBADF, IOError = ex
        # if the listening socket was closed in GenericServer#shutdown,
        # IO::select raise it.
      rescue Exception = ex
        msg = #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}
        @logger.error msg
      end
    end

    @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

首先,根据不同的ServerType执行不同的start方法,定义有SimpleServer和Daemon两种,Daemon方式会在以后的文章中介绍,默认为SimpleServer

class SimpleServer
  def SimpleServer.start
    yield
  end
end

非常简单,就是直接执行传过来的block

在这个block中生成一个线程组,用来存放处理http请求的线程。

IO.select(@listeners, nil, nil, 2.0)方法监听@listeners(就是tcp server),一旦有数据进入就返回,并设置2秒超时,防止进程被挂死。

对于客户端连接的socket请求,创建一个新的线程来处理,并把这个线程放入线程组中。这里用了一个小技巧来控制线程组中线程的数量。一般我们是将线程插入到SizedQueue来控制线程的数量,而这里SizedQueue插入满nil,每次创建一个线程之前,先从SizedQueue pop一个nil,每次线程处理完在push一个nil,这样,当创建了一定数量的线程时,SizedQueue就为空,无法再pop数据,只有等待一个线程处理完后才能继续。

接着先来看看如何关闭服务器。webrick提供了两种方法:

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

一是stop,它只是简单地将服务器的状态由Running改为Shutdown,这样就可以从start方法中的循环跳出来,不过由于start方法最后有这么一句话:thgroup.list.each{|th| th.join if th[:WEBrickThread] },这表示服务器并不会马上关闭,它会等到线程组中所有的线程都执行完毕之后再关闭。

def shutdown
  stop
  @listeners.each{|s|
    if @logger.debug?
      addr = s.addr
      @logger.debug(close TCPSocket(#{addr[2]}, #{addr[1]}))
    end
    s.close
  }
  @listeners.clear
end

二是shutdown,它首先执行stop方法,然后遍历所有的sockets并关闭,这样所有的线程都会买上结束,服务器也会马上停止。

再来看看每个线程都做了些什么

def start_thread(sock, )
  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
    end
  }
end

如果传入一个block,就执行这个block,不然就执行run方法,run方法的定义在WEBrick::HTTPServer下

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

run方法中,首先,根据配置信息实例化HTTPResponse和HTTPRequest,在设置的timeout之内读取socket数据,不然停止执行。request对象读取socket数据并根据HTTP协议进行解析(关于http请求和应答的解析将在后文进行介绍),将部分内容(request_method, request_uri等等)赋值给response对象。调用service方法,根据request进行操作,并返回相应的response。最后,通过socket将response发送给客户端。需要注意的是,如果http版本是1.1而且keep_alive为true的话,run方法的循环将一直执行,来保持与客户端的长连接。

最后看看service方法的代码

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

对于OPTIONS请求是需要特殊处理,返回可以处理的请求(GET, HEAD, POST, OPTIONS),根据请求的path返回相应的servlet,options, script_name和path_info,并获取到servlet实例(一般是用户定义的Servlet类,WEBrick默认有FileHandler, CGIHandler和ProcHandler),然后由具体的servlet实例来处理http请求。

这就是WEBrick的主要流程,写得比较乱,之后的文章根据WEBrick的功能一部分一部分详细介绍。

Tags 


blog comments powered by Disqus