GNU Info

Info Node: (python2.1-lib.info)BaseHTTPServer

(python2.1-lib.info)BaseHTTPServer


Next: SimpleHTTPServer Prev: SocketServer Up: Internet Protocols and Support
Enter node , (file) or (file)node

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