← 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: 2007-12-20 03:16:43 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:94
Removed console and www/bin.

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
30
28
 
31
29
class Request:
32
30
    """An IVLE request object. This is presented to the IVLE apps as a way of
33
31
    interacting with the web server and the dispatcher.
34
32
 
35
33
    Request object attributes:
36
 
        method (read)
37
 
            String. The request method (eg. 'GET', 'POST', etc)
38
34
        uri (read)
39
35
            String. The path portion of the URI.
40
36
        app (read)
43
39
            String. The path specified in the URL *not including* the
44
40
            application or the IVLE location prefix. eg. a URL of
45
41
            "/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).
59
42
 
60
43
        status (write)
61
44
            Int. Response status number. Use one of the status codes defined
68
51
        title (write)
69
52
            String. HTML page title. Used if write_html_head_foot is True, in
70
53
            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.
83
54
        write_html_head_foot (write)
84
55
            Boolean. If True, dispatch assumes that this is an XHTML page, and
85
56
            will immediately write a full HTML head, open the body element,
165
136
        self.func_write_html_head = write_html_head
166
137
        self.headers_written = False
167
138
 
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
 
 
175
139
        # Inherit values for the input members
176
 
        self.method = req.method
177
140
        self.uri = req.uri
178
141
        # Split the given path into the app (top-level dir) and sub-path
179
142
        # (after first stripping away the root directory)
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
 
143
        (self.app, self.path) = (
 
144
            common.util.split_path(common.util.unmake_path(req.uri)))
190
145
 
191
146
        # Default values for the output members
192
 
        self.status = Request.HTTP_OK
 
147
        self.status = Request.OK
193
148
        self.content_type = None        # Use Apache's default
194
149
        self.location = None
195
150
        self.title = None     # Will be set by dispatch before passing to app
196
 
        self.styles = []
197
 
        self.scripts = []
198
151
        self.write_html_head_foot = False
199
 
        self.got_common_vars = False
200
152
 
201
153
    def __writeheaders(self):
202
154
        """Writes out the HTTP and HTML headers before any real data is
224
176
 
225
177
        if not self.headers_written:
226
178
            self.__writeheaders()
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)
 
179
        self.apache_req.write(string, flush)
235
180
 
236
181
    def flush(self):
237
182
        """Flushes the output buffer."""
247
192
        """Reads at most len bytes directly from the client. (See mod_python
248
193
        Request.read)."""
249
194
        if len is None:
250
 
            return self.apache_req.read()
 
195
            self.apache_req.read()
251
196
        else:
252
 
            return self.apache_req.read(len)
 
197
            self.apache_req.read(len)
253
198
 
254
199
    def throw_error(self, httpcode):
255
200
        """Writes out an HTTP error of the specified code. Raises an exception
270
215
        Request class.
271
216
        """
272
217
        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.FileSession(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