361 lines
8.3 KiB
Go
361 lines
8.3 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha1"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"path"
|
|
"reflect"
|
|
"strings"
|
|
|
|
yaml "gopkg.in/yaml.v2"
|
|
|
|
"novit.tech/direktil/pkg/config"
|
|
|
|
"novit.tech/direktil/local-server/pkg/clustersconfig"
|
|
)
|
|
|
|
type renderContext struct {
|
|
Labels map[string]string
|
|
Annotations map[string]string
|
|
|
|
Host *clustersconfig.Host
|
|
Group *clustersconfig.Group
|
|
Cluster *clustersconfig.Cluster
|
|
Vars map[string]interface{}
|
|
|
|
BootstrapConfigTemplate *clustersconfig.Template
|
|
ConfigTemplate *clustersconfig.Template
|
|
StaticPodsTemplate *clustersconfig.Template
|
|
|
|
clusterConfig *clustersconfig.Config
|
|
}
|
|
|
|
func newRenderContext(host *clustersconfig.Host, cfg *clustersconfig.Config) (ctx *renderContext, err error) {
|
|
cluster := cfg.Cluster(host.Cluster)
|
|
if cluster == nil {
|
|
err = fmt.Errorf("no cluster named %q", host.Cluster)
|
|
return
|
|
}
|
|
|
|
group := cfg.Group(host.Group)
|
|
if group == nil {
|
|
err = fmt.Errorf("no group named %q", host.Group)
|
|
return
|
|
}
|
|
|
|
vars := make(map[string]interface{})
|
|
|
|
for _, oVars := range []map[string]interface{}{
|
|
cluster.Vars,
|
|
group.Vars,
|
|
host.Vars,
|
|
} {
|
|
mapMerge(vars, oVars)
|
|
}
|
|
|
|
return &renderContext{
|
|
Labels: mergeLabels(cluster.Labels, group.Labels, host.Labels),
|
|
Annotations: mergeLabels(cluster.Annotations, group.Annotations, host.Annotations),
|
|
|
|
Host: host,
|
|
Group: group,
|
|
Cluster: cluster,
|
|
Vars: vars,
|
|
|
|
BootstrapConfigTemplate: cfg.ConfigTemplate(group.BootstrapConfig),
|
|
ConfigTemplate: cfg.ConfigTemplate(group.Config),
|
|
StaticPodsTemplate: cfg.StaticPodsTemplate(group.StaticPods),
|
|
|
|
clusterConfig: cfg,
|
|
}, nil
|
|
}
|
|
|
|
func mergeLabels(sources ...map[string]string) map[string]string {
|
|
ret := map[string]string{}
|
|
|
|
for _, src := range sources {
|
|
for k, v := range src {
|
|
ret[k] = v
|
|
}
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
func mapMerge(target, source map[string]interface{}) {
|
|
for k, v := range source {
|
|
target[k] = genericMerge(target[k], v)
|
|
}
|
|
}
|
|
|
|
func genericMerge(target, source interface{}) (result interface{}) {
|
|
srcV := reflect.ValueOf(source)
|
|
tgtV := reflect.ValueOf(target)
|
|
|
|
if srcV.Kind() == reflect.Map && tgtV.Kind() == reflect.Map {
|
|
// XXX maybe more specific later
|
|
result = map[interface{}]interface{}{}
|
|
resultV := reflect.ValueOf(result)
|
|
|
|
tgtIt := tgtV.MapRange()
|
|
for tgtIt.Next() {
|
|
sv := srcV.MapIndex(tgtIt.Key())
|
|
if sv.Kind() == 0 {
|
|
resultV.SetMapIndex(tgtIt.Key(), tgtIt.Value())
|
|
continue
|
|
}
|
|
|
|
merged := genericMerge(tgtIt.Value().Interface(), sv.Interface())
|
|
resultV.SetMapIndex(tgtIt.Key(), reflect.ValueOf(merged))
|
|
}
|
|
|
|
srcIt := srcV.MapRange()
|
|
for srcIt.Next() {
|
|
if resultV.MapIndex(srcIt.Key()).Kind() != 0 {
|
|
continue // already done
|
|
}
|
|
|
|
resultV.SetMapIndex(srcIt.Key(), srcIt.Value())
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
return source
|
|
}
|
|
|
|
func (ctx *renderContext) Name() string {
|
|
switch {
|
|
case ctx.Host != nil:
|
|
return "host:" + ctx.Host.Name
|
|
case ctx.Group != nil:
|
|
return "group:" + ctx.Group.Name
|
|
case ctx.Cluster != nil:
|
|
return "cluster:" + ctx.Cluster.Name
|
|
default:
|
|
return "unknown"
|
|
}
|
|
}
|
|
|
|
func (ctx *renderContext) BootstrapConfig() string {
|
|
if ctx.BootstrapConfigTemplate == nil {
|
|
log.Fatalf("no such (bootstrap) config: %q", ctx.Group.BootstrapConfig)
|
|
}
|
|
return ctx.renderConfig(ctx.BootstrapConfigTemplate)
|
|
}
|
|
|
|
func (ctx *renderContext) Config() string {
|
|
if ctx.ConfigTemplate == nil {
|
|
log.Fatalf("no such config: %q", ctx.Group.Config)
|
|
}
|
|
return ctx.renderConfig(ctx.ConfigTemplate)
|
|
}
|
|
|
|
func (ctx *renderContext) renderConfig(configTemplate *clustersconfig.Template) string {
|
|
buf := new(strings.Builder)
|
|
ctx.renderConfigTo(buf, configTemplate)
|
|
return buf.String()
|
|
}
|
|
|
|
func (ctx *renderContext) renderConfigTo(buf io.Writer, configTemplate *clustersconfig.Template) {
|
|
ctxName := ctx.Name()
|
|
|
|
ctxMap := ctx.asMap()
|
|
|
|
templateFuncs := ctx.templateFuncs(ctxMap)
|
|
|
|
render := func(what string, t *clustersconfig.Template) (s string, err error) {
|
|
buf := &bytes.Buffer{}
|
|
err = t.Execute(ctxName, what, buf, ctxMap, templateFuncs)
|
|
if err != nil {
|
|
log.Printf("host %s: failed to render %s [%q]: %v", ctx.Host.Name, what, t.Name, err)
|
|
return
|
|
}
|
|
|
|
s = buf.String()
|
|
return
|
|
}
|
|
|
|
extraFuncs := ctx.templateFuncs(ctxMap)
|
|
|
|
extraFuncs["static_pods"] = func() (string, error) {
|
|
name := ctx.Group.StaticPods
|
|
if len(name) == 0 {
|
|
return "", fmt.Errorf("group %q has no static pods defined", ctx.Group.Name)
|
|
}
|
|
|
|
t := ctx.clusterConfig.StaticPodsTemplate(name)
|
|
if t == nil {
|
|
return "", fmt.Errorf("no static pods template named %q", name)
|
|
}
|
|
|
|
return render("static-pods", t)
|
|
}
|
|
|
|
extraFuncs["bootstrap_pods_files"] = func(dir string) (string, error) {
|
|
namePods := ctx.renderBootstrapPods()
|
|
|
|
defs := make([]config.FileDef, 0)
|
|
|
|
for _, namePod := range namePods {
|
|
name := namePod.Namespace + "_" + namePod.Name
|
|
|
|
ba, err := yaml.Marshal(namePod.Pod)
|
|
if err != nil {
|
|
return "", fmt.Errorf("bootstrap pod %s: failed to render: %v", name, err)
|
|
}
|
|
|
|
defs = append(defs, config.FileDef{
|
|
Path: path.Join(dir, name+".yaml"),
|
|
Mode: 0640,
|
|
Content: string(ba),
|
|
})
|
|
}
|
|
|
|
ba, err := yaml.Marshal(defs)
|
|
return string(ba), err
|
|
}
|
|
|
|
extraFuncs["machine_id"] = func() string {
|
|
ba := sha1.Sum([]byte(ctx.Cluster.Name + "/" + ctx.Host.Name)) // TODO: check semantics of machine-id
|
|
return hex.EncodeToString(ba[:])
|
|
}
|
|
|
|
if err := configTemplate.Execute(ctxName, "config", buf, ctxMap, extraFuncs); err != nil {
|
|
log.Fatalf("failed to render config %q for host %q: %v", ctx.Group.Config, ctx.Host.Name, err)
|
|
}
|
|
}
|
|
|
|
func (ctx *renderContext) StaticPods() (ba []byte, err error) {
|
|
if ctx.StaticPodsTemplate == nil {
|
|
log.Fatalf("no such static-pods: %q", ctx.Group.StaticPods)
|
|
}
|
|
|
|
ctxMap := ctx.asMap()
|
|
|
|
buf := bytes.NewBuffer(make([]byte, 0, 4096))
|
|
if err = ctx.StaticPodsTemplate.Execute(ctx.Name(), "static-pods", buf, ctxMap, ctx.templateFuncs(ctxMap)); err != nil {
|
|
return
|
|
}
|
|
|
|
ba = buf.Bytes()
|
|
return
|
|
}
|
|
|
|
func (ctx *renderContext) templateFuncs(ctxMap map[string]interface{}) map[string]interface{} {
|
|
cluster := ctx.Cluster.Name
|
|
|
|
getKeyCert := func(name, funcName string) (s string, err error) {
|
|
req := ctx.clusterConfig.CSR(name)
|
|
if req == nil {
|
|
err = fmt.Errorf("no certificate request named %q", name)
|
|
return
|
|
}
|
|
|
|
if req.CA == "" {
|
|
err = fmt.Errorf("CA not defined in req %q", name)
|
|
return
|
|
}
|
|
|
|
buf := &bytes.Buffer{}
|
|
err = req.Execute(ctx.Name(), "req:"+name, buf, ctxMap, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
key := name
|
|
if req.PerHost {
|
|
key += "/" + ctx.Host.Name
|
|
}
|
|
|
|
if funcName == "tls_dir" {
|
|
// needs the dir name
|
|
dir := "/etc/tls/" + name
|
|
|
|
s = fmt.Sprintf("{{ %s %q %q %q %q %q %q %q }}", funcName,
|
|
dir, cluster, req.CA, key, req.Profile, req.Label, buf.String())
|
|
|
|
} else {
|
|
s = fmt.Sprintf("{{ %s %q %q %q %q %q %q }}", funcName,
|
|
cluster, req.CA, key, req.Profile, req.Label, buf.String())
|
|
}
|
|
return
|
|
}
|
|
|
|
funcs := clusterFuncs(ctx.Cluster)
|
|
for k, v := range map[string]interface{}{
|
|
"tls_key": func(name string) (string, error) {
|
|
return getKeyCert(name, "tls_key")
|
|
},
|
|
|
|
"tls_crt": func(name string) (s string, err error) {
|
|
return getKeyCert(name, "tls_crt")
|
|
},
|
|
|
|
"tls_dir": func(name string) (s string, err error) {
|
|
return getKeyCert(name, "tls_dir")
|
|
},
|
|
|
|
"ssh_host_keys": func(dir string) (s string) {
|
|
return fmt.Sprintf("{{ ssh_host_keys %q %q %q}}",
|
|
dir, cluster, ctx.Host.Name)
|
|
},
|
|
|
|
"hosts_of_group": func() (hosts []interface{}) {
|
|
hosts = make([]interface{}, 0)
|
|
|
|
for _, host := range ctx.clusterConfig.Hosts {
|
|
if host.Group != ctx.Host.Group {
|
|
continue
|
|
}
|
|
|
|
hosts = append(hosts, asMap(host))
|
|
}
|
|
|
|
return hosts
|
|
},
|
|
|
|
"hosts_of_group_count": func() (count int) {
|
|
for _, host := range ctx.clusterConfig.Hosts {
|
|
if host.Group == ctx.Host.Group {
|
|
count++
|
|
}
|
|
}
|
|
return
|
|
},
|
|
} {
|
|
funcs[k] = v
|
|
}
|
|
return funcs
|
|
}
|
|
|
|
func (ctx *renderContext) asMap() map[string]interface{} {
|
|
result := asMap(ctx)
|
|
|
|
// also expand cluster:
|
|
cluster := result["cluster"].(map[interface{}]interface{})
|
|
cluster["kubernetes_svc_ip"] = ctx.Cluster.KubernetesSvcIP().String()
|
|
cluster["dns_svc_ip"] = ctx.Cluster.DNSSvcIP().String()
|
|
|
|
return result
|
|
}
|
|
|
|
func asMap(v interface{}) map[string]interface{} {
|
|
ba, err := yaml.Marshal(v)
|
|
if err != nil {
|
|
panic(err) // shouldn't happen
|
|
}
|
|
|
|
result := make(map[string]interface{})
|
|
|
|
if err := yaml.Unmarshal(ba, result); err != nil {
|
|
panic(err) // shouldn't happen
|
|
}
|
|
|
|
return result
|
|
}
|