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
|
import cPickle
import os
from os.path import realpath
import time
from zope.configuration import xmlconfig
import zope.configuration.config
from zope.component.zcml import handler
from zope.component.interface import provideInterface
from zope.configuration.exceptions import ConfigurationError
from zope.configuration.fields import GlobalObject
from zope.interface import Interface
from zope.schema import TextLine
from repoze.bfg.interfaces import IRequest
from repoze.bfg.interfaces import IViewPermission
from repoze.bfg.interfaces import IView
from repoze.bfg.path import package_path
from repoze.bfg.security import ViewPermissionFactory
class Uncacheable(object):
""" Include in discriminators of actions which are not cacheable """
pass
def view(_context,
permission=None,
for_=None,
view=None,
name="",
request_type=IRequest,
cacheable=True,
):
if not view:
raise ConfigurationError('"view" attribute was not specified')
if for_ is not None:
_context.action(
discriminator = None,
callable = provideInterface,
args = ('', for_)
)
if permission:
pfactory = ViewPermissionFactory(permission)
_context.action(
discriminator = ('permission', for_, name, request_type,
IViewPermission),
callable = handler,
args = ('registerAdapter',
pfactory, (for_, request_type), IViewPermission, name,
_context.info),
)
cacheable = cacheable or Uncacheable
_context.action(
discriminator = ('view', for_, name, request_type, IView, cacheable),
callable = handler,
args = ('registerAdapter',
view, (for_, request_type), IView, name,
_context.info),
)
class IViewDirective(Interface):
for_ = GlobalObject(
title=u"The interface or class this view is for.",
required=False
)
permission = TextLine(
title=u"Permission",
description=u"The permission needed to use the view.",
required=False
)
view = GlobalObject(
title=u"",
description=u"The view function",
required=False,
)
name = TextLine(
title=u"The name of the view",
description=u"""
The name shows up in URLs/paths. For example 'foo' or
'foo.html'.""",
required=False,
)
request_type = GlobalObject(
title=u"""The request type interface for the view""",
description=(u"The view will be called if the interface represented by "
u"'request_type' is implemented by the request. The "
u"default request type is repoze.bfg.interfaces.IRequest"),
required=False
)
PVERSION = 1
def pickle_name(name, package):
path = package_path(package)
basename = os.path.join(path, name)
return os.path.join(path, basename + '.cache')
def zcml_configure(name, package, load=cPickle.load):
""" Execute pickled zcml actions or fall back to parsing from file
"""
pckname = pickle_name(name, package)
if not (os.path.isfile(pckname) or os.path.islink(pckname)):
return file_configure(name, package)
try:
vers, ptime, actions = load(open(pckname, 'rb'))
except (IOError, cPickle.UnpicklingError, EOFError, TypeError, ValueError,
AttributeError, NameError, ImportError):
return file_configure(name, package)
if vers != PVERSION:
return file_configure(name, package)
try:
ptime = int(ptime)
except:
return file_configure(name, package)
if not hasattr(actions, '__iter__'):
return file_configure(name, package)
files = set()
for action in actions:
try:
fileset = action[4]
files.update(fileset)
except (TypeError, IndexError):
return file_configure(name, package)
for file in files:
if not(os.path.isfile(file) or os.path.islink(file)):
return file_configure(name, package)
mtime = os.stat(realpath(file)).st_mtime
if mtime >= ptime:
return file_configure(name, package)
context = zope.configuration.config.ConfigurationMachine()
xmlconfig.registerCommonDirectives(context)
context.actions = actions
context.cached_execution = True
context.execute_actions()
return True
def file_configure(name, package, dump=cPickle.dump):
context = zope.configuration.config.ConfigurationMachine()
xmlconfig.registerCommonDirectives(context)
context.package = package
xmlconfig.include(context, name, package)
context.execute_actions(clear=False)
actions = context.actions
pckname = pickle_name(name, package)
for action in actions:
discriminator = action[0]
if discriminator and Uncacheable in discriminator:
try:
os.remove(pckname)
except:
pass
return False
try:
data = (PVERSION, time.time(), actions)
dump(data, open(pckname, 'wb'), -1)
except (OSError, IOError, TypeError, cPickle.PickleError):
try:
os.remove(pckname)
except:
pass
return False
|
