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
|
package context
import (
"path"
"github.com/polydawn/meep"
"github.com/tazjin/kontemplate/util"
)
type ResourceSet struct {
Name string `json:"name"`
Path string `json:"path"`
Values map[string]interface{} `json:"values"`
// Fields for resource set collections
Include []ResourceSet `json:"include"`
Parent string
}
type Context struct {
Name string `json:"context"`
Global map[string]interface{} `json:"global"`
ResourceSets []ResourceSet `json:"include"`
VariableImports []string `json:"import"`
BaseDir string
}
type ContextLoadingError struct {
meep.AllTraits
Filename string
}
// Attempt to load and deserialise a Context from the specified file.
func LoadContextFromFile(filename string) (*Context, error) {
var c Context
err := util.LoadJsonOrYaml(filename, &c)
if err != nil {
return nil, meep.New(
&ContextLoadingError{Filename: filename},
meep.Cause(err),
)
}
c.ResourceSets = flattenPrepareResourceSetPaths(&c.ResourceSets)
c.BaseDir = path.Dir(filename)
c.ResourceSets = loadAllDefaultValues(&c)
err = c.loadImportedVariables()
if err != nil {
return nil, meep.New(
&ContextLoadingError{Filename: filename},
meep.Cause(err),
)
}
return &c, nil
}
// Kontemplate supports specifying additional variable files with the `import` keyword. This function loads those
// variable files and merges them together with the context's other global variables.
func (ctx *Context) loadImportedVariables() error {
for _, file := range ctx.VariableImports {
var importedVars map[string]interface{}
err := util.LoadJsonOrYaml(path.Join(ctx.BaseDir, file), &importedVars)
if err != nil {
return err
}
ctx.Global = *util.Merge(&ctx.Global, &importedVars)
}
return nil
}
// Correctly prepares the file paths for resource sets by inferring implicit paths and flattening resource set
// collections, i.e. resource sets that themselves have an additional 'include' field set.
// Those will be regarded as a short-hand for including multiple resource sets from a subfolder.
// See https://github.com/tazjin/kontemplate/issues/9 for more information.
func flattenPrepareResourceSetPaths(rs *[]ResourceSet) []ResourceSet {
flattened := make([]ResourceSet, 0)
for _, r := range *rs {
// If a path is not explicitly specified it should default to the resource set name.
// This is also the classic behaviour prior to kontemplate 1.2
if r.Path == "" {
r.Path = r.Name
}
if len(r.Include) == 0 {
flattened = append(flattened, r)
} else {
for _, subResourceSet := range r.Include {
if subResourceSet.Path == "" {
subResourceSet.Path = subResourceSet.Name
}
subResourceSet.Parent = r.Name
subResourceSet.Name = path.Join(r.Name, subResourceSet.Name)
subResourceSet.Path = path.Join(r.Path, subResourceSet.Path)
subResourceSet.Values = *util.Merge(&r.Values, &subResourceSet.Values)
flattened = append(flattened, subResourceSet)
}
}
}
return flattened
}
func loadAllDefaultValues(c *Context) []ResourceSet {
updated := make([]ResourceSet, len(c.ResourceSets))
for i, rs := range c.ResourceSets {
merged := loadDefaultValues(&rs, c)
rs.Values = *merged
updated[i] = rs
}
return updated
}
// Loads and merges default values for a resource set collection from path/to/set/default.{json|yaml}.
// YAML takes precedence over JSON.
// Default values in resource set collections have the lowest priority possible.
func loadDefaultValues(rs *ResourceSet, c *Context) *map[string]interface{} {
var defaultVars map[string]interface{}
// Attempt to load YAML values
err := util.LoadJsonOrYaml(path.Join(c.BaseDir, rs.Path, "default.yaml"), &defaultVars)
if err == nil {
return util.Merge(&defaultVars, &rs.Values)
}
// Attempt to load JSON values
err = util.LoadJsonOrYaml(path.Join(c.BaseDir, rs.Path, "default.json"), &defaultVars)
if err == nil {
return util.Merge(&defaultVars, &rs.Values)
}
// The actual error is not inspected here. The reasoning for this is that in case of serious problems (e.g.
// permission issues with the folder / folder not existing) failure will occur a bit later anyways.
// Otherwise we'd have to differentiate between file-not-found-errors (no default values specified) and other
// errors here.
return &rs.Values
}
|
