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
|
package context
import (
"path"
"github.com/polydawn/meep"
"github.com/tazjin/kontemplate/util"
)
type ResourceSet struct {
// Name of the resource set. This can be used in include/exclude statements during kontemplate runs.
Name string `json:"name"`
// Path to the folder containing the files for this resource set. This defaults to the value of the 'name' field
// if unset.
Path string `json:"path"`
// Values to include when interpolating resources from this resource set.
Values map[string]interface{} `json:"values"`
// Nested resource sets to include
Include []ResourceSet `json:"include"`
// Parent resource set for flattened resource sets. Should not be manually specified.
Parent string
}
type Context struct {
// The name of the kubectl context
Name string `json:"context"`
// Global variables that should be accessible by all resource sets
Global map[string]interface{} `json:"global"`
// File names of YAML or JSON files including extra variables that should be globally accessible
VariableImports []string `json:"import"`
// The resource sets to include in this context
ResourceSets []ResourceSet `json:"include"`
// This field represents the absolute path to the context base directory and should not be manually specified.
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
}
|
