"
"\n%s\n%s\n%s" % (_tbopen, body[1:-1], _tbclose))
if(title):
self.body=('\n
\n]+>\)',
regex.casefold).search
):
if (self.headers.has_key('content-type') and
self.headers['content-type']!='text/html'): return
if self.base:
body=self.body
if body:
e=end_of_header_search(body)
if e >= 0:
b=base_re_search(body)
if b < 0:
self.body=('%s\t\n%s' %
(body[:e],self.base,body[e:]))
def appendCookie(self, name, value):
'''\
Returns an HTTP header that sets a cookie on cookie-enabled
browsers with a key "name" and value "value". If a value for the
cookie has previously been set in the response object, the new
value is appended to the old one separated by a colon. '''
cookies=self.cookies
if cookies.has_key(name): cookie=cookies[name]
else: cookie=cookies[name]={}
if cookie.has_key('value'):
cookie['value']='%s:%s' % (cookie['value'], value)
else: cookie['value']=value
def expireCookie(self, name, **kw):
'''\
Cause an HTTP cookie to be removed from the browser
The response will include an HTTP header that will remove the cookie
corresponding to "name" on the client, if one exists. This is
accomplished by sending a new cookie with an expiration date
that has already passed. Note that some clients require a path
to be specified - this path must exactly match the path given
when creating the cookie. The path can be specified as a keyword
argument.
'''
dict={'max_age':0, 'expires':'Wed, 31-Dec-97 23:59:59 GMT'}
for k, v in kw.items():
dict[k]=v
apply(Response.setCookie, (self, name, 'deleted'), dict)
def setCookie(self,name,value,**kw):
'''\
Set an HTTP cookie on the browser
The response will include an HTTP header that sets a cookie on
cookie-enabled browsers with a key "name" and value
"value". This overwrites any previously set value for the
cookie in the Response object.
'''
cookies=self.cookies
if cookies.has_key(name):
cookie=cookies[name]
else: cookie=cookies[name]={}
for k, v in kw.items():
cookie[k]=v
cookie['value']=value
def appendBody(self, body):
self.setBody(self.getBody() + body)
def getHeader(self, name):
'''\
Get a header value
Returns the value associated with a HTTP return header, or
"None" if no such header has been set in the response
yet. '''
headers=self.headers
if headers.has_key(name): return headers[name]
def __getitem__(self, name):
'Get the value of an output header'
return self.headers[name]
def getBody(self):
'Returns a string representing the currently set body. '
return self.body
def appendHeader(self, name, value, delimiter=","):
'''\
Append a value to a cookie
Sets an HTTP return header "name" with value "value",
appending it following a comma if there was a previous value
set for the header. '''
headers=self.headers
if headers.has_key(name):
h=self.header[name]
h="%s%s\n\t%s" % (h,delimiter,value)
else: h=value
self.setHeader(name,h)
def isHTML(self,str):
return lower(strip(str)[:6]) == '' or find(str,' 0
def quoteHTML(self,text,
subs={'&':'&', "<":'<', ">":'>', '\"':'"'}
):
for ent in '&<>\"':
if find(text, ent) >= 0:
text=join(split(text,ent),subs[ent])
return text
def format_exception(self,etype,value,tb,limit=None):
import traceback
result=['Traceback (innermost last):']
if limit is None:
if hasattr(sys, 'tracebacklimit'):
limit = sys.tracebacklimit
n = 0
while tb is not None and (limit is None or n < limit):
f = tb.tb_frame
lineno = tb.tb_lineno
co = f.f_code
filename = co.co_filename
name = co.co_name
locals=f.f_locals
result.append(' File %s, line %d, in %s'
% (filename,lineno,name))
try: result.append(' (Object: %s)' %
locals[co.co_varnames[0]].__name__)
except: pass
try: result.append(' (Info: %s)' %
str(locals['__traceback_info__']))
except: pass
tb = tb.tb_next
n = n+1
result.append(join(traceback.format_exception_only(etype, value),
' '))
return result
def _traceback(self,t,v,tb):
tb=self.format_exception(t,v,tb,200)
tb=join(tb,'\n')
tb=self.quoteHTML(tb)
return "\n%s\n%s\n%s" % (_tbopen, tb, _tbclose)
def redirect(self, location):
"""Cause a redirection without raising an error"""
self.status=302
headers=self.headers
headers['status']='302 Moved Temporarily'
headers['location']=location
return location
def exception(self, fatal=0, info=None,
absuri_match=regex.compile(
"^"
"\(/\|\([a-zA-Z0-9+.-]+:\)\)"
"[^\000- \"\\#<>]*"
"\\(#[^\000- \"\\#<>]*\\)?"
"$"
).match,
tag_search=regex.compile('[a-zA-Z]>').search,
):
if type(info) is type(()) and len(info)==3: t,v,tb = info
elif hasattr(sys, 'exc_info'): t,v,tb = sys.exc_info()
else: t,v,tb = sys.exc_type, sys.exc_value, sys.exc_traceback
stb=tb
# Abort running transaction, if any:
try: get_transaction().abort()
except: pass
try:
# Try to capture exception info for bci calls
et=translate(str(t),nl2sp)
ev=translate(str(v),nl2sp)
# Get the tb tail, which is the interesting part:
while tb.tb_next is not None: tb=tb.tb_next
el=str(tb.tb_lineno)
ef=str(tb.tb_frame.f_code.co_filename)
if find(ev,'') >= 0: ev='bobo exception'
self.setHeader('bobo-exception-type',et)
self.setHeader('bobo-exception-value',ev[:255])
self.setHeader('bobo-exception-file',ef)
self.setHeader('bobo-exception-line',el)
except:
# Dont try so hard that we cause other problems ;)
pass
tb=stb
stb=None
self.setStatus(t)
if self.status >= 300 and self.status < 400:
if type(v) == types.StringType and absuri_match(v) >= 0:
if self.status==300: self.setStatus(302)
self.setHeader('location', v)
tb=None
return self
else:
try:
l,b=v
if type(l) == types.StringType and absuri_match(l) >= 0:
if self.status==300: self.setStatus(302)
self.setHeader('location', l)
self.setBody(b)
tb=None
return self
except: pass
b=v
if fatal:
if t is SystemExit and v==0:
tb=self.setBody(
(str(t),
'This application has exited normally.'
+ self._traceback(t,v,tb)))
else:
tb=self.setBody(
(str(t),
'Sorry, a SERIOUS APPLICATION ERROR occurred.
'
+ self._traceback(t,v,tb)))
elif type(b) is not types.StringType or tag_search(b) < 0:
tb=self.setBody(
(str(t),
'Sorry, an error occurred.
'
+ self._traceback(t,v,tb)))
elif self.isHTML(b):
tb=self.setBody(b+self._traceback(t,'(see above)',tb))
else:
tb=self.setBody((str(t),b+self._traceback(t,'(see above)',tb)))
return tb
_wrote=None
def _cookie_list(self):
cookie_list=[]
for name, attrs in self.cookies.items():
# Note that as of May 98, IE4 ignores cookies with
# quoted cookie attr values, so only the value part
# of name=value pairs may be quoted.
cookie='Set-Cookie: %s="%s"' % (name, attrs['value'])
for name, v in attrs.items():
name=lower(name)
if name=='expires': cookie = '%s; Expires=%s' % (cookie,v)
elif name=='domain': cookie = '%s; Domain=%s' % (cookie,v)
elif name=='path': cookie = '%s; Path=%s' % (cookie,v)
elif name=='max_age': cookie = '%s; Max-Age=%s' % (cookie,v)
elif name=='comment': cookie = '%s; Comment=%s' % (cookie,v)
elif name=='secure': cookie = '%s; Secure' % cookie
cookie_list.append(cookie)
# Should really check size of cookies here!
return cookie_list
def __str__(self,
html_search=regex.compile('',regex.casefold).search,
):
if self._wrote: return '' # Streaming output was used.
headers=self.headers
body=self.body
if body:
isHTML=self.isHTML(body)
if not headers.has_key('content-type'):
if isHTML:
c='text/html'
else:
c='text/plain'
self.setHeader('content-type',c)
else:
isHTML = headers['content-type']=='text/html'
if isHTML and end_of_header_search(self.body) < 0:
lhtml=html_search(body)
if lhtml >= 0:
lhtml=lhtml+6
body='%s
\n%s' % (body[:lhtml],body[lhtml:])
else:
body='\n' + body
self.setBody(body)
body=self.body
if not headers.has_key('content-length'):
self.setHeader('content-length',len(body))
if not headers.has_key('content-type') and self.status == 200:
self.setStatus('nocontent')
headersl=[]
append=headersl.append
for k,v in headers.items():
k=upper(k[:1])+k[1:]
start=0
l=find(k,'-',start)
while l >= start:
k="%s-%s%s" % (k[:l],upper(k[l+1:l+2]),k[l+2:])
start=l+1
l=find(k,'-',start)
append("%s: %s" % (k,v))
if self.cookies:
headersl=headersl+self._cookie_list()
headersl[len(headersl):]=[self.accumulated_headers,body]
return join(headersl,'\n')
def __repr__(self):
return 'CGIResponse(%s)' % `self.body`
def flush(self): pass
def write(self,data):
"""\
Return data as a stream
HTML data may be returned using a stream-oriented interface.
This allows the browser to display partial results while
computation of a response to proceed.
The published object should first set any output headers or
cookies on the response object.
Note that published objects must not generate any errors
after beginning stream-oriented output.
"""
self.body=self.body+data
if end_of_header_search(self.body) >= 0:
headers=self.headers
if headers.has_key('content-length'):
del headers['content-length']
if not self.headers.has_key('content-type'):
self.setHeader('content-type', 'text/html')
self.insertBase()
body=self.body
self.body=''
self.write=write=self.stdout.write
try: self.flush=self.stdout.flush
except: pass
write(str(self))
self._wrote=1
write('\n\n')
write(body)