← 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-03-17 03:43:52 UTC
  • Revision ID: grantw@unimelb.edu.au-20090317034352-tiv0h96wmx39fwh4
Expose jQuery in our URL space.

Adds the concept of external media files, which are static files that we
pull in from third-party dependencies and serve under /+media/+external.

A new config option (media/externals/jquery) has been added to specify
where to find jquery.js - it defaults to /usr/share/javascript/jquery,
which is both a generally sane location and also the Debian/Ubuntu one.

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):
 
157
    def __init__(self, req):
168
158
        """Builds an IVLE request object from a mod_python request object.
169
159
        This results in an object with all of the necessary methods and
170
160
        additional fields.
171
161
 
172
162
        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.
175
163
        """
176
164
 
177
165
        # Methods are mostly wrappers around the Apache request object
178
166
        self.apache_req = req
179
 
        self.func_write_html_head = write_html_head
180
167
        self.headers_written = False
181
168
 
182
169
        # Determine if the browser used the public host name to make the
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
270
241
    def logout(self):
271
242
        """Log out the current user by destroying the session state.
272
243
        Then redirect to the top-level IVLE page."""
273
 
        # List of cookies that IVLE uses (to be removed at logout)
274
 
        ivle_cookies = ["ivleforumcookie", "clipboard"]
275
 
        
276
244
        if hasattr(self, 'session'):
277
245
            self.session.invalidate()
278
246
            self.session.delete()
279
247
            # Invalidates all IVLE cookies
280
 
            all_cookies = Cookie.get_cookies(self)
281
 
            for cookie in all_cookies:
282
 
                if cookie in ivle_cookies:
283
 
                    self.add_cookie(Cookie.Cookie(cookie,'',expires=1,path='/'))
 
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='/'))
284
255
        self.throw_redirect(ivle.util.make_path('')) 
285
256
 
286
257
 
302
273
        else:
303
274
            return self.apache_req.read(len)
304
275
 
305
 
    def throw_error(self, httpcode, message=None):
306
 
        """Writes out an HTTP error of the specified code. Raises an exception
307
 
        which is caught by the dispatch or web server, so any code following
308
 
        this call will not be executed.
309
 
 
310
 
        httpcode: An HTTP response status code. Pass a constant from the
311
 
        Request class.
312
 
        """
313
 
        raise ivle.util.IVLEError(httpcode, message)
314
 
 
315
276
    def throw_redirect(self, location):
316
277
        """Writes out an HTTP redirect to the specified URL. Raises an
317
278
        exception which is caught by the dispatch or web server, so any
327
288
    def add_cookie(self, cookie, value=None, **attributes):
328
289
        """Inserts a cookie into this request object's headers."""
329
290
        if value is None:
330
 
            Cookie.add_cookie(self.apache_req, cookie)
 
291
            mod_python.Cookie.add_cookie(self.apache_req, cookie)
331
292
        else:
332
 
            Cookie.add_cookie(self.apache_req, cookie, value, **attributes)
 
293
            mod_python.Cookie.add_cookie(self.apache_req, cookie, value, **attributes)
333
294
 
334
295
    def get_session(self):
335
296
        """Returns a mod_python Session object for this request.
336
297
        Note that this is dependent on mod_python and may need to change
337
 
        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
        """
338
303
        # Cache the session object and set the timeout to 24 hours.
339
304
        if not hasattr(self, 'session'):
340
 
            self.session = Session.FileSession(self.apache_req,
 
305
            self.session = mod_python.Session.FileSession(self.apache_req,
341
306
                                               timeout = 60 * 60 * 24)
342
307
        return self.session
343
308
 
347
312
        interface if porting away from mod_python."""
348
313
        # Cache the fieldstorage object
349
314
        if not hasattr(self, 'fields'):
350
 
            self.fields = util.FieldStorage(self.apache_req)
 
315
            self.fields = mod_python.util.FieldStorage(self.apache_req)
351
316
        return self.fields
352
317
 
353
318
    def get_cgi_environ(self):