332 lines
10 KiB
Python
332 lines
10 KiB
Python
|
#!/usr/bin/env python
|
||
|
|
# -*- coding: utf-8 -*-
|
||
|
|
"""
|
||
|
|
| This file is part of the web2py Web Framework
|
||
|
|
| Copyrighted by Massimo Di Pierro <mdipierro@cs.depaul.edu>
|
||
|
|
| License: LGPLv3 (http://www.gnu.org/licenses/lgpl.html)
|
||
|
|
|
||
|
|
Restricted environment to execute application's code
|
||
|
|
-----------------------------------------------------
|
||
|
|
"""
|
||
|
|
|
||
|
|
import sys
|
||
|
|
from gluon._compat import pickle, ClassType, unicodeT, to_bytes
|
||
|
|
import traceback
|
||
|
|
import types
|
||
|
|
import os
|
||
|
|
import logging
|
||
|
|
|
||
|
|
from gluon.storage import Storage
|
||
|
|
from gluon.http import HTTP
|
||
|
|
from gluon.html import BEAUTIFY, XML
|
||
|
|
from gluon.settings import global_settings
|
||
|
|
|
||
|
|
logger = logging.getLogger("web2py")
|
||
|
|
|
||
|
|
__all__ = ['RestrictedError', 'restricted', 'TicketStorage', 'compile2']
|
||
|
|
|
||
|
|
|
||
|
|
class TicketStorage(Storage):
|
||
|
|
|
||
|
|
"""
|
||
|
|
Defines the ticket object and the default values of its members (None)
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(
|
||
|
|
self,
|
||
|
|
db=None,
|
||
|
|
tablename='web2py_ticket'
|
||
|
|
):
|
||
|
|
Storage.__init__(self)
|
||
|
|
self.db = db
|
||
|
|
self.tablename = tablename
|
||
|
|
|
||
|
|
def store(self, request, ticket_id, ticket_data):
|
||
|
|
"""
|
||
|
|
Stores the ticket. It will figure out if this must be on disk or in db
|
||
|
|
"""
|
||
|
|
if self.db:
|
||
|
|
self._store_in_db(request, ticket_id, ticket_data)
|
||
|
|
else:
|
||
|
|
self._store_on_disk(request, ticket_id, ticket_data)
|
||
|
|
|
||
|
|
def _store_in_db(self, request, ticket_id, ticket_data):
|
||
|
|
self.db._adapter.reconnect()
|
||
|
|
try:
|
||
|
|
table = self._get_table(self.db, self.tablename, request.application)
|
||
|
|
table.insert(ticket_id=ticket_id,
|
||
|
|
ticket_data=pickle.dumps(ticket_data, pickle.HIGHEST_PROTOCOL),
|
||
|
|
created_datetime=request.now)
|
||
|
|
self.db.commit()
|
||
|
|
message = 'In FILE: %(layer)s\n\n%(traceback)s\n'
|
||
|
|
except Exception:
|
||
|
|
self.db.rollback()
|
||
|
|
message =' Unable to store in FILE: %(layer)s\n\n%(traceback)s\n'
|
||
|
|
self.db.close()
|
||
|
|
logger.error(message % ticket_data)
|
||
|
|
|
||
|
|
def _store_on_disk(self, request, ticket_id, ticket_data):
|
||
|
|
ef = self._error_file(request, ticket_id, 'wb')
|
||
|
|
try:
|
||
|
|
pickle.dump(ticket_data, ef)
|
||
|
|
finally:
|
||
|
|
ef.close()
|
||
|
|
|
||
|
|
def _error_file(self, request, ticket_id, mode, app=None):
|
||
|
|
root = request.folder
|
||
|
|
if app:
|
||
|
|
root = os.path.join(os.path.join(root, '..'), app)
|
||
|
|
errors_folder = os.path.abspath(
|
||
|
|
os.path.join(root, 'errors')) # .replace('\\', '/')
|
||
|
|
return open(os.path.join(errors_folder, ticket_id), mode)
|
||
|
|
|
||
|
|
def _get_table(self, db, tablename, app):
|
||
|
|
tablename = tablename + '_' + app
|
||
|
|
table = db.get(tablename)
|
||
|
|
if not table:
|
||
|
|
table = db.define_table(
|
||
|
|
tablename,
|
||
|
|
db.Field('ticket_id', length=100),
|
||
|
|
db.Field('ticket_data', 'text'),
|
||
|
|
db.Field('created_datetime', 'datetime'))
|
||
|
|
return table
|
||
|
|
|
||
|
|
def load(
|
||
|
|
self,
|
||
|
|
request,
|
||
|
|
app,
|
||
|
|
ticket_id,
|
||
|
|
):
|
||
|
|
if not self.db:
|
||
|
|
try:
|
||
|
|
ef = self._error_file(request, ticket_id, 'rb', app)
|
||
|
|
except IOError:
|
||
|
|
return {}
|
||
|
|
try:
|
||
|
|
return pickle.load(ef)
|
||
|
|
finally:
|
||
|
|
ef.close()
|
||
|
|
else:
|
||
|
|
table = self._get_table(self.db, self.tablename, app)
|
||
|
|
rows = self.db(table.ticket_id == ticket_id).select()
|
||
|
|
return pickle.loads(rows[0].ticket_data) if rows else {}
|
||
|
|
|
||
|
|
|
||
|
|
class RestrictedError(Exception):
|
||
|
|
"""
|
||
|
|
Class used to wrap an exception that occurs in the restricted environment
|
||
|
|
below. The traceback is used to log the exception and generate a ticket.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(
|
||
|
|
self,
|
||
|
|
layer='',
|
||
|
|
code='',
|
||
|
|
output='',
|
||
|
|
environment=None,
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Layer here is some description of where in the system the exception
|
||
|
|
occurred.
|
||
|
|
"""
|
||
|
|
if environment is None:
|
||
|
|
environment = {}
|
||
|
|
self.layer = layer
|
||
|
|
self.code = code
|
||
|
|
self.output = output
|
||
|
|
self.environment = environment
|
||
|
|
if layer:
|
||
|
|
try:
|
||
|
|
try:
|
||
|
|
self.traceback = traceback.format_exc()
|
||
|
|
except:
|
||
|
|
self.traceback = traceback.format_exc(limit=1)
|
||
|
|
except:
|
||
|
|
self.traceback = 'no traceback because template parsing error'
|
||
|
|
try:
|
||
|
|
self.snapshot = snapshot(context=10, code=code,
|
||
|
|
environment=self.environment)
|
||
|
|
except:
|
||
|
|
self.snapshot = {}
|
||
|
|
else:
|
||
|
|
self.traceback = '(no error)'
|
||
|
|
self.snapshot = {}
|
||
|
|
|
||
|
|
def log(self, request):
|
||
|
|
"""
|
||
|
|
Logs the exception.
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
d = {
|
||
|
|
'layer': str(self.layer),
|
||
|
|
'code': str(self.code),
|
||
|
|
'output': str(self.output),
|
||
|
|
'traceback': str(self.traceback),
|
||
|
|
'snapshot': self.snapshot,
|
||
|
|
}
|
||
|
|
ticket_storage = TicketStorage(db=request.tickets_db)
|
||
|
|
ticket_storage.store(request, request.uuid.split('/', 1)[1], d)
|
||
|
|
cmd_opts = global_settings.cmd_options
|
||
|
|
if cmd_opts and cmd_opts.print_errors:
|
||
|
|
logger.error(self.traceback)
|
||
|
|
return request.uuid
|
||
|
|
except:
|
||
|
|
logger.error(self.traceback)
|
||
|
|
return None
|
||
|
|
|
||
|
|
|
||
|
|
def load(self, request, app, ticket_id):
|
||
|
|
"""
|
||
|
|
Loads a logged exception.
|
||
|
|
"""
|
||
|
|
ticket_storage = TicketStorage(db=request.tickets_db)
|
||
|
|
d = ticket_storage.load(request, app, ticket_id)
|
||
|
|
|
||
|
|
self.layer = d.get('layer')
|
||
|
|
self.code = d.get('code')
|
||
|
|
self.output = d.get('output')
|
||
|
|
self.traceback = d.get('traceback')
|
||
|
|
self.snapshot = d.get('snapshot')
|
||
|
|
|
||
|
|
def __str__(self):
|
||
|
|
# safely show an useful message to the user
|
||
|
|
try:
|
||
|
|
output = self.output
|
||
|
|
if not isinstance(output, str, bytes, bytearray):
|
||
|
|
output = str(output)
|
||
|
|
if isinstance(output, unicodeT):
|
||
|
|
output = to_bytes(output)
|
||
|
|
except:
|
||
|
|
output = ""
|
||
|
|
return output
|
||
|
|
|
||
|
|
|
||
|
|
def compile2(code, layer):
|
||
|
|
return compile(code, layer, 'exec')
|
||
|
|
|
||
|
|
|
||
|
|
def restricted(ccode, environment=None, layer='Unknown', scode=None):
|
||
|
|
"""
|
||
|
|
Runs code in environment and returns the output. If an exception occurs
|
||
|
|
in code it raises a RestrictedError containing the traceback. Layer is
|
||
|
|
passed to RestrictedError to identify where the error occurred.
|
||
|
|
"""
|
||
|
|
if environment is None:
|
||
|
|
environment = {}
|
||
|
|
environment['__file__'] = layer
|
||
|
|
environment['__name__'] = '__restricted__'
|
||
|
|
try:
|
||
|
|
exec(ccode, environment)
|
||
|
|
except HTTP:
|
||
|
|
raise
|
||
|
|
except RestrictedError:
|
||
|
|
# do not encapsulate (obfuscate) the original RestrictedError
|
||
|
|
raise
|
||
|
|
except Exception as error:
|
||
|
|
# extract the exception type and value (used as output message)
|
||
|
|
etype, evalue, tb = sys.exc_info()
|
||
|
|
# XXX Show exception in Wing IDE if running in debugger
|
||
|
|
if __debug__ and 'WINGDB_ACTIVE' in os.environ:
|
||
|
|
sys.excepthook(etype, evalue, tb)
|
||
|
|
del tb
|
||
|
|
output = "%s %s" % (etype, evalue)
|
||
|
|
# Save source code in ticket when available
|
||
|
|
scode = scode if scode else ccode
|
||
|
|
raise RestrictedError(layer, scode, output, environment)
|
||
|
|
|
||
|
|
|
||
|
|
def snapshot(info=None, context=5, code=None, environment=None):
|
||
|
|
"""Return a dict describing a given traceback (based on cgitb.text)."""
|
||
|
|
import time
|
||
|
|
import linecache
|
||
|
|
import inspect
|
||
|
|
import pydoc
|
||
|
|
import cgitb
|
||
|
|
|
||
|
|
# if no exception info given, get current:
|
||
|
|
etype, evalue, etb = info or sys.exc_info()
|
||
|
|
|
||
|
|
if isinstance(etype, ClassType):
|
||
|
|
etype = etype.__name__
|
||
|
|
|
||
|
|
# create a snapshot dict with some basic information
|
||
|
|
s = {}
|
||
|
|
s['pyver'] = 'Python ' + sys.version.split()[0] + ': ' + sys.executable + ' (prefix: %s)' % sys.prefix
|
||
|
|
s['date'] = time.ctime(time.time())
|
||
|
|
|
||
|
|
# start to process frames
|
||
|
|
records = inspect.getinnerframes(etb, context)
|
||
|
|
del etb # Prevent circular references that would cause memory leaks
|
||
|
|
s['frames'] = []
|
||
|
|
for frame, file, lnum, func, lines, index in records:
|
||
|
|
file = file and os.path.abspath(file) or '?'
|
||
|
|
args, varargs, varkw, locals = inspect.getargvalues(frame)
|
||
|
|
call = ''
|
||
|
|
if func != '?':
|
||
|
|
call = inspect.formatargvalues(args, varargs, varkw, locals,
|
||
|
|
formatvalue=lambda value: '=' + pydoc.text.repr(value))
|
||
|
|
|
||
|
|
# basic frame information
|
||
|
|
f = {'file': file, 'func': func, 'call': call, 'lines': {},
|
||
|
|
'lnum': lnum}
|
||
|
|
|
||
|
|
highlight = {}
|
||
|
|
|
||
|
|
def reader(lnum=[lnum]):
|
||
|
|
highlight[lnum[0]] = 1
|
||
|
|
try:
|
||
|
|
return linecache.getline(file, lnum[0])
|
||
|
|
finally:
|
||
|
|
lnum[0] += 1
|
||
|
|
vars = cgitb.scanvars(reader, frame, locals)
|
||
|
|
|
||
|
|
# if it is a view, replace with generated code
|
||
|
|
if file.endswith('html'):
|
||
|
|
lmin = lnum > context and (lnum - context) or 0
|
||
|
|
lmax = lnum + context
|
||
|
|
lines = code.split("\n")[lmin:lmax]
|
||
|
|
index = min(context, lnum) - 1
|
||
|
|
|
||
|
|
if index is not None:
|
||
|
|
i = lnum - index
|
||
|
|
for line in lines:
|
||
|
|
f['lines'][i] = line.rstrip()
|
||
|
|
i += 1
|
||
|
|
|
||
|
|
# dump local variables (referenced in current line only)
|
||
|
|
f['dump'] = {}
|
||
|
|
for name, where, value in vars:
|
||
|
|
if name in f['dump']:
|
||
|
|
continue
|
||
|
|
if value is not cgitb.__UNDEF__:
|
||
|
|
if where == 'global':
|
||
|
|
name = 'global ' + name
|
||
|
|
elif where != 'local':
|
||
|
|
name = where + name.split('.')[-1]
|
||
|
|
f['dump'][name] = pydoc.text.repr(value)
|
||
|
|
else:
|
||
|
|
f['dump'][name] = 'undefined'
|
||
|
|
|
||
|
|
s['frames'].append(f)
|
||
|
|
|
||
|
|
# add exception type, value and attributes
|
||
|
|
s['etype'] = str(etype)
|
||
|
|
s['evalue'] = str(evalue)
|
||
|
|
s['exception'] = {}
|
||
|
|
if isinstance(evalue, BaseException):
|
||
|
|
for name in dir(evalue):
|
||
|
|
value = pydoc.text.repr(getattr(evalue, name))
|
||
|
|
s['exception'][name] = value
|
||
|
|
|
||
|
|
# add all local values (of last frame) to the snapshot
|
||
|
|
s['locals'] = {}
|
||
|
|
for name, value in locals.items():
|
||
|
|
s['locals'][name] = pydoc.text.repr(value)
|
||
|
|
|
||
|
|
# add web2py environment variables
|
||
|
|
for k, v in environment.items():
|
||
|
|
if k in ('request', 'response', 'session'):
|
||
|
|
s[k] = XML(str(BEAUTIFY(v)))
|
||
|
|
|
||
|
|
return s
|