← 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-06-16 07:14:51 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:775
browser.js: Updated logic to decide when to enable/disable certain actions.
    Serve and directory actions (inside the editor).
    Now Serve is correctly enabled within the editor.

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
158
165
        self.func_write_html_head = write_html_head
159
166
        self.headers_written = False
160
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
 
161
175
        # Inherit values for the input members
162
176
        self.method = req.method
163
177
        self.uri = req.uri
164
178
        # Split the given path into the app (top-level dir) and sub-path
165
179
        # (after first stripping away the root directory)
166
 
        (self.app, self.path) = (
167
 
            common.util.split_path(common.util.unmake_path(req.uri)))
168
 
        self.username = None
 
180
        path = common.util.unmake_path(req.uri)
 
181
        if self.publicmode:
 
182
            self.app = None
 
183
            (_, self.path) = (common.util.split_path(path))
 
184
        else:
 
185
            (self.app, self.path) = (common.util.split_path(path))
 
186
        self.user = None
 
187
        self.hostname = req.hostname
169
188
        self.headers_in = req.headers_in
170
189
        self.headers_out = req.headers_out
171
190
 
177
196
        self.styles = []
178
197
        self.scripts = []
179
198
        self.write_html_head_foot = False
 
199
        self.got_common_vars = False
180
200
 
181
201
    def __writeheaders(self):
182
202
        """Writes out the HTTP and HTML headers before any real data is
204
224
 
205
225
        if not self.headers_written:
206
226
            self.__writeheaders()
207
 
        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)
208
235
 
209
236
    def flush(self):
210
237
        """Flushes the output buffer."""
220
247
        """Reads at most len bytes directly from the client. (See mod_python
221
248
        Request.read)."""
222
249
        if len is None:
223
 
            self.apache_req.read()
 
250
            return self.apache_req.read()
224
251
        else:
225
 
            self.apache_req.read(len)
 
252
            return self.apache_req.read(len)
226
253
 
227
 
    def throw_error(self, httpcode):
 
254
    def throw_error(self, httpcode, message=None):
228
255
        """Writes out an HTTP error of the specified code. Raises an exception
229
256
        which is caught by the dispatch or web server, so any code following
230
257
        this call will not be executed.
232
259
        httpcode: An HTTP response status code. Pass a constant from the
233
260
        Request class.
234
261
        """
235
 
        raise mod_python.apache.SERVER_RETURN, httpcode
 
262
        raise common.util.IVLEError(httpcode, message)
236
263
 
237
264
    def throw_redirect(self, location):
238
265
        """Writes out an HTTP redirect to the specified URL. Raises an
244
271
        """
245
272
        mod_python.util.redirect(self.apache_req, location)
246
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
 
247
281
    def get_session(self):
248
282
        """Returns a mod_python Session object for this request.
249
283
        Note that this is dependent on mod_python and may need to change
250
284
        interface if porting away from mod_python."""
251
 
        # Cache the session object
 
285
        # Cache the session object and set the timeout to 24 hours.
252
286
        if not hasattr(self, 'session'):
253
 
            self.session = Session.Session(self.apache_req)
 
287
            self.session = Session.FileSession(self.apache_req,
 
288
                                               timeout = 60 * 60 * 24)
254
289
        return self.session
255
290
 
256
291
    def get_fieldstorage(self):
261
296
        if not hasattr(self, 'fields'):
262
297
            self.fields = util.FieldStorage(self.apache_req)
263
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
}