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
197
198
199
200
201
|
"""This provides bundle clauses with translation functionality."""
import copy
import logging
import lxml.etree
import os
import os.path
import re
import sys
import Bcfg2.Server
import Bcfg2.Server.Plugin
import Bcfg2.Server.Lint
try:
import genshi.template.base
from Bcfg2.Server.Plugins.TGenshi import removecomment, TemplateFile
HAS_GENSHI = True
except ImportError:
HAS_GENSHI = False
SETUP = None
class BundleFile(Bcfg2.Server.Plugin.StructFile):
""" Representation of a bundle XML file """
def get_xml_value(self, metadata):
""" get the XML data that applies to the given client """
bundlename = os.path.splitext(os.path.basename(self.name))[0]
bundle = lxml.etree.Element('Bundle', name=bundlename)
for item in self.Match(metadata):
bundle.append(copy.copy(item))
return bundle
if HAS_GENSHI:
class BundleTemplateFile(TemplateFile,
Bcfg2.Server.Plugin.StructFile):
""" Representation of a Genshi-templated bundle XML file """
def __init__(self, name, specific, encoding, fam=None):
TemplateFile.__init__(self, name, specific, encoding)
Bcfg2.Server.Plugin.StructFile.__init__(self, name, fam=fam)
self.logger = logging.getLogger(name)
def get_xml_value(self, metadata):
""" get the rendered XML data that applies to the given
client """
if not hasattr(self, 'template'):
msg = "No parsed template information for %s" % self.name
self.logger.error(msg)
raise Bcfg2.Server.Plugin.PluginExecutionError(msg)
stream = self.template.generate(
metadata=metadata,
repo=SETUP['repo']).filter(removecomment)
data = lxml.etree.XML(
stream.render('xml', strip_whitespace=False).encode(),
parser=Bcfg2.Server.XMLParser)
bundlename = os.path.splitext(os.path.basename(self.name))[0]
bundle = lxml.etree.Element('Bundle', name=bundlename)
for item in self.Match(metadata, data):
bundle.append(copy.deepcopy(item))
return bundle
def Match(self, metadata, xdata): # pylint: disable=W0221
"""Return matching fragments of parsed template."""
rv = []
for child in xdata.getchildren():
rv.extend(self._match(child, metadata))
self.logger.debug("File %s got %d match(es)" % (self.name,
len(rv)))
return rv
class SGenshiTemplateFile(BundleTemplateFile):
""" provided for backwards compat with the deprecated SGenshi
plugin """
pass
class Bundler(Bcfg2.Server.Plugin.Plugin,
Bcfg2.Server.Plugin.Structure,
Bcfg2.Server.Plugin.XMLDirectoryBacked):
""" The bundler creates dependent clauses based on the
bundle/translation scheme from Bcfg1. """
__author__ = 'bcfg-dev@mcs.anl.gov'
patterns = re.compile(r'^(?P<name>.*)\.(xml|genshi)$')
def __init__(self, core, datastore):
Bcfg2.Server.Plugin.Plugin.__init__(self, core, datastore)
Bcfg2.Server.Plugin.Structure.__init__(self)
self.encoding = core.setup['encoding']
self.__child__ = self.template_dispatch
Bcfg2.Server.Plugin.XMLDirectoryBacked.__init__(self, self.data,
self.core.fam)
global SETUP
SETUP = core.setup
def template_dispatch(self, name, _):
""" Add the correct child entry type to Bundler depending on
whether the XML file in question is a plain XML file or a
templated bundle """
bundle = lxml.etree.parse(name, parser=Bcfg2.Server.XMLParser)
nsmap = bundle.getroot().nsmap
if (name.endswith('.genshi') or
('py' in nsmap and
nsmap['py'] == 'http://genshi.edgewall.org/')):
if HAS_GENSHI:
spec = Bcfg2.Server.Plugin.Specificity()
return BundleTemplateFile(name, spec, self.encoding,
fam=self.core.fam)
else:
raise Bcfg2.Server.Plugin.PluginExecutionError("Genshi not "
"available: %s"
% name)
else:
return BundleFile(name, fam=self.fam)
def BuildStructures(self, metadata):
"""Build all structures for client (metadata)."""
bundleset = []
bundle_entries = {}
for key, item in self.entries.items():
bundle_entries.setdefault(
self.patterns.match(os.path.basename(key)).group('name'),
[]).append(item)
for bundlename in metadata.bundles:
try:
entries = bundle_entries[bundlename]
except KeyError:
self.logger.error("Bundler: Bundle %s does not exist" %
bundlename)
continue
try:
bundleset.append(entries[0].get_xml_value(metadata))
except genshi.template.base.TemplateError:
err = sys.exc_info()[1]
self.logger.error("Bundler: Failed to render templated bundle "
"%s: %s" % (bundlename, err))
except:
self.logger.error("Bundler: Unexpected bundler error for %s" %
bundlename, exc_info=1)
return bundleset
class BundlerLint(Bcfg2.Server.Lint.ServerPlugin):
""" Perform various :ref:`Bundler
<server-plugins-structures-bundler-index>` checks. """
def Run(self):
self.missing_bundles()
for bundle in self.core.plugins['Bundler'].entries.values():
if (self.HandlesFile(bundle.name) and
(not HAS_GENSHI or
not isinstance(bundle, BundleTemplateFile))):
self.bundle_names(bundle)
@classmethod
def Errors(cls):
return {"bundle-not-found": "error",
"inconsistent-bundle-name": "warning"}
def missing_bundles(self):
""" Find bundles listed in Metadata but not implemented in
Bundler. """
if self.files is None:
# when given a list of files on stdin, this check is
# useless, so skip it
groupdata = self.metadata.groups_xml.xdata
ref_bundles = set([b.get("name")
for b in groupdata.findall("//Bundle")])
allbundles = self.core.plugins['Bundler'].entries.keys()
for bundle in ref_bundles:
xmlbundle = "%s.xml" % bundle
genshibundle = "%s.genshi" % bundle
if (xmlbundle not in allbundles and
genshibundle not in allbundles):
self.LintError("bundle-not-found",
"Bundle %s referenced, but does not exist" %
bundle)
def bundle_names(self, bundle):
""" Verify bundle name attribute matches filename.
:param bundle: The bundle to verify
:type bundle: Bcfg2.Server.Plugins.Bundler.BundleFile
"""
try:
xdata = lxml.etree.XML(bundle.data)
except AttributeError:
# genshi template
xdata = lxml.etree.parse(bundle.template.filepath).getroot()
fname = os.path.splitext(os.path.basename(bundle.name))[0]
bname = xdata.get('name')
if fname != bname:
self.LintError("inconsistent-bundle-name",
"Inconsistent bundle name: filename is %s, "
"bundle name is %s" % (fname, bname))
|
