def _parse_error(self, message):
"""Raise a parse error."""
error = ParseError(message)
error.filename = self.m_frames[-1].filename
error.lineno = self.m_frames[-1].lineno
error.backtrace = get_backtrace()
raise error
def _import(self, modname):
"""Import a module `modname'."""
try:
mod = __import__(modname, globals(), locals())
except SyntaxError, err:
error = DracoSiteError("Syntax error in module.")
error.filename = modname
error.lineno = err.lineno
error.backtrace = get_backtrace()
raise error
def handle_request(iface):
"""Handle a request."""
# Acquire the read-write lock. This lock is held by all threads in
# read mode when serving a Draco request. If one of the global Draco
# objects needs to be reloaded, the lock is upgraded to write mode
# by the thread that detected the reload condition. All threads will
# then serialize and the reload can continue.
rwlock.acquire_read()
try:
# Once off initialization. No user code can be run from this, and
# there's no option of recording errors.
initlock.acquire()
try:
global initialized, options
if not initialized:
options = init_options(iface.options())
init_logger(options)
init_codecs(options)
initialized = True
finally:
initlock.release()
# Dispatch the request. Errors are handled from now on.
debug = options.get('debug')
profile = options.get('profile')
logger = logging.getLogger('draco2.core.dispatch')
try:
agent = iface.headers_in().get('user-agent', [''])[0]
logger.debug('Request: %s (%s)' % (iface.uri(), agent))
t1 = time.time()
if profile:
import lsprof
stats = lsprof.profile(dispatch_request, iface)
stats.sort('inlinetime')
io = StringIO()
stats.pprint(top=20, file=io)
logger.debug(io.getvalue())
stats.sort('totaltime')
io = StringIO()
stats.pprint(top=20, file=io)
logger.debug(io.getvalue())
else:
dispatch_request(iface)
t2 = time.time()
logger.debug('Total time spent: %.2f (%s)' % ((t2 - t1), iface.uri()))
return
except HTTPResponse, exc:
status = exc.status
headers = exc.headers
message = http.http_reason_strings[status]
if not hasattr(exc, 'backtrace') or not exc.backtrace:
exc.backtrace = get_backtrace()
errorname = 'error_response_%03d' % status
exception = exc
except (StandardError, DracoError), exc:
status = http.HTTP_INTERNAL_SERVER_ERROR
headers = {}
if not hasattr(exc, 'backtrace') or not exc.backtrace:
exc.backtrace = get_backtrace()
if debug:
message = exc.backtrace
else:
message = http.http_reason_strings[status]
errorname = 'uncaught_exception'
exception = exc
logger.error('A uncaught exception occurred. Backtrace follows.')
logger.error(exc.backtrace)
iface.internal_redirect(uri)
iface.set_error(exception)
try:
dispatch_request(iface)
return
except HTTPResponse, exc:
if exc.status != http.HTTP_NOT_FOUND:
logger.error('HTTP response %s in error handler.' % exc.status)
except (StandardError, DracoError), exc:
# Log the error but display the original one to the user.
logger.error('Uncaught exception in error handler. Backtrace follows.')
if not hasattr(exc, 'backtrace') or not exc.backtrace:
exc.backtrace = get_backtrace()
logger.error(exc.backtrace)
if iface.header_sent():
logger.error('Header was sent by error handler, cannot continue.')
return
# Finally, do a simple error response.
iface.simple_response(status, headers, message)
finally:
rwlock.release_read()
def dispatch_request(iface):
"""Dispatch a request to the proper handler."""
