def addToCache(self, id, data):
"""
Over-writes the cached dict for key id with the data dict.
This is a helper method--call this to add data to the cache.
Do not override it.
@param id: a unique key for the information you're storing
@type id: string
@param data: the data to store--this should probably be a dict
@type data: dict
"""
cache = tools.get_cache()
cache[id] = data
def addToCache(self, id, data):
"""
Over-writes the cached dict for key id with the data dict.
This is a helper method--call this to add data to the cache.
Do not override it.
@param id: a unique key for the information you're storing
@type id: string
@param data: the data to store--this should probably be a dict
@type data: dict
"""
mycache = tools.get_cache(self._request)
if mycache:
mycache[id] = data
def add_to_cache(self, entryid, data):
"""
Over-writes the cached dict for key entryid with the data
dict.
This is a helper method--call this to add data to the cache.
Do not override it.
:param entryid: a unique key for the information you're
storing
:param data: the data to store--this should probably be a dict
"""
mycache = tools.get_cache(self._request)
if mycache:
mycache[entryid] = data
def render(self, header = 1):
"""
Figures out flavours and such and then renders the content according
to which flavour we're using.
@param header: whether (1) or not (0) to render the HTTP headers
@type header: boolean
"""
data = self._request.getData()
config = self._request.getConfiguration()
parsevars = {}
for mem in config.keys():
parsevars[mem] = config[mem]
for mem in data.keys():
parsevars[mem] = data[mem]
self.flavour = self._getFlavour(data.get('flavour', 'html'))
data['content-type'] = self.flavour['content_type'].strip()
if header:
if self._needs_content_type and data['content-type'] !="":
self.addHeader('Content-type', '%(content-type)s' % data)
self.showHeaders()
if self._content:
if self.flavour.has_key('head'):
self._outputFlavour(parsevars,'head')
if self.flavour.has_key('story'):
self._processContent()
if self.flavour.has_key('date_foot'):
self._outputFlavour(parsevars,'date_foot')
if self.flavour.has_key('foot'):
self._outputFlavour(parsevars,'foot')
self.rendered = 1
# FIXME - we might want to do this at a later point?
cache = tools.get_cache(self._request)
if cache:
cache.close()
def render(self, header=1):
"""
Figures out flavours and such and then renders the content according
to which flavour we're using.
@param header: whether (1) or not (0) to render the HTTP headers
@type header: boolean
"""
data = self._request.getData()
config = self._request.getConfiguration()
parsevars = {}
for mem in config.keys():
parsevars[mem] = config[mem]
for mem in data.keys():
parsevars[mem] = data[mem]
self.flavour = self._getFlavour(data.get('flavour', 'html'))
data['content-type'] = self.flavour['content_type'].strip()
if header:
if self._needs_content_type and data['content-type'] != "":
self.addHeader('Content-type', '%(content-type)s' % data)
self.showHeaders()
if self._content:
if self.flavour.has_key('head'):
self._outputFlavour(parsevars, 'head')
if self.flavour.has_key('story'):
self._processContent()
if self.flavour.has_key('date_foot'):
self._outputFlavour(parsevars, 'date_foot')
if self.flavour.has_key('foot'):
self._outputFlavour(parsevars, 'foot')
self.rendered = 1
# FIXME - we might want to do this at a later point?
cache = tools.get_cache(self._request)
if cache:
cache.close()
def get_from_cache(self, entryid):
"""
Retrieves information from the cache that pertains to this
specific entryid.
This is a helper method--call this to get data from the cache.
Do not override it.
:param entryid: a unique key for the information you're retrieving
:returns: dict with the values or None if there's nothing for that
entryid
"""
cache = tools.get_cache(self._request)
# cache.__getitem__ returns None if the id isn't there
if cache.has_key(entryid):
return cache[entryid]
return None
def get_from_cache(self, entryid):
"""
Retrieves information from the cache that pertains to this
specific entryid.
This is a helper method--call this to get data from the cache.
Do not override it.
:param entryid: a unique key for the information you're retrieving
:returns: dict with the values or None if there's nothing for that
entryid
"""
cache = tools.get_cache(self._request)
# cache.__getitem__ returns None if the id isn't there
if cache.has_key(entryid):
return cache[entryid]
return None
def getFromCache(self, id):
"""
Retrieves information from the cache that pertains to this
specific id.
This is a helper method--call this to get data from the cache.
Do not override it.
@param id: a unique key for the information you're retrieving
@type id: string
@returns: dict with the values or None if there's nothing for that
id
@rtype: dict or None
"""
cache = tools.get_cache()
# cache.__getitem__ returns None if the id isn't there
if cache.has_key(id):
return cache[id]
else:
return None
def getFromCache(self, id):
"""
Retrieves information from the cache that pertains to this
specific id.
This is a helper method--call this to get data from the cache.
Do not override it.
@param id: a unique key for the information you're retrieving
@type id: string
@returns: dict with the values or None if there's nothing for that
id
@rtype: dict or None
"""
cache = tools.get_cache(self._request)
# cache.__getitem__ returns None if the id isn't there
if cache.has_key(id):
return cache[id]
return None
def add_to_cache(self, entryid, data):
"""
Over-writes the cached dict for key entryid with the data
dict.
This is a helper method--call this to add data to the cache.
Do not override it.
:param entryid: a unique key for the information you're
storing
:param data: the data to store--this should probably be a dict
"""
mycache = tools.get_cache(self._request)
if mycache:
# This could be extended to cover all keys used by
# set_time(), but this is the key most likely to turn
# up in metadata. If #date is not blocked from caching
# here, the templates will use the raw string value
# from the user metadata, rather than the value
# derived from mtime.
if data.has_key('date'):
data.pop('date')
mycache[entryid] = data
def add_to_cache(self, entryid, data):
"""
Over-writes the cached dict for key entryid with the data
dict.
This is a helper method--call this to add data to the cache.
Do not override it.
:param entryid: a unique key for the information you're
storing
:param data: the data to store--this should probably be a dict
"""
mycache = tools.get_cache(self._request)
if mycache:
# This could be extended to cover all keys used by
# set_time(), but this is the key most likely to turn
# up in metadata. If #date is not blocked from caching
# here, the templates will use the raw string value
# from the user metadata, rather than the value
# derived from mtime.
if data.has_key('date'):
data.pop('date')
mycache[entryid] = data
def blosxom_handler(request):
"""This is the default blosxom handler.
It calls the renderer callback to get a renderer. If there is no
renderer, it uses the blosxom renderer.
It calls the pathinfo callback to process the path_info http
variable.
It calls the filelist callback to build a list of entries to
display.
It calls the prepare callback to do any additional preparation
before rendering the entries.
Then it tells the renderer to render the entries.
:param request: the request object.
"""
config = request.get_configuration()
data = request.get_data()
# go through the renderer callback to see if anyone else wants to
# render. this renderer gets stored in the data dict for
# downstream processing.
rend = tools.run_callback('renderer', {'request': request},
donefunc=lambda x: x is not None,
defaultfunc=lambda x: None)
if not rend:
# get the renderer we want to use
rend = config.get("renderer", "blosxom")
# import the renderer
rend = tools.importname("Pyblosxom.renderers", rend)
# get the renderer object
rend = rend.Renderer(request, config.get("stdoutput", sys.stdout))
data['renderer'] = rend
# generate the timezone variable
data["timezone"] = time.tzname[time.localtime()[8]]
# process the path info to determine what kind of blog entry(ies)
# this is
tools.run_callback("pathinfo", {"request": request},
donefunc=lambda x: x is not None,
defaultfunc=blosxom_process_path_info)
# call the filelist callback to generate a list of entries
data["entry_list"] = tools.run_callback(
"filelist", {"request": request},
donefunc=lambda x: x is not None,
defaultfunc=blosxom_file_list_handler)
# figure out the blog-level mtime which is the mtime of the head
# of the entry_list
entry_list = data["entry_list"]
if isinstance(entry_list, list) and len(entry_list) > 0:
mtime = entry_list[0].get("mtime", time.time())
else:
mtime = time.time()
mtime_tuple = time.localtime(mtime)
mtime_gmtuple = time.gmtime(mtime)
data["latest_date"] = time.strftime('%a, %d %b %Y', mtime_tuple)
# Make sure we get proper 'English' dates when using standards
loc = locale.getlocale(locale.LC_ALL)
locale.setlocale(locale.LC_ALL, 'C')
data["latest_w3cdate"] = time.strftime('%Y-%m-%dT%H:%M:%SZ', mtime_gmtuple)
data['latest_rfc822date'] = time.strftime('%a, %d %b %Y %H:%M GMT',
mtime_gmtuple)
# set the locale back
locale.setlocale(locale.LC_ALL, loc)
# we pass the request with the entry_list through the prepare
# callback giving everyone a chance to transform the data. the
# request is modified in place.
tools.run_callback("prepare", {"request": request})
# now we pass the entry_list through the renderer
entry_list = data["entry_list"]
renderer = data['renderer']
if renderer and not renderer.rendered:
if entry_list:
renderer.set_content(entry_list)
# Log it as success
tools.run_callback(
"logrequest", {
'filename': config.get('logfile', ''),
'return_code': '200',
'request': request
})
else:
renderer.add_header('Status', '404 Not Found')
renderer.set_content({
'title':
'The page you are looking for is not available',
'body':
'Somehow I cannot find the page you want. ' +
'Go Back to <a href="%s">%s</a>?' %
(config["base_url"], config["blog_title"])
})
# Log it as failure
tools.run_callback(
"logrequest", {
'filename': config.get('logfile', ''),
'return_code': '404',
'request': request
})
renderer.render()
elif not renderer:
output = config.get('stdoutput', sys.stdout)
output.write("Content-Type: text/plain\n\n" +
"There is something wrong with your setup.\n" +
"Check your config files and verify that your " +
"configuration is correct.\n")
cache = tools.get_cache(request)
if cache:
cache.close()
def render(self, header=1):
"""
Renders a PyBlosxom request after we've gone through all the
motions of converting data and getting entries to render.
@param header: either prints (1) or does not print (0) the http
headers.
@type header: boolean
"""
pyhttp = self._request.getHttp()
config = self._request.getConfiguration()
data = self._request.getData()
printout = self.write
hbar = "------------------------------------------------------\n"
if header:
self.addHeader('Content-type', 'text/html')
self.showHeaders()
printout("<html>")
printout("<body>")
printout("<pre>")
printout("Welcome to debug mode!\n")
printout("You requested the %(flavour)s flavour.\n" % data)
printout(hbar)
printout("The HTTP Return codes are:\n")
printout(hbar)
for k, v in self._header:
printout("<font color=\"#0000ff\">%s</font> -> %s\n" % \
(escv(k), escv(v)))
printout(hbar)
printout("The OS environment contains:\n")
printout(hbar)
import os
print_map(printout, os.environ)
printout(hbar)
printout("Request.getHttp() dict contains:\n")
printout(hbar)
print_map(printout, pyhttp)
printout(hbar)
printout("Request.getConfiguration() dict contains:\n")
printout(hbar)
print_map(printout, config)
printout(hbar)
printout("Request.getData() dict contains:\n")
printout(hbar)
print_map(printout, data)
printout(hbar)
printout("Entries to process:\n")
printout(hbar)
for content in self._content:
if not isinstance(content, str):
printout("%s\n" %
escv(content.get('filename', 'No such file\n')))
printout(hbar)
printout("Entries processed:\n")
printout(hbar)
for content in self._content:
if not isinstance(content, str):
printout(hbar)
emsg = escv(content.get('filename', 'No such file\n'))
printout("Items for %s:\n" % emsg)
printout(hbar)
print_map(printout, content)
printout(hbar)
if not config.has_key("cacheDriver"):
printout("No cache driver configured.")
else:
printout("Cached Titles:\n")
printout(hbar)
cache = tools.get_cache(self._request)
for content in self._content:
if not isinstance(content, str):
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % escv(cache[filename]['title']))
cache.close()
printout(hbar)
printout("Cached Entry Bodies:\n")
printout(hbar)
for content in self._content:
if not isinstance(content, str):
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % escv(cache[filename]['title']))
printout(hbar.replace("-", "="))
printout("%s\n" % escv(cache[filename]['body']))
else:
printout("Contents of %s is not cached\n" % \
escv(filename))
cache.close()
printout(hbar)
printout("</body>")
printout("</html>")
def blosxom_handler(request):
"""This is the default blosxom handler.
It calls the renderer callback to get a renderer. If there is no
renderer, it uses the blosxom renderer.
It calls the pathinfo callback to process the path_info http
variable.
It calls the filelist callback to build a list of entries to
display.
It calls the prepare callback to do any additional preparation
before rendering the entries.
Then it tells the renderer to render the entries.
:param request: the request object.
"""
config = request.get_configuration()
data = request.get_data()
# go through the renderer callback to see if anyone else wants to
# render. this renderer gets stored in the data dict for
# downstream processing.
rend = tools.run_callback('renderer',
{'request': request},
donefunc = lambda x: x != None,
defaultfunc = lambda x: None)
if not rend:
# get the renderer we want to use
rend = config.get("renderer", "blosxom")
# import the renderer
rend = tools.importname("Pyblosxom.renderers", rend)
# get the renderer object
rend = rend.Renderer(request, config.get("stdoutput", sys.stdout))
data['renderer'] = rend
# generate the timezone variable
data["timezone"] = time.tzname[time.localtime()[8]]
# process the path info to determine what kind of blog entry(ies)
# this is
tools.run_callback("pathinfo",
{"request": request},
donefunc=lambda x:x != None,
defaultfunc=blosxom_process_path_info)
# call the filelist callback to generate a list of entries
data["entry_list"] = tools.run_callback(
"filelist",
{"request": request},
donefunc=lambda x:x != None,
defaultfunc=blosxom_file_list_handler)
# figure out the blog-level mtime which is the mtime of the head
# of the entry_list
entry_list = data["entry_list"]
if isinstance(entry_list, list) and len(entry_list) > 0:
mtime = entry_list[0].get("mtime", time.time())
else:
mtime = time.time()
mtime_tuple = time.localtime(mtime)
mtime_gmtuple = time.gmtime(mtime)
data["latest_date"] = time.strftime('%a, %d %b %Y', mtime_tuple)
# Make sure we get proper 'English' dates when using standards
loc = locale.getlocale(locale.LC_ALL)
locale.setlocale(locale.LC_ALL, 'C')
data["latest_w3cdate"] = time.strftime('%Y-%m-%dT%H:%M:%SZ',
mtime_gmtuple)
data['latest_rfc822date'] = time.strftime('%a, %d %b %Y %H:%M GMT',
mtime_gmtuple)
# set the locale back
locale.setlocale(locale.LC_ALL, loc)
# we pass the request with the entry_list through the prepare
# callback giving everyone a chance to transform the data. the
# request is modified in place.
tools.run_callback("prepare", {"request": request})
# now we pass the entry_list through the renderer
entry_list = data["entry_list"]
renderer = data['renderer']
if renderer and not renderer.rendered:
if entry_list:
renderer.set_content(entry_list)
# Log it as success
tools.run_callback("logrequest",
{'filename':config.get('logfile',''),
'return_code': '200',
'request': request})
else:
renderer.add_header('Status', '404 Not Found')
renderer.set_content(
{'title': 'The page you are looking for is not available',
'body': 'Somehow I cannot find the page you want. ' +
'Go Back to <a href="%s">%s</a>?'
% (config["base_url"], config["blog_title"])})
# Log it as failure
tools.run_callback("logrequest",
{'filename':config.get('logfile',''),
'return_code': '404',
'request': request})
renderer.render()
elif not renderer:
output = config.get('stdoutput', sys.stdout)
output.write("Content-Type: text/plain\n\n" +
"There is something wrong with your setup.\n" +
"Check your config files and verify that your " +
"configuration is correct.\n")
cache = tools.get_cache(request)
if cache:
cache.close()
def render(self, header = 1):
pyhttp = self._request.getHttp()
config = self._request.getConfiguration()
data = self._request.getData()
printout = self.write
self.addHeader('Content-type', 'text/plain')
self.showHeaders()
printout("Welcome to debug mode!\n")
printout("You wanted the %(flavour)s flavour if I support flavours\n" % data)
printout("------------------------------------------------------\n")
printout("The HTTP Return codes are:\n")
printout("------------------------------------------------------\n")
for key in self._header.keys():
printout("%s -> %s\n" % (key, self._header[key]))
printout("------------------------------------------------------\n")
printout("The OS environment contains:\n")
printout("------------------------------------------------------\n")
import os
for key in os.environ.keys():
printout("%s -> %s\n" % (key, os.environ[key]))
printout("------------------------------------------------------\n")
printout("Request.getHttp() dict contains:\n")
printout("------------------------------------------------------\n")
for key in pyhttp.keys():
printout("%s -> %s\n" % (key, pyhttp[key]))
printout("------------------------------------------------------\n")
printout("Request.getConfiguration() dict contains:\n")
printout("------------------------------------------------------\n")
for key in config.keys():
printout("%s -> %s\n" % (key, config[key]))
printout("------------------------------------------------------\n")
printout("Request.getData() dict contains:\n")
printout("------------------------------------------------------\n")
for key in data.keys():
printout("%s -> %s\n" % (key, data[key]))
printout("------------------------------------------------------\n")
printout("Entries to process:\n")
printout("------------------------------------------------------\n")
for content in self._content:
if type(content) != types.StringType:
printout("%s\n" % content.get('filename', 'No such file\n'))
printout("------------------------------------------------------\n")
printout("Entries processed:\n")
printout("------------------------------------------------------\n")
for content in self._content:
if type(content) != types.StringType:
printout("------------------------------------------------------\n")
printout("Items for %s:\n" % content.get('filename', 'No such file\n'))
printout("------------------------------------------------------\n")
for item in content.keys():
printout("%s -> %s\n" % (item, content[item]))
#printout("%s\n" % content.get('filename', 'No such file\n'))
printout("------------------------------------------------------\n")
printout("Cached Titles:\n")
printout("------------------------------------------------------\n")
cache = tools.get_cache(self._request)
for content in self._content:
if type(content) != types.StringType:
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % cache[filename]['title'])
cache.close()
printout("------------------------------------------------------\n")
printout("Cached Entry Bodies:\n")
printout("------------------------------------------------------\n")
for content in self._content:
if type(content) != types.StringType:
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % cache[filename]['title'])
printout("==================================================\n")
printout("%s\n" % cache[filename]['body'])
else:
printout("Contents of %s is not cached\n" % filename)
cache.close()
printout("------------------------------------------------------\n")
def render(self, header=1):
pyhttp = self._request.getHttp()
config = self._request.getConfiguration()
data = self._request.getData()
printout = self.write
self.addHeader('Content-type', 'text/plain')
self.showHeaders()
printout("Welcome to debug mode!\n")
printout("You wanted the %(flavour)s flavour if I support flavours\n" %
data)
printout("------------------------------------------------------\n")
printout("The HTTP Return codes are:\n")
printout("------------------------------------------------------\n")
for key in self._header.keys():
printout("%s -> %s\n" % (key, self._header[key]))
printout("------------------------------------------------------\n")
printout("The OS environment contains:\n")
printout("------------------------------------------------------\n")
import os
for key in os.environ.keys():
printout("%s -> %s\n" % (key, os.environ[key]))
printout("------------------------------------------------------\n")
printout("Request.getHttp() dict contains:\n")
printout("------------------------------------------------------\n")
for key in pyhttp.keys():
printout("%s -> %s\n" % (key, pyhttp[key]))
printout("------------------------------------------------------\n")
printout("Request.getConfiguration() dict contains:\n")
printout("------------------------------------------------------\n")
for key in config.keys():
printout("%s -> %s\n" % (key, config[key]))
printout("------------------------------------------------------\n")
printout("Request.getData() dict contains:\n")
printout("------------------------------------------------------\n")
for key in data.keys():
printout("%s -> %s\n" % (key, data[key]))
printout("------------------------------------------------------\n")
printout("Entries to process:\n")
printout("------------------------------------------------------\n")
for content in self._content:
if type(content) != types.StringType:
printout("%s\n" % content.get('filename', 'No such file\n'))
printout("------------------------------------------------------\n")
printout("Entries processed:\n")
printout("------------------------------------------------------\n")
for content in self._content:
if type(content) != types.StringType:
printout(
"------------------------------------------------------\n")
printout("Items for %s:\n" %
content.get('filename', 'No such file\n'))
printout(
"------------------------------------------------------\n")
for item in content.keys():
printout("%s -> %s\n" % (item, content[item]))
#printout("%s\n" % content.get('filename', 'No such file\n'))
printout("------------------------------------------------------\n")
printout("Cached Titles:\n")
printout("------------------------------------------------------\n")
cache = tools.get_cache(self._request)
for content in self._content:
if type(content) != types.StringType:
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % cache[filename]['title'])
cache.close()
printout("------------------------------------------------------\n")
printout("Cached Entry Bodies:\n")
printout("------------------------------------------------------\n")
for content in self._content:
if type(content) != types.StringType:
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % cache[filename]['title'])
printout(
"==================================================\n")
printout("%s\n" % cache[filename]['body'])
else:
printout("Contents of %s is not cached\n" % filename)
cache.close()
printout(
"------------------------------------------------------\n")
def render(self, header=True):
"""
Renders a Pyblosxom request after we've gone through all the
motions of converting data and getting entries to render.
:param header: either prints (True) or does not print (True)
the http headers.
"""
pyhttp = self._request.get_http()
config = self._request.get_configuration()
data = self._request.get_data()
printout = self.write
hbar = "------------------------------------------------------\n"
if header:
self.add_header('Content-type', 'text/html')
self.show_headers()
printout("<html>")
printout("<body>")
printout("<pre>")
printout("Welcome to debug mode!\n")
printout("You requested the %(flavour)s flavour.\n" % data)
printout(hbar)
printout("HTTP return headers:\n")
printout(hbar)
for k, v in self._header:
printout("<font color=\"#0000ff\">%s</font> -> %s\n" % \
(escv(k), escv(v)))
printout(hbar)
printout("The OS environment contains:\n")
printout(hbar)
import os
print_map(printout, os.environ)
printout(hbar)
printout("Plugins:\n")
printout(hbar)
printout("Plugins that loaded:\n")
if plugin_utils.plugins:
for plugin in plugin_utils.plugins:
printout(" * " + escv(plugin) + "\n")
else:
printout("None\n")
printout("\n")
printout("Plugins that didn't load:\n")
if plugin_utils.bad_plugins:
for plugin, exc in plugin_utils.bad_plugins:
exc = " " + "\n ".join(exc.splitlines()) + "\n"
printout(" * " + escv(plugin) + "\n")
printout(escv(exc))
else:
printout("None\n")
printout(hbar)
printout("Request.get_http() dict contains:\n")
printout(hbar)
print_map(printout, pyhttp)
printout(hbar)
printout("Request.get_configuration() dict contains:\n")
printout(hbar)
print_map(printout, config)
printout(hbar)
printout("Request.get_data() dict contains:\n")
printout(hbar)
print_map(printout, data)
printout(hbar)
printout("Entries to process:\n")
printout(hbar)
for content in self._content:
if not isinstance(content, str):
printout("%s\n" %
escv(content.get('filename', 'No such file\n')))
printout(hbar)
printout("Entries processed:\n")
printout(hbar)
for content in self._content:
if not isinstance(content, str):
printout(hbar)
emsg = escv(content.get('filename', 'No such file\n'))
printout("Items for %s:\n" % emsg)
printout(hbar)
print_map(printout, content)
printout(hbar)
if not config.has_key("cacheDriver"):
printout("No cache driver configured.")
else:
printout("Cached Titles:\n")
printout(hbar)
cache = tools.get_cache(self._request)
for content in self._content:
if not isinstance(content, str):
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % escv(cache[filename]['title']))
cache.close()
printout(hbar)
printout("Cached Entry Bodies:\n")
printout(hbar)
for content in self._content:
if not isinstance(content, str):
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % escv(cache[filename]['title']))
printout(hbar.replace("-", "="))
printout("%s\n" % escv(cache[filename]['body']))
else:
printout("Contents of %s is not cached\n" % \
escv(filename))
cache.close()
printout(hbar)
printout("</body>")
printout("</html>")
def render(self, header=True):
"""
Renders a Pyblosxom request after we've gone through all the
motions of converting data and getting entries to render.
:param header: either prints (True) or does not print (True)
the http headers.
"""
pyhttp = self._request.get_http()
config = self._request.get_configuration()
data = self._request.get_data()
printout = self.write
hbar = "------------------------------------------------------\n"
if header:
self.add_header('Content-type', 'text/html')
self.show_headers()
printout("<html>")
printout("<body>")
printout("<pre>")
printout("Welcome to debug mode!\n")
printout("You requested the %(flavour)s flavour.\n" % data)
printout(hbar)
printout("HTTP return headers:\n")
printout(hbar)
for k, v in self._header:
printout("<font color=\"#0000ff\">%s</font> -> %s\n" % \
(escv(k), escv(v)))
printout(hbar)
printout("The OS environment contains:\n")
printout(hbar)
import os
print_map(printout, os.environ)
printout(hbar)
printout("Plugins:\n")
printout(hbar)
printout("Plugins that loaded:\n")
if plugin_utils.plugins:
for plugin in plugin_utils.plugins:
printout(" * " + escv(plugin) + "\n")
else:
printout("None\n")
printout("\n")
printout("Plugins that didn't load:\n")
if plugin_utils.bad_plugins:
for plugin, exc in plugin_utils.bad_plugins:
exc = " " + "\n ".join(exc.splitlines()) + "\n"
printout(" * " + escv(plugin) + "\n")
printout(escv(exc))
else:
printout("None\n")
printout(hbar)
printout("Request.get_http() dict contains:\n")
printout(hbar)
print_map(printout, pyhttp)
printout(hbar)
printout("Request.get_configuration() dict contains:\n")
printout(hbar)
print_map(printout, config)
printout(hbar)
printout("Request.get_data() dict contains:\n")
printout(hbar)
print_map(printout, data)
printout(hbar)
printout("Entries to process:\n")
printout(hbar)
for content in self._content:
if not isinstance(content, str):
printout("%s\n" %
escv(content.get('filename', 'No such file\n')))
printout(hbar)
printout("Entries processed:\n")
printout(hbar)
for content in self._content:
if not isinstance(content, str):
printout(hbar)
emsg = escv(content.get('filename', 'No such file\n'))
printout("Items for %s:\n" % emsg)
printout(hbar)
print_map(printout, content)
printout(hbar)
if not config.has_key("cacheDriver"):
printout("No cache driver configured.")
else:
printout("Cached Titles:\n")
printout(hbar)
cache = tools.get_cache(self._request)
for content in self._content:
if not isinstance(content, str):
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % escv(cache[filename]['title']))
cache.close()
printout(hbar)
printout("Cached Entry Bodies:\n")
printout(hbar)
for content in self._content:
if not isinstance(content, str):
filename = content['filename']
if cache.has_key(filename):
printout("%s\n" % escv(cache[filename]['title']))
printout(hbar.replace("-", "="))
printout("%s\n" % escv(cache[filename]['body']))
else:
printout("Contents of %s is not cached\n" % \
escv(filename))
cache.close()
printout(hbar)
printout("</body>")
printout("</html>")