← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/dispatch/request.py

  • Committer: William Grant
  • Date: 2009-04-28 04:50:39 UTC
  • Revision ID: grantw@unimelb.edu.au-20090428045039-ibb7gwtjrhe9osq3
Populate req.config in a cleaner manner.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/request.py
25
25
object.
26
26
"""
27
27
 
28
 
import mod_python
29
 
from mod_python import (util, Session, Cookie)
 
28
try:
 
29
    import mod_python.Session
 
30
    import mod_python.Cookie
 
31
    import mod_python.util
 
32
except ImportError:
 
33
    # This needs to be importable from outside Apache.
 
34
    pass
30
35
 
31
36
import ivle.util
32
37
import ivle.conf
33
38
import ivle.database
34
 
import plugins.console # XXX: Relies on www/ being in the Python path.
 
39
from ivle.webapp.base.plugins import CookiePlugin
35
40
 
36
41
class Request:
37
42
    """An IVLE request object. This is presented to the IVLE apps as a way of
73
78
        location (write)
74
79
            String. Response "Location" header value. Used with HTTP redirect
75
80
            responses.
76
 
        title (write)
77
 
            String. HTML page title. Used if write_html_head_foot is True, in
78
 
            the HTML title element text.
79
81
        styles (write)
80
82
            List of strings. Write a list of URLs to CSS files here, and they
81
83
            will be incorporated as <link rel="stylesheet" type="text/css">
94
96
            in the head, if write_html_head_foot is True.
95
97
            This is the propper way to specify functions that need to run at 
96
98
            page load time.
97
 
        write_html_head_foot (write)
98
 
            Boolean. If True, dispatch assumes that this is an XHTML page, and
99
 
            will immediately write a full HTML head, open the body element,
100
 
            and write heading contents to the page, before any bytes are
101
 
            written. It will then write footer contents and close the body and
102
 
            html elements at the end of execution.  
103
 
 
104
 
            This value should be set to true by all applications for all HTML
105
 
            output (unless there is a good reason, eg. exec). The
106
 
            applications should therefore output HTML content assuming that
107
 
            it will be written inside the body tag. Do not write opening or
108
 
            closing <html> or <body> tags.
109
99
    """
110
100
 
111
101
    # Special code for an OK response.
164
154
    HTTP_INSUFFICIENT_STORAGE         = 507
165
155
    HTTP_NOT_EXTENDED                 = 510
166
156
 
167
 
    def __init__(self, req, write_html_head):
168
 
        """Builds an IVLE request object from a mod_python request object.
169
 
        This results in an object with all of the necessary methods and
170
 
        additional fields.
 
157
    def __init__(self, req, config):
 
158
        """Create an IVLE request from a mod_python one.
171
159
 
172
 
        req: A mod_python request object.
173
 
        write_html_head: Function which is called when writing the automatic
174
 
            HTML header. Accepts a single argument, the IVLE request object.
 
160
        @param req: A mod_python request.
 
161
        @param config: An IVLE configuration.
175
162
        """
176
163
 
177
164
        # Methods are mostly wrappers around the Apache request object
178
165
        self.apache_req = req
179
 
        self.func_write_html_head = write_html_head
 
166
        self.config = config
180
167
        self.headers_written = False
181
168
 
182
169
        # Determine if the browser used the public host name to make the
183
170
        # request (in which case we are in "public mode")
184
 
        if req.hostname == ivle.conf.public_host:
 
171
        if req.hostname == config['urls']['public_host']:
185
172
            self.publicmode = True
186
173
        else:
187
174
            self.publicmode = False
206
193
        self.status = Request.HTTP_OK
207
194
        self.content_type = None        # Use Apache's default
208
195
        self.location = None
209
 
        self.title = None     # Will be set by dispatch before passing to app
210
196
        self.styles = []
211
197
        self.scripts = []
212
198
        self.scripts_init = []
213
 
        self.write_html_head_foot = False
214
199
        # In some cases we don't want the template JS (such as the username
215
200
        # and public FQDN) in the output HTML. In that case, set this to 0.
216
201
        self.write_javascript_settings = True
224
209
        """Writes out the HTTP and HTML headers before any real data is
225
210
        written."""
226
211
        self.headers_written = True
227
 
        
228
 
        # app is the App object for the chosen app
229
 
        try:
230
 
            app = ivle.conf.apps.app_url[self.app]
231
 
        except KeyError:
232
 
            app = None
233
 
 
234
 
        # Write any final modifications to header content
235
 
        if app and app.useconsole and self.user:
236
 
            plugins.console.insert_scripts_styles(self.scripts, self.styles, \
237
 
                self.scripts_init)
238
212
 
239
213
        # Prepare the HTTP and HTML headers before the first write is made
240
214
        if self.content_type != None:
242
216
        self.apache_req.status = self.status
243
217
        if self.location != None:
244
218
            self.apache_req.headers_out['Location'] = self.location
245
 
        if self.write_html_head_foot:
246
 
            # Write the HTML header, pass "self" (request object)
247
 
            self.func_write_html_head(self)
248
219
 
249
220
    def ensure_headers_written(self):
250
221
        """Writes out the HTTP and HTML headers if they haven't already been
267
238
            # This includes binary strings.
268
239
            self.apache_req.write(string, flush)
269
240
 
 
241
    def logout(self):
 
242
        """Log out the current user by destroying the session state.
 
243
        Then redirect to the top-level IVLE page."""
 
244
        if hasattr(self, 'session'):
 
245
            self.session.invalidate()
 
246
            self.session.delete()
 
247
            # Invalidates all IVLE cookies
 
248
            all_cookies = mod_python.Cookie.get_cookies(self)
 
249
 
 
250
            # Create cookies for plugins that might request them.
 
251
            for plugin in self.config.plugin_index[CookiePlugin]:
 
252
                for cookie in plugin.cookies:
 
253
                    self.add_cookie(mod_python.Cookie.Cookie(cookie, '',
 
254
                                                    expires=1, path='/'))
 
255
        self.throw_redirect(ivle.util.make_path('')) 
 
256
 
 
257
 
270
258
    def flush(self):
271
259
        """Flushes the output buffer."""
272
260
        self.apache_req.flush()
285
273
        else:
286
274
            return self.apache_req.read(len)
287
275
 
288
 
    def throw_error(self, httpcode, message=None):
289
 
        """Writes out an HTTP error of the specified code. Raises an exception
290
 
        which is caught by the dispatch or web server, so any code following
291
 
        this call will not be executed.
292
 
 
293
 
        httpcode: An HTTP response status code. Pass a constant from the
294
 
        Request class.
295
 
        """
296
 
        raise ivle.util.IVLEError(httpcode, message)
297
 
 
298
276
    def throw_redirect(self, location):
299
277
        """Writes out an HTTP redirect to the specified URL. Raises an
300
278
        exception which is caught by the dispatch or web server, so any
310
288
    def add_cookie(self, cookie, value=None, **attributes):
311
289
        """Inserts a cookie into this request object's headers."""
312
290
        if value is None:
313
 
            Cookie.add_cookie(self.apache_req, cookie)
 
291
            mod_python.Cookie.add_cookie(self.apache_req, cookie)
314
292
        else:
315
 
            Cookie.add_cookie(self.apache_req, cookie, value, **attributes)
 
293
            mod_python.Cookie.add_cookie(self.apache_req, cookie, value, **attributes)
316
294
 
317
295
    def get_session(self):
318
296
        """Returns a mod_python Session object for this request.
319
297
        Note that this is dependent on mod_python and may need to change
320
 
        interface if porting away from mod_python."""
 
298
        interface if porting away from mod_python.
 
299
 
 
300
        IMPORTANT: Call unlock() on the session as soon as you are done with
 
301
                   it! If you don't, all other requests will block!
 
302
        """
321
303
        # Cache the session object and set the timeout to 24 hours.
322
304
        if not hasattr(self, 'session'):
323
 
            self.session = Session.FileSession(self.apache_req,
 
305
            self.session = mod_python.Session.FileSession(self.apache_req,
324
306
                                               timeout = 60 * 60 * 24)
325
307
        return self.session
326
308
 
330
312
        interface if porting away from mod_python."""
331
313
        # Cache the fieldstorage object
332
314
        if not hasattr(self, 'fields'):
333
 
            self.fields = util.FieldStorage(self.apache_req)
 
315
            self.fields = mod_python.util.FieldStorage(self.apache_req)
334
316
        return self.fields
335
317
 
336
318
    def get_cgi_environ(self):