/usr/share/pyshared/paste/webkit/wkresponse.py is in python-pastewebkit 1.0-7build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 | """
A Webware HTTPResponse object.
"""
import time
from wkcommon import NoDefault, Cookie
from MiscUtils.DateInterval import timeDecode
import urlparse
from paste.request import resolve_relative_url
TimeTupleType = type(time.gmtime(0))
class HTTPResponse(object):
def __init__(self, transaction, environ, start_response):
self._transaction = transaction
self._environ = environ
self._start_response = start_response
self._writer = None
self._committed = False
self._autoFlush = False
self.reset()
def endTime(self):
return self._endTime
def recordEndTime(self):
"""
Stores the current time as the end time of the response. This
should be invoked at the end of deliver(). It may also be
invoked by the application for those responses that never
deliver due to an error."""
self._endTime = time.time()
## Headers ##
def header(self, name, default=NoDefault):
""" Returns the value of the specified header. """
if default is NoDefault:
return self._headers[name.lower()]
else:
return self._headers.get(name.lower(), default)
def hasHeader(self, name):
return self._headers.has_key(name.lower())
def setHeader(self, name, value):
"""
Sets a specific header by name.
"""
assert self._committed==0, "Headers have already been sent"
assert type(name) is str, (
"Header %r name is not string" % name)
assert type(value) is str, (
"Header %s value is not string (%r)" % (name, value))
self._headers[name.lower()] = value
def headers(self):
"""
Returns a dictionary-style object of all Header objects
contained by this request. """
return self._headers
def clearHeaders(self):
"""
Clears all the headers. You might consider a
setHeader('Content-type', 'text/html') or something similar
after this."""
assert self._committed==0
self._headers = {}
## Cookies ##
def cookie(self, name):
""" Returns the value of the specified cookie. """
return self._cookies[name]
def hasCookie(self, name):
"""
Returns true if the specified cookie is present.
"""
return self._cookies.has_key(name)
def setCookie(self, name, value, path='/', expires='ONCLOSE',
secure=False):
"""
Set a cookie. You can also set the path (which defaults to /),
You can also set when it expires. It can expire:
'NOW':
this is the same as trying to delete it, but it
doesn't really seem to work in IE
'ONCLOSE':
the default behavior for cookies (expires when
the browser closes)
'NEVER':
some time in the far, far future.
integer:
a timestamp value
tuple:
a tuple, as created by the time module
"""
cookie = Cookie(name, value)
if expires == 'ONCLOSE' or not expires:
pass # this is already default behavior
elif expires == 'NOW' or expires == 'NEVER':
t = time.gmtime(time.time())
if expires == 'NEVER':
t = (t[0] + 10,) + t[1:]
t = time.strftime("%a, %d-%b-%Y %H:%M:%S GMT", t)
cookie.setExpires(t)
else:
t = expires
if isinstance(t, (str, unicode)) and t.startswith('+'):
interval = timeDecode(t[1:])
t = time.time() + interval
if isinstance(t, (int, long, float)):
t = time.gmtime(t)
if isinstance(t, (tuple, TimeTupleType)):
t = time.strftime("%a, %d-%b-%Y %H:%M:%S GMT", t)
cookie.setExpires(t)
if path:
cookie.setPath(path)
if secure:
cookie.setSecure(secure)
self.addCookie(cookie)
def addCookie(self, cookie):
"""
Adds a cookie that will be sent with this response.
cookie is a Cookie object instance. See WebKit.Cookie.
"""
assert self._committed==0
assert isinstance(cookie, Cookie)
self._cookies[cookie.name()] = cookie
def delCookie(self, name):
"""
Deletes a cookie at the browser. To do so, one has
to create and send to the browser a cookie with
parameters that will cause the browser to delete it.
"""
if self._cookies.has_key(name):
self._cookies[name].delete()
else:
cookie = Cookie(name, None)
cookie.delete()
self.addCookie(cookie)
def cookies(self):
"""
Returns a dictionary-style object of all Cookie objects that will be sent
with this response.
"""
return self._cookies
def clearCookies(self):
""" Clears all the cookies. """
assert self._committed==0
self._cookies = {}
## Status ##
def setStatus(self, code, msg=''):
""" Set the status code of the response, such as 200, 'OK'. """
assert self._committed==0, "Headers already sent."
self.setHeader('Status', str(code) + ' ' + msg)
## Special responses ##
def sendError(self, code, msg=''):
"""
Sets the status code to the specified code and message.
"""
assert self._committed==0, "Response already partially sent"
self.setStatus(code, msg)
def sendRedirect(self, url):
"""
This method sets the headers and content for the redirect, but
does NOT change the cookies. Use clearCookies() as
appropriate.
@@ 2002-03-21 ce: I thought cookies were ignored by user
agents if a redirect occurred. We should verify and update
code or docs as appropriate.
"""
# ftp://ftp.isi.edu/in-notes/rfc2616.txt
# Sections: 10.3.3 and others
url = resolve_relative_url(
url, self._transaction.request().environ())
assert not self._committed, "Headers already sent"
self.setHeader('Status', '302 Redirect')
self.setHeader('Location', url)
self.setHeader('Content-type', 'text/html')
self.write('<html> <body> This page has been redirected to '
'<a href="%s">%s</a>. </body> </html>' % (url, url))
## Output ##
def write(self, charstr=None):
"""
Write charstr to the response stream.
"""
if not charstr:
return
if self._autoFlush:
assert self._committed
self._writer(charstr)
else:
self._output.append(charstr)
def flush(self, autoFlush=True):
"""
Send all accumulated response data now. Commits the response
headers and tells the underlying stream to flush. if
autoFlush is true, the responseStream will flush itself
automatically from now on.
"""
if not self._committed:
self.commit()
if self._output:
self._writer(''.join(self._output))
self._autoFlush = autoFlush
def isCommitted(self):
"""
Has the reponse already been partially or completely sent? If
this returns true, no new headers/cookies can be added to the
response.
"""
return self._committed
def deliver(self):
"""
The final step in the processing cycle.
Not used for much with responseStreams added.
"""
self.recordEndTime()
if not self._committed: self.commit()
def commit(self):
"""
Write out all headers to the reponse stream, and tell the
underlying response stream it can start sending data.
"""
status = self._headers['status']
del self._headers['status']
headers = self._headers.items()
for cookie in self._cookies.values():
headers.append(('Set-Cookie', cookie.headerValue()))
self._writer = self._start_response(status, headers)
self._committed = True
def wsgiIterator(self):
return self._output
def recordSession(self):
raise NotImplementedError
def reset(self):
"""
Resets the response (such as headers, cookies and contents).
"""
assert self._committed == 0
self._headers = {}
self.setHeader('Content-type','text/html')
self.setHeader('Status', '200 OK')
self._cookies = {}
self._output = []
def rawResponse(self):
raise NotImplementedError
def size(self):
raise NotImplementedError
def mergeTextHeaders(self, headerstr):
raise NotImplementedError
|