← 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: 2010-02-16 04:11:46 UTC
  • Revision ID: grantw@unimelb.edu.au-20100216041146-rvfbuwin7fncc0nw
https://launchpad.net/bugs/522025
Restrict privileges on group-related userservice actions to users with admin_groups on the offering.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/request.py
29
29
    import mod_python.Session
30
30
    import mod_python.Cookie
31
31
    import mod_python.util
32
 
    import mod_python.apache
33
 
 
34
 
    class PotentiallySecureFileSession(mod_python.Session.FileSession):
35
 
        """A mod_python FileSession that sets secure cookie when appropriate.
36
 
 
37
 
        A secure cookie will be set if the request itself is over HTTPS, or if
38
 
        a proxy in front has set X-Forwarded-Proto: https. Otherwise the cookie
39
 
        will be insecure.
40
 
        """
41
 
        def make_cookie(self):
42
 
            cookie = super(PotentiallySecureFileSession, self).make_cookie()
43
 
            if (self._req.is_https() or
44
 
                self._req.headers_in.get('X-Forwarded-Proto') == 'https'):
45
 
                cookie.secure = True
46
 
            return cookie
47
32
except ImportError:
48
33
    # This needs to be importable from outside Apache.
49
34
    pass
53
38
import ivle.util
54
39
import ivle.database
55
40
from ivle.webapp.base.plugins import CookiePlugin
56
 
import ivle.webapp.security
57
 
 
58
41
 
59
42
class Request:
60
43
    """An IVLE request object. This is presented to the IVLE apps as a way of
65
48
            String. The request method (eg. 'GET', 'POST', etc)
66
49
        uri (read)
67
50
            String. The path portion of the URI.
68
 
        unparsed_uri (read)
69
 
            String. The path portion of the URI, unparsed with query string.
70
51
        app (read)
71
52
            String. Name of the application specified in the URL, or None.
72
53
        path (read)
95
76
            in class Request.
96
77
        content_type (write)
97
78
            String. The Content-Type (mime type) header value.
98
 
        content_length (write)
99
 
            Integer. The number of octets to be transfered.
100
79
        location (write)
101
80
            String. Response "Location" header value. Used with HTTP redirect
102
81
            responses.
115
94
    HTTP_NOT_FOUND                    = 404
116
95
    HTTP_INTERNAL_SERVER_ERROR        = 500
117
96
 
118
 
    _store = None
119
 
 
120
97
    def __init__(self, req, config):
121
98
        """Create an IVLE request from a mod_python one.
122
99
 
139
116
        # Inherit values for the input members
140
117
        self.method = req.method
141
118
        self.uri = req.uri
142
 
        self.unparsed_uri = req.unparsed_uri
143
119
        # Split the given path into the app (top-level dir) and sub-path
144
120
        # (after first stripping away the root directory)
145
121
        (self.app, self.path) = (ivle.util.split_path(req.uri))
 
122
        self.user = None
146
123
        self.hostname = req.hostname
147
124
        self.headers_in = req.headers_in
148
125
        self.headers_out = req.headers_out
149
126
 
 
127
        # Open a database connection and transaction, keep it around for users
 
128
        # of the Request object to use
 
129
        self.store = ivle.database.get_store(config)
 
130
 
150
131
        # Default values for the output members
151
132
        self.status = Request.HTTP_OK
152
133
        self.content_type = None        # Use Apache's default
153
 
        self.content_length = None        # Don't provide Content-Length
154
134
        self.location = None
155
135
        # In some cases we don't want the template JS (such as the username
156
136
        # and public FQDN) in the output HTML. In that case, set this to 0.
158
138
        self.got_common_vars = False
159
139
 
160
140
    def __del__(self):
161
 
        self.cleanup()
162
 
 
163
 
    def cleanup(self):
164
 
        """Cleanup."""
165
 
        if self._store is not None:
166
 
            self._store.close()
167
 
            self._store = None
168
 
 
169
 
    def commit(self):
170
 
        """Cleanup."""
171
 
        if self._store is not None:
172
 
            self._store.commit()
 
141
        """Cleanup."""
 
142
        self.store.close()
173
143
 
174
144
    def __writeheaders(self):
175
145
        """Writes out the HTTP and HTML headers before any real data is
179
149
        # Prepare the HTTP and HTML headers before the first write is made
180
150
        if self.content_type != None:
181
151
            self.apache_req.content_type = self.content_type
182
 
        if self.content_length:
183
 
            self.apache_req.set_content_length(self.content_length)
184
152
        self.apache_req.status = self.status
185
153
        if self.location != None:
186
154
            self.apache_req.headers_out['Location'] = self.location
279
247
        """
280
248
        # Cache the session object and set the timeout to 24 hours.
281
249
        if not hasattr(self, 'session'):
282
 
            self.session = PotentiallySecureFileSession(
283
 
                self.apache_req, timeout = 60 * 60 * 24)
 
250
            self.session = mod_python.Session.FileSession(self.apache_req,
 
251
                                               timeout = 60 * 60 * 24)
284
252
        return self.session
285
253
 
286
254
    def get_fieldstorage(self):
301
269
            self.got_common_vars = True
302
270
        return self.apache_req.subprocess_env
303
271
 
304
 
    @property
305
 
    def store(self):
306
 
        # Open a database connection and transaction, keep it around for users
307
 
        # of the Request object to use.
308
 
        if self._store is None:
309
 
            self._store = ivle.database.get_store(self.config)
310
 
        return self._store
311
 
 
312
 
    @property
313
 
    def user(self):
314
 
        # Get and cache the request user, or None if it's not valid.
315
 
        # This is a property so that we don't create a store unless
316
 
        # some code actually requests the user.
317
 
        try:
318
 
            return self._user
319
 
        except AttributeError:
320
 
            if self.publicmode:
321
 
                self._user = None
322
 
            else:
323
 
                temp_user = ivle.webapp.security.get_user_details(self)
324
 
                if temp_user and temp_user.valid:
325
 
                    self._user = temp_user
326
 
                else:
327
 
                    self._user = None
328
 
            return self._user
329