tincan: tincan.py comparison

comparison tincan.py @ 45:969f515b505b draft

Make it easy to leave stdout and stderr alone (untested).

author	David Barts <n5jrn@me.com>
date	Thu, 30 May 2019 14:44:09 -0700
parents	7261459351fa
children	997d0c8c174f

comparison

equal deleted inserted replaced

-:7261459351fa
+:969f515b505b
 import email.utils
 import functools
 import importlib
 from inspect import isclass
 import io
+import logging
 import mimetypes
 import py_compile
 from stat import S_ISDIR, S_ISREG
 from string import whitespace
 from threading import Lock
 import time
-import traceback
 import urllib
+import uuid
 import bottle
 # E x c e p t i o n s
 self.lock = Lock()
 self.get_template = _get_template_nocache
 else:
 self.lock = _DummyLock()
 self.get_template = _get_template_cache
+self.logger = launcher.logger
 def urljoin(self, *args):
 """
 Normalize a parsed-out URL fragment.
 """
 self._type += "; charset=" + launcher.encoding
 else:
 self._encoding = None
 def launch(self):
-# print("adding static route:", self._urlpath)  # debug
+self.logger.info("adding static route: %s", self._urlpath)
 self._app.route(self._urlpath, 'GET', self)
 def _parse_date(self, ims):
 """
 Parse rfc1123, rfc850 and asctime timestamps and return UTC epoch.
 except FileNotFoundError as e:
 return bottle.HTTPError(status=404, exception=e)
 except PermissionError as e:
 return bottle.HTTPError(status=403, exception=e)
 except OSError as e:
+self.logger.exception("unexpected exception reading %r", self._fspath)
 return bottle.HTTPError(status=500, exception=e)
 # Establish preliminary standard headers.
 headers = {
 "Content-Type": self._type,
 "Last-Modified": time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime(mtime)),
 A route to an error page. These don't get routes created for them,
 and are only reached if an error routes them there. Unless you create
 custom code-behind, only two variables are available to your template:
 request (bottle.Request) and error (bottle.HTTPError).
 """
-def __init__(self, template, loads, klass, lock):
+def __init__(self, template, loads, klass, lock, logger):
 self._template = template
 self._template.prepare()
 self._loads = loads
 self._class = klass
 self.lock = lock
+self.logger = logger
 def __call__(self, e):
 bottle.request.environ[_FTYPE] = True
 try:
 obj = self._class(bottle.request, e)
 with self.lock:
 return self._template.render(tvars).lstrip('\n')
 except bottle.HTTPResponse as e:
 return e
 except Exception as e:
-traceback.print_exc()
+self.logger.exception("unexpected exception in error page")
 # Bottle doesn't allow error handlers to themselves cause
 # errors, most likely as a measure to prevent looping. So
 # this will cause a "Critical error while processing request"
 # page to be displayed, and any installed error pages to be
 # ignored.
 oheader = self._header  # save original header
 elif (oheader.errors is None) != (self._header.errors is None):
 raise TinCanError("{0}: invalid #forward".format(self._origin))
 if self._header.forward is None:
 break
-# print("forwarding from:", self._urlpath)  # debug
+# self.logger.debug("forwarding from: %s", self._urlpath)  # debug
 self._redirect()
-# print("forwarded to:", self._urlpath)  # debug
+# self.logger.debug("forwarded to: %s", self._urlpath)  # debug
 # If this is a #hidden page, we ignore it for now, since hidden pages
 # don't get routes made for them.
 if oheader.hidden and not oheader.errors:
 return
 # Get the code-behind #python
 else:
 methods = [ i.upper() for i in self._header.methods.split() ]
 if not methods:
 raise TinCanError("{0}: no #methods specified".format(self._urlpath))
 # Register this thing with Bottle
-# print("adding route:", self._origin, '('+','.join(methods)+')')  # debug
+self.logger.info("adding route: %s (%s)", self._origin, ','.join(methods))
 self._app.route(self._origin, methods, self)
 def _splitpath(self, unsplit):
 return _normpath(self._subdir, unsplit)
 raise TinCanError("{0}: bad #errors line".format(self._urlpath)) from e
 if not errors:
 errors = range(_ERRMIN, _ERRMAX+1)
 route = _TinCanErrorRoute(
 ChameleonTemplate(source=self._template.body, encoding=self._encoding),
-self._loads, self._class, self.lock)
+self._loads, self._class, self.lock, self.logger)
 for error in errors:
 if error < _ERRMIN or error > _ERRMAX:
 raise TinCanError("{0}: bad #errors code".format(self._urlpath))
 self._app.error_handler[error] = route  # XXX
 except ForwardException as fwd:
 target = fwd.target
 except bottle.HTTPResponse as e:
 return e
 except Exception as e:
-traceback.print_exc()
+self.logger.exception("%s: unexpected exception", self._urlpath)
 raise bottle.HTTPError(status=500, exception=e)
 if target is None:
-message = "{0}: unexpected null target".format(self._urlpath)
+self.logger.error("%s: unexpected null target", self._urlpath)
-sys.stderr.write(message + '\n')
 raise bottle.HTTPError(status=500, exception=TinCanError(message))
 # We get here if we are doing a server-side programmatic
 # forward.
 environ = bottle.request.environ
 if _FORIG not in environ:
 environ[_FORIG] = self._urlpath
 if _FLOOP not in environ:
 environ[_FLOOP] = set([self._urlpath])
 elif target in environ[_FLOOP]:
-message = "{0}: forward loop detected".format(environ[_FORIG])
+self.logger.error("%s: forward loop detected", environ[_FORIG])
-sys.stderr.write(message + '\n')
 raise bottle.HTTPError(status=500, exception=TinCanError(message))
 environ[_FLOOP].add(target)
 environ['bottle.raw_path'] = target
 environ['PATH_INFO'] = urllib.parse.quote(target)
 route, args = self._app.router.match(environ)
 class _Launcher(object):
 """
 Helper class for launching webapps.
 """
-def __init__(self, fsroot, urlroot, logger, multithread=True):
+def __init__(self, fsroot, urlroot, multithread):
 """
 Lightweight constructor. The real action happens in .launch() below.
 """
 self.fsroot = fsroot
 self.urlroot = urlroot
-self.logger = logger
 self.app = None
 self.errors = 0
 self.debug = False
 self.encoding = ENCODING
 self.static = False
 self.multithread = multithread
+self.logger = None
 def launch(self):
 """
 Does the actual work of launching something. XXX - modifies sys.path
 and never un-modifies it.
 else:
 continue
 try:
 route.launch()
 except TinCanError as e:
-self.logger(str(e))
+if self.logger.getEffectiveLevel() <= logging.DEBUG:
-if self.debug:
+self.logger.exception(str(e))
-while e.__cause__ != None:
+else:
-e = e.__cause__
+self.logger.error(str(e))
-self.logger("\t{0}: {1!s}".format(e.__class__.__name__, e))
 self.errors += 1
 elif S_ISDIR(etype):
 self._launch(subdir + [entry])
-def _logger(message):
+def launch(fsroot=None, urlroot='/', logger=None, debug=False,
-sys.stderr.write(message)
-sys.stderr.write('\n')
-def launch(fsroot=None, urlroot='/', logger=_logger, debug=False,
 encoding=ENCODING, static=False, multithread=True):
 """
 Launch and return a TinCan webapp. Does not run the app; it is the
 caller's responsibility to call app.run()
 """
+if logger is None:
+logger = logging.getLogger("{0!s}-{1!s}".format(__name__, uuid.uuid1()))
+logger.addHandler(logging.StreamHandler())
+logger.setLevel(logging.DEBUG if debug else logging.INFO)
 if fsroot is None:
 fsroot = os.getcwd()
-launcher = _Launcher(fsroot, urlroot, logger, multithread=multithread)
+launcher = _Launcher(fsroot, urlroot, multithread)
-launcher.debug = debug
+launcher.logger = logger
 launcher.encoding = encoding
 launcher.static = static
 launcher.launch()
 return launcher.app, launcher.errors

Mercurial > cgi-bin > hgweb.cgi > tincan

comparison tincan.py @ 45:969f515b505b draft