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
|
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
from __future__ import absolute_import, print_function, unicode_literals
import os
import pystache
import yaml
import copy
# Key used in template inheritance...
INHERITS_KEY = '$inherits'
def merge_to(source, dest):
'''
Merge dict and arrays (override scalar values)
Keys from source override keys from dest, and elements from lists in source
are appended to lists in dest.
:param dict source: to copy from
:param dict dest: to copy to (modified in place)
'''
for key, value in source.items():
# Override mismatching or empty types
if type(value) != type(dest.get(key)): # noqa
dest[key] = source[key]
continue
# Merge dict
if isinstance(value, dict):
merge_to(value, dest[key])
continue
if isinstance(value, list):
dest[key] = dest[key] + source[key]
continue
dest[key] = source[key]
return dest
def merge(*objects):
'''
Merge the given objects, using the semantics described for merge_to, with
objects later in the list taking precedence. From an inheritance
perspective, "parents" should be listed before "children".
Returns the result without modifying any arguments.
'''
if len(objects) == 1:
return copy.deepcopy(objects[0])
return merge_to(objects[-1], merge(*objects[:-1]))
class TemplatesException(Exception):
pass
class Templates():
'''
The taskcluster integration makes heavy use of yaml to describe tasks this
class handles the loading/rendering.
'''
def __init__(self, root):
'''
Initialize the template render.
:param str root: Root path where to load yaml files.
'''
if not root:
raise TemplatesException('Root is required')
if not os.path.isdir(root):
raise TemplatesException('Root must be a directory')
self.root = root
def _inherits(self, path, obj, properties, seen):
blueprint = obj.pop(INHERITS_KEY)
seen.add(path)
# Resolve the path here so we can detect circular references.
template = self.resolve_path(blueprint.get('from'))
variables = blueprint.get('variables', {})
# Passed parameters override anything in the task itself.
for key in properties:
variables[key] = properties[key]
if not template:
msg = '"{}" inheritance template missing'.format(path)
raise TemplatesException(msg)
if template in seen:
msg = 'Error while handling "{}" in "{}" circular template' + \
'inheritance seen \n {}'
raise TemplatesException(msg.format(path, template, seen))
try:
out = self.load(template, variables, seen)
except TemplatesException as e:
msg = 'Error expanding parent ("{}") of "{}" original error {}'
raise TemplatesException(msg.format(template, path, str(e)))
# Anything left in obj is merged into final results (and overrides)
return merge_to(obj, out)
def render(self, path, content, parameters, seen):
'''
Renders a given yaml string.
:param str path: used to prevent infinite recursion in inheritance.
:param str content: Of yaml file.
:param dict parameters: For mustache templates.
:param set seen: Seen files (used for inheritance)
'''
content = pystache.render(content, parameters)
result = yaml.load(content)
# In addition to the usual template logic done by mustache we also
# handle special '$inherit' dict keys.
if isinstance(result, dict) and INHERITS_KEY in result:
return self._inherits(path, result, parameters, seen)
return result
def resolve_path(self, path):
return os.path.join(self.root, path)
def load(self, path, parameters=None, seen=None):
'''
Load an render the given yaml path.
:param str path: Location of yaml file to load (relative to root).
:param dict parameters: To template yaml file with.
'''
seen = seen or set()
if not path:
raise TemplatesException('path is required')
path = self.resolve_path(path)
if not os.path.isfile(path):
raise TemplatesException('"{}" is not a file'.format(path))
content = open(path).read()
return self.render(path, content, parameters, seen)
|
