← 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-01-09 21:33:56 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:144
Trunk, and all subdirectories with Python files:
    Added to svn:ignore all *.pyc *.pyo, to avoid compiled files
    showing up in svn st / diff / commit lists.
    Added to svn:ignore trampoline/trampoline.

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, Cookie)
29
 
import conf
30
 
import plugins.console
 
28
from mod_python import (util, Session)
31
29
 
32
30
class Request:
33
31
    """An IVLE request object. This is presented to the IVLE apps as a way of
44
42
            String. The path specified in the URL *not including* the
45
43
            application or the IVLE location prefix. eg. a URL of
46
44
            "/ivle/files/joe/myfiles" has a path of "joe/myfiles".
47
 
        user (read)
48
 
            User object. Details of the user who is currently logged in, or
 
45
        username (read)
 
46
            String. Login name of the user who is currently logged in, or
49
47
            None.
50
 
        hostname (read)
51
 
            String. Hostname the server is running on.
52
48
        headers_in (read)
53
49
            Table object representing headers sent by the client.
54
50
        headers_out (read, can be written to)
55
51
            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).
60
52
 
61
53
        status (write)
62
54
            Int. Response status number. Use one of the status codes defined
69
61
        title (write)
70
62
            String. HTML page title. Used if write_html_head_foot is True, in
71
63
            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.
90
64
        write_html_head_foot (write)
91
65
            Boolean. If True, dispatch assumes that this is an XHTML page, and
92
66
            will immediately write a full HTML head, open the body element,
172
146
        self.func_write_html_head = write_html_head
173
147
        self.headers_written = False
174
148
 
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
 
 
182
149
        # Inherit values for the input members
183
150
        self.method = req.method
184
151
        self.uri = req.uri
185
152
        # Split the given path into the app (top-level dir) and sub-path
186
153
        # (after first stripping away the root directory)
187
 
        path = common.util.unmake_path(req.uri)
188
 
        if self.publicmode:
189
 
            self.app = None
190
 
            (_, self.path) = (common.util.split_path(path))
191
 
        else:
192
 
            (self.app, self.path) = (common.util.split_path(path))
193
 
        self.user = None
194
 
        self.hostname = req.hostname
 
154
        (self.app, self.path) = (
 
155
            common.util.split_path(common.util.unmake_path(req.uri)))
 
156
        self.username = None
195
157
        self.headers_in = req.headers_in
196
158
        self.headers_out = req.headers_out
197
159
 
198
160
        # Default values for the output members
199
 
        self.status = Request.HTTP_OK
 
161
        self.status = Request.OK
200
162
        self.content_type = None        # Use Apache's default
201
163
        self.location = None
202
164
        self.title = None     # Will be set by dispatch before passing to app
203
 
        self.styles = []
204
 
        self.scripts = []
205
 
        self.scripts_init = []
206
165
        self.write_html_head_foot = False
207
 
        self.got_common_vars = False
208
166
 
209
167
    def __writeheaders(self):
210
168
        """Writes out the HTTP and HTML headers before any real data is
211
169
        written."""
212
170
        self.headers_written = True
213
 
        
214
 
        # app is the App object for the chosen app
215
 
        try:
216
 
            app = conf.apps.app_url[self.app]
217
 
        except KeyError:
218
 
            app = None
219
 
 
220
 
        # Write any final modifications to header content
221
 
        if app and app.useconsole and self.user:
222
 
            plugins.console.insert_scripts_styles(self.scripts, self.styles, \
223
 
                self.scripts_init)
224
 
 
225
171
        # Prepare the HTTP and HTML headers before the first write is made
226
172
        if self.content_type != None:
227
173
            self.apache_req.content_type = self.content_type
244
190
 
245
191
        if not self.headers_written:
246
192
            self.__writeheaders()
247
 
        if isinstance(string, unicode):
248
 
            # Encode unicode strings as UTF-8
249
 
            # (Otherwise cannot handle being written to a bytestream)
250
 
            self.apache_req.write(string.encode('utf8'), flush)
251
 
        else:
252
 
            # 8-bit clean strings just get written directly.
253
 
            # This includes binary strings.
254
 
            self.apache_req.write(string, flush)
 
193
        self.apache_req.write(string, flush)
255
194
 
256
195
    def flush(self):
257
196
        """Flushes the output buffer."""
267
206
        """Reads at most len bytes directly from the client. (See mod_python
268
207
        Request.read)."""
269
208
        if len is None:
270
 
            return self.apache_req.read()
 
209
            self.apache_req.read()
271
210
        else:
272
 
            return self.apache_req.read(len)
 
211
            self.apache_req.read(len)
273
212
 
274
 
    def throw_error(self, httpcode, message=None):
 
213
    def throw_error(self, httpcode):
275
214
        """Writes out an HTTP error of the specified code. Raises an exception
276
215
        which is caught by the dispatch or web server, so any code following
277
216
        this call will not be executed.
279
218
        httpcode: An HTTP response status code. Pass a constant from the
280
219
        Request class.
281
220
        """
282
 
        raise common.util.IVLEError(httpcode, message)
 
221
        raise mod_python.apache.SERVER_RETURN, httpcode
283
222
 
284
223
    def throw_redirect(self, location):
285
224
        """Writes out an HTTP redirect to the specified URL. Raises an
291
230
        """
292
231
        mod_python.util.redirect(self.apache_req, location)
293
232
 
294
 
    def add_cookie(self, cookie, value=None, **attributes):
295
 
        """Inserts a cookie into this request object's headers."""
296
 
        if value is None:
297
 
            Cookie.add_cookie(self.apache_req, cookie)
298
 
        else:
299
 
            Cookie.add_cookie(self.apache_req, cookie, value, **attributes)
300
 
 
301
233
    def get_session(self):
302
234
        """Returns a mod_python Session object for this request.
303
235
        Note that this is dependent on mod_python and may need to change
304
236
        interface if porting away from mod_python."""
305
 
        # Cache the session object and set the timeout to 24 hours.
 
237
        # Cache the session object
306
238
        if not hasattr(self, 'session'):
307
 
            self.session = Session.FileSession(self.apache_req,
308
 
                                               timeout = 60 * 60 * 24)
 
239
            self.session = Session.Session(self.apache_req)
309
240
        return self.session
310
241
 
311
242
    def get_fieldstorage(self):
316
247
        if not hasattr(self, 'fields'):
317
248
            self.fields = util.FieldStorage(self.apache_req)
318
249
        return self.fields
319
 
 
320
 
    def get_cgi_environ(self):
321
 
        """Returns the CGI environment emulation for this request. (Calls
322
 
        add_common_vars). The environment is returned as a mapping
323
 
        compatible with os.environ."""
324
 
        if not self.got_common_vars:
325
 
            self.apache_req.add_common_vars()
326
 
            self.got_common_vars = True
327
 
        return self.apache_req.subprocess_env
328
 
 
329
 
    @staticmethod
330
 
    def get_http_codename(code):
331
 
        """Given a HTTP error code int, returns a (name, description)
332
 
        pair, suitable for displaying to the user.
333
 
        May return (None,None) if code is unknown.
334
 
        Only lists common 4xx and 5xx codes (since this is just used
335
 
        to display throw_error error messages).
336
 
        """
337
 
        try:
338
 
            return http_codenames[code]
339
 
        except KeyError:
340
 
            return None, None
341
 
 
342
 
# Human strings for HTTP response codes
343
 
http_codenames = {
344
 
    Request.HTTP_BAD_REQUEST:
345
 
        ("Bad Request",
346
 
        "Your browser sent a request IVLE did not understand."),
347
 
    Request.HTTP_UNAUTHORIZED:
348
 
        ("Unauthorized",
349
 
        "You are not allowed to view this part of IVLE."),
350
 
    Request.HTTP_FORBIDDEN:
351
 
        ("Forbidden",
352
 
        "You are not allowed to view this part of IVLE."),
353
 
    Request.HTTP_NOT_FOUND:
354
 
        ("Not Found",
355
 
        "The application or file you requested does not exist."),
356
 
    Request.HTTP_METHOD_NOT_ALLOWED:
357
 
        ("Method Not Allowed",
358
 
        "Your browser is interacting with IVLE in the wrong way."
359
 
        "This is probably a bug in IVLE. "
360
 
        "Please report it to the administrators."),
361
 
    Request.HTTP_INTERNAL_SERVER_ERROR:
362
 
        ("Internal Server Error",
363
 
        "An unknown error occured in IVLE."),
364
 
    Request.HTTP_NOT_IMPLEMENTED:
365
 
        ("Not Implemented",
366
 
        "The application or file you requested has not been implemented "
367
 
        "in IVLE."),
368
 
    Request.HTTP_SERVICE_UNAVAILABLE:
369
 
        ("Service Unavailable",
370
 
        "IVLE is currently experiencing technical difficulties. "
371
 
        "Please try again later."),
372
 
}