← 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: chadnickbok
  • Date: 2009-01-13 05:33:58 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:1108
Updated the settings page to require the old password
when updating the password. Note that this field
is not shown when using ldap authentication

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
 
30
import plugins.console
29
31
 
30
32
class Request:
31
33
    """An IVLE request object. This is presented to the IVLE apps as a way of
42
44
            String. The path specified in the URL *not including* the
43
45
            application or the IVLE location prefix. eg. a URL of
44
46
            "/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
 
47
        user (read)
 
48
            User object. Details of the user who is currently logged in, or
47
49
            None.
 
50
        hostname (read)
 
51
            String. Hostname the server is running on.
 
52
        headers_in (read)
 
53
            Table object representing headers sent by the client.
 
54
        headers_out (read, can be written to)
 
55
            Table object representing headers to be sent to the client.
 
56
        publicmode (read)
 
57
            Bool. True if the request came for the "public host" as
 
58
            configured in conf.py. Note that public mode requests do not
 
59
            have an app (app is set to None).
48
60
 
49
61
        status (write)
50
62
            Int. Response status number. Use one of the status codes defined
57
69
        title (write)
58
70
            String. HTML page title. Used if write_html_head_foot is True, in
59
71
            the HTML title element text.
 
72
        styles (write)
 
73
            List of strings. Write a list of URLs to CSS files here, and they
 
74
            will be incorporated as <link rel="stylesheet" type="text/css">
 
75
            elements in the head, if write_html_head_foot is True.
 
76
            URLs should be relative to the IVLE root; they will be fixed up
 
77
            to be site-relative.
 
78
        scripts (write)
 
79
            List of strings. Write a list of URLs to JS files here, and they
 
80
            will be incorporated as <script type="text/javascript"> elements
 
81
            in the head, if write_html_head_foot is True.
 
82
            URLs should be relative to the IVLE root; they will be fixed up
 
83
            to be site-relative.
 
84
        scripts_init (write)
 
85
            List of strings. Write a list of JS function names, and they
 
86
            will be added as window.addListener('load', ..., false); calls
 
87
            in the head, if write_html_head_foot is True.
 
88
            This is the propper way to specify functions that need to run at 
 
89
            page load time.
60
90
        write_html_head_foot (write)
61
91
            Boolean. If True, dispatch assumes that this is an XHTML page, and
62
92
            will immediately write a full HTML head, open the body element,
142
172
        self.func_write_html_head = write_html_head
143
173
        self.headers_written = False
144
174
 
 
175
        # Determine if the browser used the public host name to make the
 
176
        # request (in which case we are in "public mode")
 
177
        if req.hostname == conf.public_host:
 
178
            self.publicmode = True
 
179
        else:
 
180
            self.publicmode = False
 
181
 
145
182
        # Inherit values for the input members
146
183
        self.method = req.method
147
184
        self.uri = req.uri
148
185
        # Split the given path into the app (top-level dir) and sub-path
149
186
        # (after first stripping away the root directory)
150
 
        (self.app, self.path) = (
151
 
            common.util.split_path(common.util.unmake_path(req.uri)))
152
 
        self.username = None
 
187
        path = common.util.unmake_path(req.uri)
 
188
        (self.app, self.path) = (common.util.split_path(path))
 
189
        self.user = None
 
190
        self.hostname = req.hostname
 
191
        self.headers_in = req.headers_in
 
192
        self.headers_out = req.headers_out
153
193
 
154
194
        # Default values for the output members
155
 
        self.status = Request.OK
 
195
        self.status = Request.HTTP_OK
156
196
        self.content_type = None        # Use Apache's default
157
197
        self.location = None
158
198
        self.title = None     # Will be set by dispatch before passing to app
 
199
        self.styles = []
 
200
        self.scripts = []
 
201
        self.scripts_init = []
159
202
        self.write_html_head_foot = False
 
203
        # In some cases we don't want the template JS (such as the username
 
204
        # and public FQDN) in the output HTML. In that case, set this to 0.
 
205
        self.write_javascript_settings = True
 
206
        self.got_common_vars = False
160
207
 
161
208
    def __writeheaders(self):
162
209
        """Writes out the HTTP and HTML headers before any real data is
163
210
        written."""
164
211
        self.headers_written = True
 
212
        
 
213
        # app is the App object for the chosen app
 
214
        try:
 
215
            app = conf.apps.app_url[self.app]
 
216
        except KeyError:
 
217
            app = None
 
218
 
 
219
        # Write any final modifications to header content
 
220
        if app and app.useconsole and self.user:
 
221
            plugins.console.insert_scripts_styles(self.scripts, self.styles, \
 
222
                self.scripts_init)
 
223
 
165
224
        # Prepare the HTTP and HTML headers before the first write is made
166
225
        if self.content_type != None:
167
226
            self.apache_req.content_type = self.content_type
184
243
 
185
244
        if not self.headers_written:
186
245
            self.__writeheaders()
187
 
        self.apache_req.write(string, flush)
 
246
        if isinstance(string, unicode):
 
247
            # Encode unicode strings as UTF-8
 
248
            # (Otherwise cannot handle being written to a bytestream)
 
249
            self.apache_req.write(string.encode('utf8'), flush)
 
250
        else:
 
251
            # 8-bit clean strings just get written directly.
 
252
            # This includes binary strings.
 
253
            self.apache_req.write(string, flush)
 
254
 
 
255
    def logout(self):
 
256
        """Log out the current user by destroying the session state.
 
257
        Then redirect to the top-level IVLE page."""
 
258
        # List of cookies that IVLE uses (to be removed at logout)
 
259
        ivle_cookies = ["ivleforumcookie", "clipboard"]
 
260
        
 
261
        if hasattr(self, 'session'):
 
262
            self.session.invalidate()
 
263
            self.session.delete()
 
264
            # Invalidates all IVLE cookies
 
265
            all_cookies = Cookie.get_cookies(self)
 
266
            for cookie in all_cookies:
 
267
                if cookie in ivle_cookies:
 
268
                    self.add_cookie(Cookie.Cookie(cookie,'',expires=1,path='/'))
 
269
        self.throw_redirect(common.util.make_path('')) 
 
270
 
188
271
 
189
272
    def flush(self):
190
273
        """Flushes the output buffer."""
200
283
        """Reads at most len bytes directly from the client. (See mod_python
201
284
        Request.read)."""
202
285
        if len is None:
203
 
            self.apache_req.read()
 
286
            return self.apache_req.read()
204
287
        else:
205
 
            self.apache_req.read(len)
 
288
            return self.apache_req.read(len)
206
289
 
207
 
    def throw_error(self, httpcode):
 
290
    def throw_error(self, httpcode, message=None):
208
291
        """Writes out an HTTP error of the specified code. Raises an exception
209
292
        which is caught by the dispatch or web server, so any code following
210
293
        this call will not be executed.
212
295
        httpcode: An HTTP response status code. Pass a constant from the
213
296
        Request class.
214
297
        """
215
 
        raise mod_python.apache.SERVER_RETURN, httpcode
 
298
        raise common.util.IVLEError(httpcode, message)
216
299
 
217
300
    def throw_redirect(self, location):
218
301
        """Writes out an HTTP redirect to the specified URL. Raises an
224
307
        """
225
308
        mod_python.util.redirect(self.apache_req, location)
226
309
 
 
310
    def add_cookie(self, cookie, value=None, **attributes):
 
311
        """Inserts a cookie into this request object's headers."""
 
312
        if value is None:
 
313
            Cookie.add_cookie(self.apache_req, cookie)
 
314
        else:
 
315
            Cookie.add_cookie(self.apache_req, cookie, value, **attributes)
 
316
 
227
317
    def get_session(self):
228
318
        """Returns a mod_python Session object for this request.
229
319
        Note that this is dependent on mod_python and may need to change
230
320
        interface if porting away from mod_python."""
231
 
        # Cache the session object
 
321
        # Cache the session object and set the timeout to 24 hours.
232
322
        if not hasattr(self, 'session'):
233
 
            self.session = Session.Session(self.apache_req)
 
323
            self.session = Session.FileSession(self.apache_req,
 
324
                                               timeout = 60 * 60 * 24)
234
325
        return self.session
235
326
 
236
327
    def get_fieldstorage(self):
241
332
        if not hasattr(self, 'fields'):
242
333
            self.fields = util.FieldStorage(self.apache_req)
243
334
        return self.fields
 
335
 
 
336
    def get_cgi_environ(self):
 
337
        """Returns the CGI environment emulation for this request. (Calls
 
338
        add_common_vars). The environment is returned as a mapping
 
339
        compatible with os.environ."""
 
340
        if not self.got_common_vars:
 
341
            self.apache_req.add_common_vars()
 
342
            self.got_common_vars = True
 
343
        return self.apache_req.subprocess_env
 
344
 
 
345
    @staticmethod
 
346
    def get_http_codename(code):
 
347
        """Given a HTTP error code int, returns a (name, description)
 
348
        pair, suitable for displaying to the user.
 
349
        May return (None,None) if code is unknown.
 
350
        Only lists common 4xx and 5xx codes (since this is just used
 
351
        to display throw_error error messages).
 
352
        """
 
353
        try:
 
354
            return http_codenames[code]
 
355
        except KeyError:
 
356
            return None, None
 
357
 
 
358
# Human strings for HTTP response codes
 
359
http_codenames = {
 
360
    Request.HTTP_BAD_REQUEST:
 
361
        ("Bad Request",
 
362
        "Your browser sent a request IVLE did not understand."),
 
363
    Request.HTTP_UNAUTHORIZED:
 
364
        ("Unauthorized",
 
365
        "You are not allowed to view this part of IVLE."),
 
366
    Request.HTTP_FORBIDDEN:
 
367
        ("Forbidden",
 
368
        "You are not allowed to view this part of IVLE."),
 
369
    Request.HTTP_NOT_FOUND:
 
370
        ("Not Found",
 
371
        "The application or file you requested does not exist."),
 
372
    Request.HTTP_METHOD_NOT_ALLOWED:
 
373
        ("Method Not Allowed",
 
374
        "Your browser is interacting with IVLE in the wrong way."
 
375
        "This is probably a bug in IVLE. "
 
376
        "Please report it to the administrators."),
 
377
    Request.HTTP_INTERNAL_SERVER_ERROR:
 
378
        ("Internal Server Error",
 
379
        "An unknown error occured in IVLE."),
 
380
    Request.HTTP_NOT_IMPLEMENTED:
 
381
        ("Not Implemented",
 
382
        "The application or file you requested has not been implemented "
 
383
        "in IVLE."),
 
384
    Request.HTTP_SERVICE_UNAVAILABLE:
 
385
        ("Service Unavailable",
 
386
        "IVLE is currently experiencing technical difficulties. "
 
387
        "Please try again later."),
 
388
}