1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
from zope.component.event import dispatch
from zope.interface import implements
from zope.interface import providedBy
from repoze.bfg.interfaces import IForbiddenView
from repoze.bfg.interfaces import ILogger
from repoze.bfg.interfaces import INotFoundView
from repoze.bfg.interfaces import IRootFactory
from repoze.bfg.interfaces import IRouter
from repoze.bfg.interfaces import ISettings
from repoze.bfg.interfaces import ITraverser
from repoze.bfg.interfaces import IView
from repoze.bfg.configuration import make_registry
from repoze.bfg.configuration import DefaultRootFactory
from repoze.bfg.events import AfterTraversal
from repoze.bfg.events import NewRequest
from repoze.bfg.events import NewResponse
from repoze.bfg.events import WSGIApplicationCreatedEvent
from repoze.bfg.exceptions import Forbidden
from repoze.bfg.exceptions import NotFound
from repoze.bfg.request import Request
from repoze.bfg.threadlocal import manager
from repoze.bfg.traversal import ModelGraphTraverser
from repoze.bfg.view import default_forbidden_view
from repoze.bfg.view import default_notfound_view
_marker = object()
class Router(object):
""" The main repoze.bfg WSGI application. """
implements(IRouter)
debug_notfound = False
threadlocal_manager = manager
def __init__(self, registry):
q = registry.queryUtility
self.logger = q(ILogger, 'repoze.bfg.debug')
self.notfound_view = q(INotFoundView, default=default_notfound_view)
self.forbidden_view = q(IForbiddenView, default=default_forbidden_view)
self.root_factory = q(IRootFactory, default=DefaultRootFactory)
self.root_policy = self.root_factory # b/w compat
self.registry = registry
settings = registry.queryUtility(ISettings)
if settings is not None:
self.debug_notfound = settings['debug_notfound']
def __call__(self, environ, start_response):
"""
Accept ``environ`` and ``start_response``; route requests to
``repoze.bfg`` views based on registrations within the
application registry; call ``start_response`` and return an
iterable.
"""
registry = self.registry
has_listeners = registry.has_listeners
logger = self.logger
manager = self.threadlocal_manager
threadlocals = {'registry':registry, 'request':None}
manager.push(threadlocals)
try:
# setup
request = Request(environ)
threadlocals['request'] = request
attrs = request.__dict__
attrs['registry'] = registry
has_listeners and registry.notify(NewRequest(request))
# view lookup
root = self.root_factory(request)
attrs['root'] = root
traverser = registry.queryAdapter(root, ITraverser)
if traverser is None:
traverser = ModelGraphTraverser(root)
tdict = traverser(request)
context, view_name, subpath, traversed, vroot, vroot_path = (
tdict['context'], tdict['view_name'], tdict['subpath'],
tdict['traversed'], tdict['virtual_root'],
tdict['virtual_root_path'])
attrs.update(tdict)
has_listeners and registry.notify(AfterTraversal(request))
provides = map(providedBy, (context, request))
view_callable = registry.adapters.lookup(
provides, IView, name=view_name, default=None)
# view execution
if view_callable is None:
if self.debug_notfound:
msg = (
'debug_notfound of url %s; path_info: %r, context: %r, '
'view_name: %r, subpath: %r, traversed: %r, '
'root: %r, vroot: %r, vroot_path: %r' % (
request.url, request.path_info, context, view_name,
subpath, traversed, root, vroot, vroot_path)
)
logger and logger.debug(msg)
else:
msg = request.path_info
environ['repoze.bfg.message'] = msg
response = self.notfound_view(context, request)
else:
try:
response = view_callable(context, request)
except Forbidden, why:
msg = why[0]
environ['repoze.bfg.message'] = msg
response = self.forbidden_view(context, request)
except NotFound, why:
msg = why[0]
environ['repoze.bfg.message'] = msg
response = self.notfound_view(context, request)
# response handling
has_listeners and registry.notify(NewResponse(response))
try:
headers = response.headerlist
app_iter = response.app_iter
status = response.status
except AttributeError:
raise ValueError(
'Non-response object returned from view named %s '
'(and no renderer): %r' % (view_name, response))
if 'global_response_headers' in attrs:
headers = list(headers)
headers.extend(attrs['global_response_headers'])
start_response(response.status, headers)
return response.app_iter
finally:
manager.pop()
# make_registry and manager kw args for unit testing only
# note that ``options`` is a b/w compat alias for ``settings``
def make_app(root_factory, package=None, filename='configure.zcml',
settings=None, options=None,
authentication_policy=None, authorization_policy=None,
manager=manager, make_registry=make_registry):
""" Return a Router object, representing a fully configured
``repoze.bfg`` WSGI application.
``root_factory`` must be a callable that accepts a :term:`request`
object and which returns a traversal root object. The traversal
root returned by the root factory is the *default* traversal root;
it can be overridden on a per-view basis. ``root_factory`` may be
``None``, in which case a 'default default' traversal root is
used.
``package`` is a Python module representing the application's
package. It is optional, defaulting to ``None``. ``package`` may
be ``None``. If ``package`` is ``None``, the ``filename`` passed
or the value in the ``options`` dictionary named
``configure_zcml`` must be a) absolute pathname to a ZCML file
that represents the application's configuration *or* b) a
'specification' in the form
``dotted_package_name:relative/file/path.zcml``.
``filename`` is the filesystem path to a ZCML file (optionally
relative to the package path) that should be parsed to create the
application registry. It defaults to ``configure.zcml``. It can
also be a 'specification' in the form
``dotted_package_name:relatve/file/path.zcml``. Note that if any
value for ``configure_zcml`` is passed within the ``options``
dictionary, the value passed as ``filename`` will be ignored,
replaced with the ``configure_zcml`` value.
``settings``, if used, should be a dictionary containing runtime
settings (e.g. the key/value pairs in an app section of a
PasteDeploy file), with each key representing the option and the
key's value representing the specific option value,
e.g. ``{'reload_templates':True}``. Note that the keyword
parameter ``options`` is a backwards compatibility alias for the
``settings`` keyword parameter.
"""
settings = settings or options
registry = make_registry(root_factory, package, filename,
authentication_policy, authorization_policy,
settings)
app = Router(registry)
# We push the registry on to the stack here in case any ZCA API is
# used in listeners subscribed to the WSGIApplicationCreatedEvent
# we send.
manager.push({'registry':registry, 'request':None})
try:
# use dispatch here instead of registry.notify to make unit
# tests possible
dispatch(WSGIApplicationCreatedEvent(app))
finally:
manager.pop()
return app
|
