← 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: drtomc
  • Date: 2008-02-03 22:43:33 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:392
Fix another glitch.

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)
 
29
import conf
28
30
 
29
31
class Request:
30
32
    """An IVLE request object. This is presented to the IVLE apps as a way of
31
33
    interacting with the web server and the dispatcher.
32
34
 
33
35
    Request object attributes:
 
36
        method (read)
 
37
            String. The request method (eg. 'GET', 'POST', etc)
34
38
        uri (read)
35
39
            String. The path portion of the URI.
36
40
        app (read)
39
43
            String. The path specified in the URL *not including* the
40
44
            application or the IVLE location prefix. eg. a URL of
41
45
            "/ivle/files/joe/myfiles" has a path of "joe/myfiles".
 
46
        username (read)
 
47
            String. Login name of the user who is currently logged in, or
 
48
            None.
 
49
        hostname (read)
 
50
            String. Hostname the server is running on.
 
51
        headers_in (read)
 
52
            Table object representing headers sent by the client.
 
53
        headers_out (read, can be written to)
 
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).
42
59
 
43
60
        status (write)
44
61
            Int. Response status number. Use one of the status codes defined
51
68
        title (write)
52
69
            String. HTML page title. Used if write_html_head_foot is True, in
53
70
            the HTML title element text.
 
71
        styles (write)
 
72
            List of strings. Write a list of URLs to CSS files here, and they
 
73
            will be incorporated as <link rel="stylesheet" type="text/css">
 
74
            elements in the head, if write_html_head_foot is True.
 
75
            URLs should be relative to the IVLE root; they will be fixed up
 
76
            to be site-relative.
 
77
        scripts (write)
 
78
            List of strings. Write a list of URLs to JS files here, and they
 
79
            will be incorporated as <script type="text/javascript"> elements
 
80
            in the head, if write_html_head_foot is True.
 
81
            URLs should be relative to the IVLE root; they will be fixed up
 
82
            to be site-relative.
54
83
        write_html_head_foot (write)
55
84
            Boolean. If True, dispatch assumes that this is an XHTML page, and
56
85
            will immediately write a full HTML head, open the body element,
136
165
        self.func_write_html_head = write_html_head
137
166
        self.headers_written = False
138
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
 
139
175
        # Inherit values for the input members
 
176
        self.method = req.method
140
177
        self.uri = req.uri
141
178
        # Split the given path into the app (top-level dir) and sub-path
142
179
        # (after first stripping away the root directory)
143
 
        (self.app, self.path) = (
144
 
            common.util.split_path(common.util.unmake_path(req.uri)))
 
180
        path = common.util.unmake_path(req.uri)
 
181
        if self.publicmode:
 
182
            self.app = None
 
183
            self.path = path
 
184
        else:
 
185
            (self.app, self.path) = (common.util.split_path(path))
 
186
        self.username = None
 
187
        self.hostname = req.hostname
 
188
        self.headers_in = req.headers_in
 
189
        self.headers_out = req.headers_out
145
190
 
146
191
        # Default values for the output members
147
 
        self.status = Request.OK
 
192
        self.status = Request.HTTP_OK
148
193
        self.content_type = None        # Use Apache's default
149
194
        self.location = None
150
195
        self.title = None     # Will be set by dispatch before passing to app
 
196
        self.styles = []
 
197
        self.scripts = []
151
198
        self.write_html_head_foot = False
 
199
        self.got_common_vars = False
152
200
 
153
201
    def __writeheaders(self):
154
202
        """Writes out the HTTP and HTML headers before any real data is
176
224
 
177
225
        if not self.headers_written:
178
226
            self.__writeheaders()
179
 
        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)
180
235
 
181
236
    def flush(self):
182
237
        """Flushes the output buffer."""
192
247
        """Reads at most len bytes directly from the client. (See mod_python
193
248
        Request.read)."""
194
249
        if len is None:
195
 
            self.apache_req.read()
 
250
            return self.apache_req.read()
196
251
        else:
197
 
            self.apache_req.read(len)
 
252
            return self.apache_req.read(len)
198
253
 
199
254
    def throw_error(self, httpcode):
200
255
        """Writes out an HTTP error of the specified code. Raises an exception
215
270
        Request class.
216
271
        """
217
272
        mod_python.util.redirect(self.apache_req, location)
 
273
 
 
274
    def get_session(self):
 
275
        """Returns a mod_python Session object for this request.
 
276
        Note that this is dependent on mod_python and may need to change
 
277
        interface if porting away from mod_python."""
 
278
        # Cache the session object
 
279
        if not hasattr(self, 'session'):
 
280
            self.session = Session.Session(self.apache_req)
 
281
        return self.session
 
282
 
 
283
    def get_fieldstorage(self):
 
284
        """Returns a mod_python FieldStorage object for this request.
 
285
        Note that this is dependent on mod_python and may need to change
 
286
        interface if porting away from mod_python."""
 
287
        # Cache the fieldstorage object
 
288
        if not hasattr(self, 'fields'):
 
289
            self.fields = util.FieldStorage(self.apache_req)
 
290
        return self.fields
 
291
 
 
292
    def get_cgi_environ(self):
 
293
        """Returns the CGI environment emulation for this request. (Calls
 
294
        add_common_vars). The environment is returned as a mapping
 
295
        compatible with os.environ."""
 
296
        if not self.got_common_vars:
 
297
            self.apache_req.add_common_vars()
 
298
            self.got_common_vars = True
 
299
        return self.apache_req.subprocess_env