← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to src/dispatch/request.py

  • Committer: mattgiuca
  • Date: 2007-12-17 05:20:17 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:74
apps/help: Full help file handling (now this module works).
apps/dummy: Added help file.
common/util: Added make_local_path.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dispatch/request.py
23
23
# See design notes/apps/dispatch.txt for a full specification of this request
24
24
# object.
25
25
 
 
26
import common.util
 
27
import mod_python
 
28
 
26
29
class Request:
27
30
    """An IVLE request object. This is presented to the IVLE apps as a way of
28
 
    interacting with the web server and the dispatcher."""
29
 
 
30
 
    # Special code for "everything's OK" (somehow different to 200).
 
31
    interacting with the web server and the dispatcher.
 
32
 
 
33
    Request object attributes:
 
34
        uri (read)
 
35
            String. The path portion of the URI.
 
36
        app (read)
 
37
            String. Name of the application specified in the URL, or None.
 
38
        path (read)
 
39
            String. The path specified in the URL *not including* the
 
40
            application or the IVLE location prefix. eg. a URL of
 
41
            "/ivle/files/joe/myfiles" has a path of "joe/myfiles".
 
42
 
 
43
        status (write)
 
44
            Int. Response status number. Use one of the status codes defined
 
45
            in class Request.
 
46
        content_type (write)
 
47
            String. The Content-Type (mime type) header value.
 
48
        location (write)
 
49
            String. Response "Location" header value. Used with HTTP redirect
 
50
            responses.
 
51
        title (write)
 
52
            String. HTML page title. Used if write_html_head_foot is True, in
 
53
            the HTML title element text.
 
54
        write_html_head_foot (write)
 
55
            Boolean. If True, dispatch assumes that this is an XHTML page, and
 
56
            will immediately write a full HTML head, open the body element,
 
57
            and write heading contents to the page, before any bytes are
 
58
            written. It will then write footer contents and close the body and
 
59
            html elements at the end of execution.  
 
60
 
 
61
            This value should be set to true by all applications for all HTML
 
62
            output (unless there is a good reason, eg. exec). The
 
63
            applications should therefore output HTML content assuming that
 
64
            it will be written inside the body tag. Do not write opening or
 
65
            closing <html> or <body> tags.
 
66
    """
 
67
 
 
68
    # Special code for an OK response.
 
69
    # Do not use HTTP_OK; for some reason Apache produces an "OK" error
 
70
    # message if you do that.
31
71
    OK  = 0
32
72
 
33
73
    # HTTP status codes
81
121
    HTTP_INSUFFICIENT_STORAGE         = 507
82
122
    HTTP_NOT_EXTENDED                 = 510
83
123
 
84
 
    def __init__(self, req):
 
124
    def __init__(self, req, write_html_head):
85
125
        """Builds an IVLE request object from a mod_python request object.
86
126
        This results in an object with all of the necessary methods and
87
127
        additional fields.
88
128
 
89
129
        req: A mod_python request object.
 
130
        write_html_head: Function which is called when writing the automatic
 
131
            HTML header. Accepts a single argument, the IVLE request object.
90
132
        """
91
133
 
92
134
        # Methods are mostly wrappers around the Apache request object
93
135
        self.apache_req = req
 
136
        self.func_write_html_head = write_html_head
 
137
        self.headers_written = False
94
138
 
95
139
        # Inherit values for the input members
96
140
        self.uri = req.uri
 
141
        # Split the given path into the app (top-level dir) and sub-path
 
142
        # (after first stripping away the root directory)
 
143
        (self.app, self.path) = (
 
144
            common.util.split_path(common.util.unmake_path(req.uri)))
97
145
 
98
146
        # Default values for the output members
99
147
        self.status = Request.OK
102
150
        self.title = None     # Will be set by dispatch before passing to app
103
151
        self.write_html_head_foot = False
104
152
 
 
153
    def __writeheaders(self):
 
154
        """Writes out the HTTP and HTML headers before any real data is
 
155
        written."""
 
156
        self.headers_written = True
 
157
        # Prepare the HTTP and HTML headers before the first write is made
 
158
        if self.content_type != None:
 
159
            self.apache_req.content_type = self.content_type
 
160
        self.apache_req.status = self.status
 
161
        if self.location != None:
 
162
            self.apache_req.headers_out['Location'] = self.location
 
163
        if self.write_html_head_foot:
 
164
            # Write the HTML header, pass "self" (request object)
 
165
            self.func_write_html_head(self)
 
166
 
 
167
    def ensure_headers_written(self):
 
168
        """Writes out the HTTP and HTML headers if they haven't already been
 
169
        written."""
 
170
        if not self.headers_written:
 
171
            self.__writeheaders()
 
172
 
105
173
    def write(self, string, flush=1):
106
174
        """Writes string directly to the client, then flushes the buffer,
107
175
        unless flush is 0."""
108
176
 
109
 
        # TODO: Prepare the IVLE HTTP and HTML headers before the first write.
 
177
        if not self.headers_written:
 
178
            self.__writeheaders()
110
179
        self.apache_req.write(string, flush)
111
180
 
112
181
    def flush(self):
113
182
        """Flushes the output buffer."""
114
183
        self.apache_req.flush()
 
184
 
 
185
    def sendfile(self, filename):
 
186
        """Sends the named file directly to the client."""
 
187
        if not self.headers_written:
 
188
            self.__writeheaders()
 
189
        self.apache_req.sendfile(filename)
 
190
 
 
191
    def read(self, len=None):
 
192
        """Reads at most len bytes directly from the client. (See mod_python
 
193
        Request.read)."""
 
194
        if len is None:
 
195
            self.apache_req.read()
 
196
        else:
 
197
            self.apache_req.read(len)
 
198
 
 
199
    def throw_error(self, httpcode):
 
200
        """Writes out an HTTP error of the specified code. Raises an exception
 
201
        which is caught by the dispatch or web server, so any code following
 
202
        this call will not be executed.
 
203
 
 
204
        httpcode: An HTTP response status code. Pass a constant from the
 
205
        Request class.
 
206
        """
 
207
        raise mod_python.apache.SERVER_RETURN, httpcode
 
208
 
 
209
    def throw_redirect(self, location):
 
210
        """Writes out an HTTP redirect to the specified URL. Raises an
 
211
        exception which is caught by the dispatch or web server, so any
 
212
        code following this call will not be executed.
 
213
 
 
214
        httpcode: An HTTP response status code. Pass a constant from the
 
215
        Request class.
 
216
        """
 
217
        mod_python.util.redirect(self.apache_req, location)