| | |
- web.cgi.CGIManager
- web.cgi.CGIObject
- web.cgi.CGIRequest
- web.cgi.CGIResponse
class CGIManager |
| |
This class is intended to serve as the basic implementation of
a CGI _dispatcher_. It routes a @CGIRequest to python objects and
modules that service the request.
This class uses the path information associated with the request
to determine how the request is routed. If there is no path info
associated with the request, the @defaultHandler() method is called.
If the first component of the path is an object stored in the managers
object dictionary, the request goes to the object. If the object is a
@CGIObject, the rest of the path information is ignored and the
object's processRequest() method is called. For any other kind of
object, if there is a second path component, the manager will attempt
to call a method of that name on the object. If there is no second
path component, the object /itself/ will be called.
If the first component is not an object stored in the manager, the
manager checks to see if there is a python module in the current
working directory of that name. In this case, there must be a second
path component and it is the function that is called within the
module. The module will be reloaded if its file has been changed since
the last time that it was loaded, making the CGIManager very well
suited to interactive debugging.
All functions and methods (including processRequest()) that are
provided to the manager must accept the following argument list:
/manager/::
The CGIManager instance that is initiating the call.
/request/::
The @CGIRequest object.
/response/::
The @CGIResponse object.
The CGIManager can be used within the context of stand-alone CGI
programs, but it is really designed to be housed in a running process
into which smaller cgi programs can feed it requests, either through
distributed object method invocations or some other means.
|
| |
Methods defined here:
- __init__(self)
- addObject(self, key, val)
- defaultHandler(self, request, response)
- error(self, request, response)
- process(self, request, response=None)
- removeObject(self, key)
- test(self, request, response)
|
class CGIObject |
| |
This is an abstract base class for objects that implement the
processRequest() method. When requests are sent to these objects,
the processRequest() method is always called and it is up to the
derived class to process the request.
|
| |
Methods defined here:
- processRequest(self, manager, request, response)
- Called whenever a request is sent to the object. /manager/
is the CGIManager instance, /request/ is a @CGIRequest instance,
and /response/ is a @CGIResponse instance.
|
class CGIRequest |
| |
This is just a bundle of the parameters in a CGI request.
Public variables:
*args*::
Argument list of the original CGI command.
*env*::
Environment of the original CGI command (a dictionary).
*query*::
Query parameters of the original CGI command parsed into a
dictionary.
*path*::
The CGI command path info, broken up into a list. Path info
is the URL path that follows the command name. If the URL
is `"http://somehost/cgi-bin/cgipdisp/service/name"`, then this
variable would contain ['service', 'name'].
*cookies*::
A dictionary mapping cookie names to values.
|
| |
Methods defined here:
- __init__(self, args, env, query, path, cookies=None)
|
class CGIResponse |
| |
This is another bundle of attributes designed to deliver a response
to the client.
Public variables:
*out*::
The cgi output stream.
service = args[1]
|
| |
Methods defined here:
- __init__(self, out)
- getContentType(self)
- Returns the content type string of the output stream. If the
headers have not been written, this will be an empty string.
- headersWritten(self)
- writeHeaders(self, contentType='text/html', otherHeaders=[])
- Writes the headers if they have not already been written.
The "Content-type" header is the only one that is always written.
If any other headers are desired, they may be added in the
/otherHeaders/ list, which should be a list of string headers
with their associated values but no line terminators.
| |