← Back to branch summary

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

« back to all changes in this revision

Viewing changes to www/dispatch/request.py

  • Committer: drtomc
  • Date: 2008-01-02 22:05:22 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:127
A bit of simplification - unify the output areas and use colours to
distinguish output, return values and errors.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/dispatch/request.py
25
25
 
26
26
import common.util
27
27
import mod_python
28
 
from mod_python import (util, Session, Cookie)
29
 
import conf
 
28
from mod_python import (util, Session)
30
29
 
31
30
class Request:
32
31
    """An IVLE request object. This is presented to the IVLE apps as a way of
43
42
            String. The path specified in the URL *not including* the
44
43
            application or the IVLE location prefix. eg. a URL of
45
44
            "/ivle/files/joe/myfiles" has a path of "joe/myfiles".
46
 
        user (read)
47
 
            User object. Details of the user who is currently logged in, or
 
45
        username (read)
 
46
            String. Login name of the user who is currently logged in, or
48
47
            None.
49
 
        hostname (read)
50
 
            String. Hostname the server is running on.
51
 
        headers_in (read)
52
 
            Table object representing headers sent by the client.
53
 
        headers_out (read, can be written to)
54
 
            Table object representing headers to be sent to the client.
55
 
        publicmode (read)
56
 
            Bool. True if the request came for the "public host" as
57
 
            configured in conf.py. Note that public mode requests do not
58
 
            have an app (app is set to None).
59
48
 
60
49
        status (write)
61
50
            Int. Response status number. Use one of the status codes defined
68
57
        title (write)
69
58
            String. HTML page title. Used if write_html_head_foot is True, in
70
59
            the HTML title element text.
71
 
        styles (write)
72
 
            List of strings. Write a list of URLs to CSS files here, and they
73
 
            will be incorporated as <link rel="stylesheet" type="text/css">
74
 
            elements in the head, if write_html_head_foot is True.
75
 
            URLs should be relative to the IVLE root; they will be fixed up
76
 
            to be site-relative.
77
 
        scripts (write)
78
 
            List of strings. Write a list of URLs to JS files here, and they
79
 
            will be incorporated as <script type="text/javascript"> elements
80
 
            in the head, if write_html_head_foot is True.
81
 
            URLs should be relative to the IVLE root; they will be fixed up
82
 
            to be site-relative.
83
60
        write_html_head_foot (write)
84
61
            Boolean. If True, dispatch assumes that this is an XHTML page, and
85
62
            will immediately write a full HTML head, open the body element,
165
142
        self.func_write_html_head = write_html_head
166
143
        self.headers_written = False
167
144
 
168
 
        # Determine if the browser used the public host name to make the
169
 
        # request (in which case we are in "public mode")
170
 
        if req.hostname == conf.public_host:
171
 
            self.publicmode = True
172
 
        else:
173
 
            self.publicmode = False
174
 
 
175
145
        # Inherit values for the input members
176
146
        self.method = req.method
177
147
        self.uri = req.uri
178
148
        # Split the given path into the app (top-level dir) and sub-path
179
149
        # (after first stripping away the root directory)
180
 
        path = common.util.unmake_path(req.uri)
181
 
        if self.publicmode:
182
 
            self.app = None
183
 
            self.path = path
184
 
        else:
185
 
            (self.app, self.path) = (common.util.split_path(path))
186
 
        self.user = None
187
 
        self.hostname = req.hostname
188
 
        self.headers_in = req.headers_in
189
 
        self.headers_out = req.headers_out
 
150
        (self.app, self.path) = (
 
151
            common.util.split_path(common.util.unmake_path(req.uri)))
 
152
        self.username = None
190
153
 
191
154
        # Default values for the output members
192
 
        self.status = Request.HTTP_OK
 
155
        self.status = Request.OK
193
156
        self.content_type = None        # Use Apache's default
194
157
        self.location = None
195
158
        self.title = None     # Will be set by dispatch before passing to app
196
 
        self.styles = []
197
 
        self.scripts = []
198
159
        self.write_html_head_foot = False
199
 
        self.got_common_vars = False
200
160
 
201
161
    def __writeheaders(self):
202
162
        """Writes out the HTTP and HTML headers before any real data is
224
184
 
225
185
        if not self.headers_written:
226
186
            self.__writeheaders()
227
 
        if isinstance(string, unicode):
228
 
            # Encode unicode strings as UTF-8
229
 
            # (Otherwise cannot handle being written to a bytestream)
230
 
            self.apache_req.write(string.encode('utf8'), flush)
231
 
        else:
232
 
            # 8-bit clean strings just get written directly.
233
 
            # This includes binary strings.
234
 
            self.apache_req.write(string, flush)
 
187
        self.apache_req.write(string, flush)
235
188
 
236
189
    def flush(self):
237
190
        """Flushes the output buffer."""
247
200
        """Reads at most len bytes directly from the client. (See mod_python
248
201
        Request.read)."""
249
202
        if len is None:
250
 
            return self.apache_req.read()
 
203
            self.apache_req.read()
251
204
        else:
252
 
            return self.apache_req.read(len)
 
205
            self.apache_req.read(len)
253
206
 
254
 
    def throw_error(self, httpcode, message=None):
 
207
    def throw_error(self, httpcode):
255
208
        """Writes out an HTTP error of the specified code. Raises an exception
256
209
        which is caught by the dispatch or web server, so any code following
257
210
        this call will not be executed.
259
212
        httpcode: An HTTP response status code. Pass a constant from the
260
213
        Request class.
261
214
        """
262
 
        raise common.util.IVLEError(httpcode, message)
 
215
        raise mod_python.apache.SERVER_RETURN, httpcode
263
216
 
264
217
    def throw_redirect(self, location):
265
218
        """Writes out an HTTP redirect to the specified URL. Raises an
271
224
        """
272
225
        mod_python.util.redirect(self.apache_req, location)
273
226
 
274
 
    def add_cookie(self, cookie, value=None, **attributes):
275
 
        """Inserts a cookie into this request object's headers."""
276
 
        if value is None:
277
 
            Cookie.add_cookie(self.apache_req, cookie)
278
 
        else:
279
 
            Cookie.add_cookie(self.apache_req, cookie, value, **attributes)
280
 
 
281
227
    def get_session(self):
282
228
        """Returns a mod_python Session object for this request.
283
229
        Note that this is dependent on mod_python and may need to change
284
230
        interface if porting away from mod_python."""
285
 
        # Cache the session object and set the timeout to 24 hours.
 
231
        # Cache the session object
286
232
        if not hasattr(self, 'session'):
287
 
            self.session = Session.FileSession(self.apache_req,
288
 
                                               timeout = 60 * 60 * 24)
 
233
            self.session = Session.Session(self.apache_req)
289
234
        return self.session
290
235
 
291
236
    def get_fieldstorage(self):
296
241
        if not hasattr(self, 'fields'):
297
242
            self.fields = util.FieldStorage(self.apache_req)
298
243
        return self.fields
299
 
 
300
 
    def get_cgi_environ(self):
301
 
        """Returns the CGI environment emulation for this request. (Calls
302
 
        add_common_vars). The environment is returned as a mapping
303
 
        compatible with os.environ."""
304
 
        if not self.got_common_vars:
305
 
            self.apache_req.add_common_vars()
306
 
            self.got_common_vars = True
307
 
        return self.apache_req.subprocess_env
308
 
 
309
 
    @staticmethod
310
 
    def get_http_codename(code):
311
 
        """Given a HTTP error code int, returns a (name, description)
312
 
        pair, suitable for displaying to the user.
313
 
        May return (None,None) if code is unknown.
314
 
        Only lists common 4xx and 5xx codes (since this is just used
315
 
        to display throw_error error messages).
316
 
        """
317
 
        try:
318
 
            return http_codenames[code]
319
 
        except KeyError:
320
 
            return None, None
321
 
 
322
 
# Human strings for HTTP response codes
323
 
http_codenames = {
324
 
    Request.HTTP_BAD_REQUEST:
325
 
        ("Bad Request",
326
 
        "Your browser sent a request IVLE did not understand."),
327
 
    Request.HTTP_UNAUTHORIZED:
328
 
        ("Unauthorized",
329
 
        "You are not allowed to view this part of IVLE."),
330
 
    Request.HTTP_FORBIDDEN:
331
 
        ("Forbidden",
332
 
        "You are not allowed to view this part of IVLE."),
333
 
    Request.HTTP_NOT_FOUND:
334
 
        ("Not Found",
335
 
        "The application or file you requested does not exist."),
336
 
    Request.HTTP_METHOD_NOT_ALLOWED:
337
 
        ("Method Not Allowed",
338
 
        "Your browser is interacting with IVLE in the wrong way."
339
 
        "This is probably a bug in IVLE. "
340
 
        "Please report it to the administrators."),
341
 
    Request.HTTP_INTERNAL_SERVER_ERROR:
342
 
        ("Internal Server Error",
343
 
        "An unknown error occured in IVLE."),
344
 
    Request.HTTP_NOT_IMPLEMENTED:
345
 
        ("Not Implemented",
346
 
        "The application or file you requested has not been implemented "
347
 
        "in IVLE."),
348
 
    Request.HTTP_SERVICE_UNAVAILABLE:
349
 
        ("Service Unavailable",
350
 
        "IVLE is currently experiencing technical difficulties. "
351
 
        "Please try again later."),
352
 
}