def _load_app(self, app_fs_root):
"""Given an app's fs root, return an instance of the application.
Each app is imported under the app_fs_root so that they don't collide in
sys.modules.
"""
logger.debug("loading app from %s" % app_fs_root)
try:
fp, pathname, description = imp.find_module('app', [app_fs_root])
app = imp.load_module(app_fs_root, fp, pathname, description)
except ImportError:
raise ImportError("unable to import app from " + "%s: \n%s" %
(app_fs_root, traceback.format_exc()))
# Validate the app.
# =================
# We use zope interfaces, although your app needn't implement zope
# interfaces explicitly.
try:
verifyObject(IApp, app, tentative=True)
except:
logger.debug("app in %s is not valid." % app_fs_root)
raise
try:
verifyClass(IApplication, app.Application, tentative=True)
except:
logger.debug("app.Application in %s is not valid." % app_fs_root)
raise
return self._instantiate_Application(app_fs_root, app.Application)
def load_app(site_root, app_uri_root):
"""Given a site's FS root and an app's URI root, load the application.
"""
msg = ("Found bad app `%s'. Each app must be a path rooted in the " +
"website root, and it must have a subdirectory named __.")
# Find the app's filesystem root.
# ===============================
_parts = [p for p in app_uri_root.lstrip('/').split('/') if p]
_parts.insert(0, site_root)
fs_root = os.sep.join(_parts)
if not os.path.isdir(fs_root):
raise StandardError(msg % fs_root)
# Find the app's magic directory.
# ===============================
__ = os.path.join(fs_root, '__')
if not os.path.isdir(__):
if fs_root == site_root:
__ = None # special case
else:
raise StandardError(msg % fs_root)
# Load the actual module.
# =======================
# We support automatically falling back to DefaultApp for the root
# directory. Otherwise, we fail if there is no importable app. We also
# validate the app using zope interfaces. Your app needn't implement zope
# interfaces explicitly, however. Also note that we import each app under
# the app_uri_root so that they don't collide in sys.modules.
if __ is None:
app = DefaultApp
else:
try:
fp, pathname, description = imp.find_module('app', [__])
app = imp.load_module(app_uri_root, fp, pathname, description)
except ImportError:
raise ImportError("Unable to import an app from " + "%s: \n%s" %
(__, traceback.format_exc()))
verifyObject(IApp, app, tentative=True)
verifyClass(IApplication, app.Application, tentative=True)
# Add some useful API to Application, and return an instance.
# ===========================================================
app.Application.site_root = site_root
app.Application.uri_root = app_uri_root
app.Application.fs_root = fs_root
app.Application.__ = __
return app.Application()
def test_interfaces(self):
verifyObject(ITimeDelta, timedelta(minutes=20))
verifyObject(IDate, date(2000, 1, 2))
verifyObject(IDateTime, datetime(2000, 1, 2, 10, 20))
verifyObject(ITime, time(20, 30, 15, 1234))
verifyObject(ITZInfo, tzinfo())
verifyClass(ITimeDeltaClass, timedelta)
verifyClass(IDateClass, date)
verifyClass(IDateTimeClass, datetime)
verifyClass(ITimeClass, time)
def __init__(self, request):
"""Takes an IRequest provider.
"""
verifyObject(IRequest, request, tentative=True)
for attr in IRequest._InterfaceClass__attrs.keys(): # hack!
if not attr.startswith('_'):
val = getattr(request, attr)
setattr(self, attr, val)
def __init__(self, request):
"""Takes an IRequest provider.
"""
verifyObject(IRequest, request)
for attr in ['raw', 'raw_line', 'raw_headers', 'raw_body',
'method', 'uri', 'path', 'message']:
val = getattr(request, attr)
setattr(self, attr, val)
def add_api(responder, root, uri):
"""Given a responder, a filesystem path, and a URI, return the responder.
"""
try:
verifyObject(IResponder, responder, tentative=True)
except:
error_logger.debug("%s is not valid." % responder)
raise
if not hasattr(responder, 'uri'):
responder.uri = uri
if not hasattr(responder, 'root'):
responder.root = root
return responder
def test(self):
from httpy._zope.server.logger.pythonlogger import PythonLogger
from httpy._zope.server.interfaces.logger import IMessageLogger
plogger = PythonLogger(self.name)
verifyObject(IMessageLogger, plogger)
msg1 = 'test message 1'
plogger.logMessage(msg1)
self.assertEquals(self.handler.last_record.msg, msg1)
self.assertEquals(self.handler.last_record.levelno, logging.INFO)
msg2 = 'test message 2\r\n'
plogger.level = logging.ERROR
plogger.logMessage(msg2)
self.assertEquals(self.handler.last_record.msg, msg2.rstrip())
self.assertEquals(self.handler.last_record.levelno, logging.ERROR)
def load_responder(self, root):
"""Given a responder's filesystem root, return an instance.
Each responder is imported under the root so that they don't collide in
sys.modules.
"""
logger.debug("loading responder from %s" % root)
try:
result = imp.find_module('responder', [root])
responder = imp.load_module(root, *result)
except ImportError:
raise ImportError("unable to import responder from " + "%s: \n%s" %
(root, traceback.format_exc()))
# Validate the responder.
# =======================
# We use zope interfaces, although your responder needn't implement
# them explicitly. Allow both module and class responders.
try: # responder.Responder.respond()
verifyObject(Iresponder, responder, tentative=True)
try:
responder = responder.Responder
verifyClass(IBaseResponder, responder, tentative=True)
except Invalid:
logger.debug("responder.Responder in %s " % root +
"is not valid.")
raise
except Invalid: # responder.respond()
try:
verifyObject(IBaseResponder, responder, tentative=True)
except:
logger.debug("responder in %s is not valid." % root)
raise
# Alter sys.path, add API and return.
# ===================================
pkg = self.sys_path(root)
self.add_api(responder, root, pkg)
if inspect.isclass(responder):
responder = responder()
return responder
def get_framework(self):
"""Return an instance of the site's framework.
We are looking for a module defined in __/framework.py.
"""
try:
logger.debug("loading framework ...")
fp, pathname, description = imp.find_module( 'framework'
, [self.config.__]
)
framework = imp.load_module('framework', fp, pathname, description)
except ImportError:
logger.warning("framework import failed:\n" +
traceback.format_exc())
logger.info("falling back to PassThrough")
framework = PassThrough
# Validate the framework.
# =======================
# We use zope interfaces, although your framework needn't implement
# zope interfaces explicitly.
try:
verifyObject(IFramework, framework, tentative=True)
except:
logger.debug("framework in %s is not valid." % self.config.__)
raise
# Add API and return.
# ===================
framework.__ = self.config.__
framework.site_root = self.config.root
framework.debug_mode = self.debug_mode
framework.devel_mode = self.devel_mode
framework.deploy_mode = self.deploy_mode
return framework
def _load_module(self, __, name):
"""Given a magic directory, return a module.
We support automatically falling back to DefaultApp for the root
directory. Otherwise, we fail if there is no importable app. We also
validate the app using zope interfaces. Your app needn't implement zope
interfaces explicitly, however.
"""
if __ is None:
app = DefaultApp
else:
try:
fp, pathname, description = imp.find_module('app', [__])
app = imp.load_module(name, fp, pathname, description)
except ImportError:
raise ConfigError("Unable to import an app from " +
"%s: \n%s" % (__, traceback.format_exc()))
verifyObject(IApp, app, tentative=True)
verifyClass(ITransaction, app.Transaction, tentative=True)
return app
def testModule(self):
from httpy._zope.interface.tests.ifoo import IFoo
from httpy._zope.interface.tests import dummy
verifyObject(IFoo, dummy)
def test_IFileSystemInterface(self):
verifyObject(IFileSystem, self.filesystem)