← 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: mattgiuca
  • Date: 2008-02-28 08:03:25 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:610
server, download: More fixes to error messages.

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)
 
28
from mod_python import (util, Session, Cookie)
 
29
import conf
29
30
 
30
31
class Request:
31
32
    """An IVLE request object. This is presented to the IVLE apps as a way of
42
43
            String. The path specified in the URL *not including* the
43
44
            application or the IVLE location prefix. eg. a URL of
44
45
            "/ivle/files/joe/myfiles" has a path of "joe/myfiles".
45
 
        username (read)
46
 
            String. Login name of the user who is currently logged in, or
 
46
        user (read)
 
47
            User object. Details of the user who is currently logged in, or
47
48
            None.
 
49
        hostname (read)
 
50
            String. Hostname the server is running on.
48
51
        headers_in (read)
49
52
            Table object representing headers sent by the client.
50
53
        headers_out (read, can be written to)
51
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).
52
59
 
53
60
        status (write)
54
61
            Int. Response status number. Use one of the status codes defined
61
68
        title (write)
62
69
            String. HTML page title. Used if write_html_head_foot is True, in
63
70
            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.
64
83
        write_html_head_foot (write)
65
84
            Boolean. If True, dispatch assumes that this is an XHTML page, and
66
85
            will immediately write a full HTML head, open the body element,
146
165
        self.func_write_html_head = write_html_head
147
166
        self.headers_written = False
148
167
 
 
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
 
149
175
        # Inherit values for the input members
150
176
        self.method = req.method
151
177
        self.uri = req.uri
152
178
        # Split the given path into the app (top-level dir) and sub-path
153
179
        # (after first stripping away the root directory)
154
 
        (self.app, self.path) = (
155
 
            common.util.split_path(common.util.unmake_path(req.uri)))
156
 
        self.username = None
 
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
157
188
        self.headers_in = req.headers_in
158
189
        self.headers_out = req.headers_out
159
190
 
162
193
        self.content_type = None        # Use Apache's default
163
194
        self.location = None
164
195
        self.title = None     # Will be set by dispatch before passing to app
 
196
        self.styles = []
 
197
        self.scripts = []
165
198
        self.write_html_head_foot = False
 
199
        self.got_common_vars = False
166
200
 
167
201
    def __writeheaders(self):
168
202
        """Writes out the HTTP and HTML headers before any real data is
190
224
 
191
225
        if not self.headers_written:
192
226
            self.__writeheaders()
193
 
        self.apache_req.write(string, flush)
 
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)
194
235
 
195
236
    def flush(self):
196
237
        """Flushes the output buffer."""
206
247
        """Reads at most len bytes directly from the client. (See mod_python
207
248
        Request.read)."""
208
249
        if len is None:
209
 
            self.apache_req.read()
 
250
            return self.apache_req.read()
210
251
        else:
211
 
            self.apache_req.read(len)
 
252
            return self.apache_req.read(len)
212
253
 
213
 
    def throw_error(self, httpcode):
 
254
    def throw_error(self, httpcode, message=None):
214
255
        """Writes out an HTTP error of the specified code. Raises an exception
215
256
        which is caught by the dispatch or web server, so any code following
216
257
        this call will not be executed.
218
259
        httpcode: An HTTP response status code. Pass a constant from the
219
260
        Request class.
220
261
        """
221
 
        raise mod_python.apache.SERVER_RETURN, httpcode
 
262
        raise common.util.IVLEError(httpcode, message)
222
263
 
223
264
    def throw_redirect(self, location):
224
265
        """Writes out an HTTP redirect to the specified URL. Raises an
230
271
        """
231
272
        mod_python.util.redirect(self.apache_req, location)
232
273
 
 
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
 
233
281
    def get_session(self):
234
282
        """Returns a mod_python Session object for this request.
235
283
        Note that this is dependent on mod_python and may need to change
236
284
        interface if porting away from mod_python."""
237
 
        # Cache the session object
 
285
        # Cache the session object and set the timeout to 24 hours.
238
286
        if not hasattr(self, 'session'):
239
 
            self.session = Session.Session(self.apache_req)
 
287
            self.session = Session.FileSession(self.apache_req,
 
288
                                               timeout = 60 * 60 * 24)
240
289
        return self.session
241
290
 
242
291
    def get_fieldstorage(self):
247
296
        if not hasattr(self, 'fields'):
248
297
            self.fields = util.FieldStorage(self.apache_req)
249
298
        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
}