GNU Info
(python2.1-lib.info)BaseHTTPServer
Basic HTTP server
=================
Basic HTTP server (base class for `SimpleHTTPServer' and
`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 `SimpleHTTPServer'
and `CGIHTTPServer' modules.
The first class, `HTTPServer', is a `SocketServer.TCPServer' subclass.
It creates and listens at the web 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()
`HTTPServer(server_address, RequestHandlerClass)'
This class builds on the `TCPServer' class by storing the server
address as instance variables named `server_name' and
`server_port'. The server is accessible by the handler, typically
through the handler's `server' instance variable.
`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). `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
`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
`__init__()' method.
`BaseHTTPRequestHandler' has the following instance variables:
`client_address'
Contains a tuple of the form `(HOST, PORT)' referring to the
client's address.
`command'
Contains the command (request type). For example, `'GET''.
`path'
Contains the request path.
`request_version'
Contains the version string from the request. For example,
`'HTTP/1.0''.
`headers'
Holds an instance of the class specified by the `MessageClass'
class variable. This instance parses and manages the headers in
the HTTP request.
`rfile'
Contains an input stream, positioned at the start of the optional
input data.
`wfile'
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.
`BaseHTTPRequestHandler' has the following class variables:
`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''.
`sys_version'
Contains the Python system version, in a form usable by the
`version_string' method and the `server_version' class variable.
For example, `'Python/1.4''.
`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.
`protocol_version'
This specifies the HTTP protocol version used in responses.
Typically, this should not be overridden. Defaults to `'HTTP/1.0''.
`MessageClass'
Specifies a `rfc822.Message'-like class to parse HTTP headers.
Typically, this is not overridden, and it defaults to
`mimetools.Message'.
`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 `error_message_format'
class variable).
A `BaseHTTPRequestHandler' instance has the following methods:
`handle()'
Overrides the superclass' `handle()' method to provide the
specific handler behavior. This method will parse and dispatch the
request to the appropriate `do_*()' method.
`send_error(code[, message])'
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 `error_message_format' class variable.
`send_response(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
`version_string()' and `date_time_string()' methods, respectively.
`send_header(keyword, value)'
Writes a specific MIME header to the output stream. KEYWORD should
specify the header keyword, with VALUE specifying its value.
`end_headers()'
Sends a blank line, indicating the end of the MIME headers in the
response.
`log_request([code[, size]])'
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.
`log_error(...)'
Logs an error when a request cannot be fulfilled. By default, it
passes the message to `log_message()', so it takes the same
arguments (FORMAT and additional values).
`log_message(format, ...)'
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 `log_message()' are applied as inputs to
the formatting. The client address and current date and time are
prefixed to every message logged.
`version_string()'
Returns the server software's version string. This is a combination
of the `server_version' and `sys_version' class variables.
`date_time_string()'
Returns the current date and time, formatted for a message header.
`log_data_time_string()'
Returns the current date and time, formatted for logging.
`address_string()'
Returns the client address, formatted for logging. A name lookup
is performed on the client's IP address.
See also:
Note: CGIHTTPServer Extended request handler that supports CGI
scripts.
Note: SimpleHTTPServer Basic request handler that limits
response to files actually under the document root.
automatically generated by info2www version 1.2.2.9