--- rest25/library/basehttpserver.rst	2008-12-19 16:58:07.000000000 +0900
+++ rest262/library/basehttpserver.rst	2009-04-07 00:06:53.000000000 +0900
@@ -1,254 +1,298 @@
-
 :mod:`BaseHTTPServer` --- Basic HTTP server
 ===========================================
 
 .. module:: BaseHTTPServer
    :synopsis: Basic HTTP server (base class for SimpleHTTPServer and CGIHTTPServer).
 
+.. note::
+   The :mod:`BaseHTTPServer` module has been merged into :mod:`http.server` in
+   Python 3.0.  The :term:`2to3` tool will automatically adapt imports when
+   converting your sources to 3.0.
+
 
 .. index::
    pair: WWW; server
    pair: HTTP; protocol
    single: URL
    single: httpd
-
-.. index::
    module: SimpleHTTPServer
    module: CGIHTTPServer
 
 This module defines two classes for implementing HTTP servers (Web servers).
 Usually, this module isn't used directly, but is used as a basis for building
 functioning Web servers. See the :mod:`SimpleHTTPServer` and
 :mod:`CGIHTTPServer` modules.
 
 The first class, :class:`HTTPServer`, is a :class:`SocketServer.TCPServer`
-subclass.  It creates and listens at the HTTP socket, dispatching the requests
+subclass, and therefore implements the :class:`SocketServer.BaseServer`
+interface.  It creates and listens at the HTTP socket, dispatching the requests
 to a handler.  Code to create and run the server looks like this::
 
    def run(server_class=BaseHTTPServer.HTTPServer,
            handler_class=BaseHTTPServer.BaseHTTPRequestHandler):
        server_address = ('', 8000)
        httpd = server_class(server_address, handler_class)
        httpd.serve_forever()
 
 
 .. class:: HTTPServer(server_address, RequestHandlerClass)
 
-   This class builds on the :class:`TCPServer` class by storing the server address
-   as instance variables named :attr:`server_name` and :attr:`server_port`. The
-   server is accessible by the handler, typically through the handler's
-   :attr:`server` instance variable.
+   This class builds on the :class:`TCPServer` class by storing the server
+   address as instance variables named :attr:`server_name` and
+   :attr:`server_port`. The server is accessible by the handler, typically
+   through the handler's :attr:`server` instance variable.
 
 
 .. class:: BaseHTTPRequestHandler(request, client_address, server)
 
    This class is used to handle the HTTP requests that arrive at the server. By
-   itself, it cannot respond to any actual HTTP requests; it must be subclassed to
-   handle each request method (e.g. GET or POST). :class:`BaseHTTPRequestHandler`
-   provides a number of class and instance variables, and methods for use by
-   subclasses.
+   itself, it cannot respond to any actual HTTP requests; it must be subclassed
+   to handle each request method (e.g. GET or
+   POST). :class:`BaseHTTPRequestHandler` provides a number of class and
+   instance variables, and methods for use by subclasses.
+
+   The handler will parse the request and the headers, then call a method
+   specific to the request type. The method name is constructed from the
+   request. For example, for the request method ``SPAM``, the :meth:`do_SPAM`
+   method will be called with no arguments. All of the relevant information is
+   stored in instance variables of the handler.  Subclasses should not need to
+   override or extend the :meth:`__init__` method.
+
+   :class:`BaseHTTPRequestHandler` has the following instance variables:
+
+
+   .. attribute:: client_address
+
+      Contains a tuple of the form ``(host, port)`` referring to the client's
+      address.
+
 
-   The handler will parse the request and the headers, then call a method specific
-   to the request type. The method name is constructed from the request. For
-   example, for the request method ``SPAM``, the :meth:`do_SPAM` method will be
-   called with no arguments. All of the relevant information is stored in instance
-   variables of the handler.  Subclasses should not need to override or extend the
-   :meth:`__init__` method.
+   .. attribute:: server
 
-:class:`BaseHTTPRequestHandler` has the following instance variables:
+      Contains the server instance.
 
 
-.. attribute:: BaseHTTPRequestHandler.client_address
+   .. attribute:: command
 
-   Contains a tuple of the form ``(host, port)`` referring to the client's address.
+      Contains the command (request type). For example, ``'GET'``.
 
 
-.. attribute:: BaseHTTPRequestHandler.command
+   .. attribute:: path
 
-   Contains the command (request type). For example, ``'GET'``.
+      Contains the request path.
 
 
-.. attribute:: BaseHTTPRequestHandler.path
+   .. attribute:: request_version
 
-   Contains the request path.
+      Contains the version string from the request. For example, ``'HTTP/1.0'``.
 
 
-.. attribute:: BaseHTTPRequestHandler.request_version
+   .. attribute:: headers
 
-   Contains the version string from the request. For example, ``'HTTP/1.0'``.
+      Holds an instance of the class specified by the :attr:`MessageClass` class
+      variable. This instance parses and manages the headers in the HTTP
+      request.
 
 
-.. attribute:: BaseHTTPRequestHandler.headers
+   .. attribute:: rfile
 
-   Holds an instance of the class specified by the :attr:`MessageClass` class
-   variable. This instance parses and manages the headers in the HTTP request.
+      Contains an input stream, positioned at the start of the optional input
+      data.
 
 
-.. attribute:: BaseHTTPRequestHandler.rfile
+   .. attribute:: wfile
 
-   Contains an input stream, positioned at the start of the optional input data.
+      Contains the output stream for writing a response back to the
+      client. Proper adherence to the HTTP protocol must be used when writing to
+      this stream.
 
 
-.. attribute:: BaseHTTPRequestHandler.wfile
+   :class:`BaseHTTPRequestHandler` has the following class variables:
 
-   Contains the output stream for writing a response back to the client. Proper
-   adherence to the HTTP protocol must be used when writing to this stream.
 
-:class:`BaseHTTPRequestHandler` has the following class variables:
+   .. attribute:: server_version
 
+      Specifies the server software version.  You may want to override this. The
+      format is multiple whitespace-separated strings, where each string is of
+      the form name[/version]. For example, ``'BaseHTTP/0.2'``.
 
-.. attribute:: BaseHTTPRequestHandler.server_version
 
-   Specifies the server software version.  You may want to override this. The
-   format is multiple whitespace-separated strings, where each string is of the
-   form name[/version]. For example, ``'BaseHTTP/0.2'``.
+   .. attribute:: sys_version
 
+      Contains the Python system version, in a form usable by the
+      :attr:`version_string` method and the :attr:`server_version` class
+      variable. For example, ``'Python/1.4'``.
 
-.. attribute:: BaseHTTPRequestHandler.sys_version
 
-   Contains the Python system version, in a form usable by the
-   :attr:`version_string` method and the :attr:`server_version` class variable. For
-   example, ``'Python/1.4'``.
+   .. attribute:: error_message_format
 
+      Specifies a format string for building an error response to the client. It
+      uses parenthesized, keyed format specifiers, so the format operand must be
+      a dictionary. The *code* key should be an integer, specifying the numeric
+      HTTP error code value. *message* should be a string containing a
+      (detailed) error message of what occurred, and *explain* should be an
+      explanation of the error code number. Default *message* and *explain*
+      values can found in the *responses* class variable.
 
-.. attribute:: BaseHTTPRequestHandler.error_message_format
 
-   Specifies a format string for building an error response to the client. It uses
-   parenthesized, keyed format specifiers, so the format operand must be a
-   dictionary. The *code* key should be an integer, specifying the numeric HTTP
-   error code value. *message* should be a string containing a (detailed) error
-   message of what occurred, and *explain* should be an explanation of the error
-   code number. Default *message* and *explain* values can found in the *responses*
-   class variable.
+   .. attribute:: error_content_type
 
+      Specifies the Content-Type HTTP header of error responses sent to the
+      client.  The default value is ``'text/html'``.
 
-.. attribute:: BaseHTTPRequestHandler.protocol_version
+      .. versionadded:: 2.6
+         Previously, the content type was always ``'text/html'``.
 
-   This specifies the HTTP protocol version used in responses.  If set to
-   ``'HTTP/1.1'``, the server will permit HTTP persistent connections; however,
-   your server *must* then include an accurate ``Content-Length`` header (using
-   :meth:`send_header`) in all of its responses to clients.  For backwards
-   compatibility, the setting defaults to ``'HTTP/1.0'``.
 
+   .. attribute:: protocol_version
 
-.. attribute:: BaseHTTPRequestHandler.MessageClass
+      This specifies the HTTP protocol version used in responses.  If set to
+      ``'HTTP/1.1'``, the server will permit HTTP persistent connections;
+      however, your server *must* then include an accurate ``Content-Length``
+      header (using :meth:`send_header`) in all of its responses to clients.
+      For backwards compatibility, the setting defaults to ``'HTTP/1.0'``.
 
-   .. index:: single: Message (in module mimetools)
 
-   Specifies a :class:`rfc822.Message`\ -like class to parse HTTP headers.
-   Typically, this is not overridden, and it defaults to
-   :class:`mimetools.Message`.
+   .. attribute:: MessageClass
 
+      .. index:: single: Message (in module mimetools)
 
-.. attribute:: BaseHTTPRequestHandler.responses
+      Specifies a :class:`rfc822.Message`\ -like class to parse HTTP headers.
+      Typically, this is not overridden, and it defaults to
+      :class:`mimetools.Message`.
 
-   This variable contains a mapping of error code integers to two-element tuples
-   containing a short and long message. For example, ``{code: (shortmessage,
-   longmessage)}``. The *shortmessage* is usually used as the *message* key in an
-   error response, and *longmessage* as the *explain* key (see the
-   :attr:`error_message_format` class variable).
 
-A :class:`BaseHTTPRequestHandler` instance has the following methods:
+   .. attribute:: responses
 
+      This variable contains a mapping of error code integers to two-element tuples
+      containing a short and long message. For example, ``{code: (shortmessage,
+      longmessage)}``. The *shortmessage* is usually used as the *message* key in an
+      error response, and *longmessage* as the *explain* key (see the
+      :attr:`error_message_format` class variable).
 
-.. method:: BaseHTTPRequestHandler.handle()
 
-   Calls :meth:`handle_one_request` once (or, if persistent connections are
-   enabled, multiple times) to handle incoming HTTP requests. You should never need
-   to override it; instead, implement appropriate :meth:`do_\*` methods.
+   A :class:`BaseHTTPRequestHandler` instance has the following methods:
 
 
-.. method:: BaseHTTPRequestHandler.handle_one_request()
+   .. method:: handle()
 
-   This method will parse and dispatch the request to the appropriate :meth:`do_\*`
-   method.  You should never need to override it.
+      Calls :meth:`handle_one_request` once (or, if persistent connections are
+      enabled, multiple times) to handle incoming HTTP requests. You should
+      never need to override it; instead, implement appropriate :meth:`do_\*`
+      methods.
 
 
-.. method:: BaseHTTPRequestHandler.send_error(code[, message])
+   .. method:: handle_one_request()
 
-   Sends and logs a complete error reply to the client. The numeric *code*
-   specifies the HTTP error code, with *message* as optional, more specific text. A
-   complete set of headers is sent, followed by text composed using the
-   :attr:`error_message_format` class variable.
+      This method will parse and dispatch the request to the appropriate
+      :meth:`do_\*` method.  You should never need to override it.
 
 
-.. method:: BaseHTTPRequestHandler.send_response(code[, message])
+   .. method:: send_error(code[, message])
 
-   Sends a response header and logs the accepted request. The HTTP response line is
-   sent, followed by *Server* and *Date* headers. The values for these two headers
-   are picked up from the :meth:`version_string` and :meth:`date_time_string`
-   methods, respectively.
+      Sends and logs a complete error reply to the client. The numeric *code*
+      specifies the HTTP error code, with *message* as optional, more specific text. A
+      complete set of headers is sent, followed by text composed using the
+      :attr:`error_message_format` class variable.
 
 
-.. method:: BaseHTTPRequestHandler.send_header(keyword, value)
+   .. method:: send_response(code[, message])
 
-   Writes a specific HTTP header to the output stream. *keyword* should specify the
-   header keyword, with *value* specifying its value.
+      Sends a response header and logs the accepted request. The HTTP response
+      line is sent, followed by *Server* and *Date* headers. The values for
+      these two headers are picked up from the :meth:`version_string` and
+      :meth:`date_time_string` methods, respectively.
 
 
-.. method:: BaseHTTPRequestHandler.end_headers()
+   .. method:: send_header(keyword, value)
 
-   Sends a blank line, indicating the end of the HTTP headers in the response.
+      Writes a specific HTTP header to the output stream. *keyword* should
+      specify the header keyword, with *value* specifying its value.
 
 
-.. method:: BaseHTTPRequestHandler.log_request([code[, size]])
+   .. method:: end_headers()
 
-   Logs an accepted (successful) request. *code* should specify the numeric HTTP
-   code associated with the response. If a size of the response is available, then
-   it should be passed as the *size* parameter.
+      Sends a blank line, indicating the end of the HTTP headers in the
+      response.
 
 
-.. method:: BaseHTTPRequestHandler.log_error(...)
+   .. method:: log_request([code[, size]])
 
-   Logs an error when a request cannot be fulfilled. By default, it passes the
-   message to :meth:`log_message`, so it takes the same arguments (*format* and
-   additional values).
+      Logs an accepted (successful) request. *code* should specify the numeric
+      HTTP code associated with the response. If a size of the response is
+      available, then it should be passed as the *size* parameter.
 
 
-.. method:: BaseHTTPRequestHandler.log_message(format, ...)
+   .. method:: log_error(...)
 
-   Logs an arbitrary message to ``sys.stderr``. This is typically overridden to
-   create custom error logging mechanisms. The *format* argument is a standard
-   printf-style format string, where the additional arguments to
-   :meth:`log_message` are applied as inputs to the formatting. The client address
-   and current date and time are prefixed to every message logged.
+      Logs an error when a request cannot be fulfilled. By default, it passes
+      the message to :meth:`log_message`, so it takes the same arguments
+      (*format* and additional values).
 
 
-.. method:: BaseHTTPRequestHandler.version_string()
+   .. method:: log_message(format, ...)
 
-   Returns the server software's version string. This is a combination of the
-   :attr:`server_version` and :attr:`sys_version` class variables.
+      Logs an arbitrary message to ``sys.stderr``. This is typically overridden
+      to create custom error logging mechanisms. The *format* argument is a
+      standard printf-style format string, where the additional arguments to
+      :meth:`log_message` are applied as inputs to the formatting. The client
+      address and current date and time are prefixed to every message logged.
 
 
-.. method:: BaseHTTPRequestHandler.date_time_string([timestamp])
+   .. method:: version_string()
 
-   Returns the date and time given by *timestamp* (which must be in the format
-   returned by :func:`time.time`), formatted for a message header. If *timestamp*
-   is omitted, it uses the current date and time.
+      Returns the server software's version string. This is a combination of the
+      :attr:`server_version` and :attr:`sys_version` class variables.
 
-   The result looks like ``'Sun, 06 Nov 1994 08:49:37 GMT'``.
 
-   .. versionadded:: 2.5
-      The *timestamp* parameter.
+   .. method:: date_time_string([timestamp])
 
+      Returns the date and time given by *timestamp* (which must be in the
+      format returned by :func:`time.time`), formatted for a message header. If
+      *timestamp* is omitted, it uses the current date and time.
 
-.. method:: BaseHTTPRequestHandler.log_date_time_string()
+      The result looks like ``'Sun, 06 Nov 1994 08:49:37 GMT'``.
 
-   Returns the current date and time, formatted for logging.
+      .. versionadded:: 2.5
+         The *timestamp* parameter.
 
 
-.. method:: BaseHTTPRequestHandler.address_string()
+   .. method:: log_date_time_string()
 
-   Returns the client address, formatted for logging. A name lookup is performed on
-   the client's IP address.
+      Returns the current date and time, formatted for logging.
+
+
+   .. method:: address_string()
+
+      Returns the client address, formatted for logging. A name lookup is
+      performed on the client's IP address.
+
+
+More examples
+-------------
+
+To create a server that doesn't run forever, but until some condition is
+fulfilled::
+
+   def run_while_true(server_class=BaseHTTPServer.HTTPServer,
+                      handler_class=BaseHTTPServer.BaseHTTPRequestHandler):
+       """
+       This assumes that keep_running() is a function of no arguments which
+       is tested initially and after each request.  If its return value
+       is true, the server continues.
+       """
+       server_address = ('', 8000)
+       httpd = server_class(server_address, handler_class)
+       while keep_running():
+           httpd.handle_request()
 
 
 .. seealso::
 
    Module :mod:`CGIHTTPServer`
       Extended request handler that supports CGI scripts.
 
    Module :mod:`SimpleHTTPServer`
-      Basic request handler that limits response to files actually under the document
-      root.
+      Basic request handler that limits response to files actually under the
+      document root.
 
