pcaseiro
/
templatefile
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases 4 Wiki Activity

Complete rewrite of the bootstraper tool

This commit is contained in:
Philippe Caseiro 2022-06-15 17:29:45 +02:00
parent 5085bd4d69
commit 4479fa02e4
26 changed files with 1100 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -14,4 +14,4 @@
# Dependency directories (remove the comment below to include it)
# vendor/
bin/

6
Makefile
View File

@ -2,12 +2,14 @@ LINT_ARGS ?= ./...
DESTDIR ?= "/usr/local"
bin:
GOOS=linux go build -o bin/templater-linux cmd/templater.go
GOOS=linux CGO_ENABLED=0 go build -o bin/templater-linux cmd/templater/main.go
GOOS=linux CGO_ENABLED=0 go build -o bin/bootstraper-linux cmd/bootstraper/main.go
upx bin/templater-linux
upx bin/templaster-server
upx bin/bootstraper-linux
install:
cp bin/templater-linux $(DESTDIR)/bin/templater
cp bin/bootstraper-linux $(DESTDIR)/bin/bootstraper
uninstall:
rm $(DESTDIR)/bin/templater

10
api/main.go
View File

@ -1,9 +1,6 @@
package api
import (
"net/http"
"forge.cadoles.com/pcaseiro/templatefile/pkg/templater"
"github.com/gin-gonic/gin"
)
@ -13,6 +10,12 @@ type Template struct {
Config string
}
func Generate(c *gin.Context) {
return
}
/*
func Generate(c *gin.Context) {
var template Template
@ -42,3 +45,4 @@ func Generate(c *gin.Context) {
}
}
*/

26
cmd/bootstraper/main.go Normal file
View File

@ -0,0 +1,26 @@
package main
import (
"forge.cadoles.com/pcaseiro/templatefile/pkg/templater"
"github.com/alexflint/go-arg"
)
func main() {
var args struct {
Config string `arg:"-c,--config,env:CONFIG" help:"Configuration values file or directory path" default:"./data/config"`
TemplateDirectory string `arg:"-t,--template-dir,env:TEMPLATE_DIR" help:"Template directory path" default:"./data/templates"`
}
arg.MustParse(&args)
var hostConfig templater.TemplaterConfig
err := hostConfig.New(args.Config, args.TemplateDirectory)
if err != nil {
panic(err)
}
if err = hostConfig.ManageServices(); err != nil {
panic(err)
}
}

14
cmd/templater.go → cmd/templater/main.go
View File

@ -55,13 +55,13 @@ func main() {
config = []byte(args.Config)
}
result := ""
if templateType == "go" {
result = templater.ProcessGoTemplate(templateFile, config)
} else if templateType == "hcl" {
result = templater.ProcessHCLTemplate(templateFile, config)
} else {
panic(fmt.Errorf("Unsupported template type"))
var file templater.ConfigFile
file.Source = templateFile
file.TemplateType = templateType
result, err := file.ProcessTemplate(templateFile, config)
if err != nil {
panic(err)
}
if output == "stdout" {
fmt.Printf("%s", result)

127
data/config/test-services.json Normal file
View File

@ -0,0 +1,127 @@
{
"Name": "LokiStack",
"Global": {
"Vars": {},
"ConfigFiles": [
{
"destination": "/etc/hosts",
"source": "hosts.pktpl.hcl",
"mode": "600",
"owner": "root",
"group": "root"
}
]
},
"Services": {
"Loki": {
"ConfigFiles": [
{
"destination": "/etc/loki/loki-local-config.yaml",
"source": "loki-local-config.pktpl.hcl",
"mode": "600",
"owner": "loki",
"service": "loki",
"group": "grafana"
}
],
"Repositories": {
"Grafana": {
"type": "helm",
"name": "grafana",
"url": "https://grafana.github.io/helm-charts",
"enabled":true
},
"AlpineTesting": {
"type": "apk",
"name": "testing",
"url": "http://mirror.arvancloud.com/alpine/edge/testing",
"enabled": true
}
},
"Packages": {
"loki": {
"name": "loki",
"action": "install"
},
"promtail": {
"name": "loki-promtail",
"action": "install"
},
"loki-helm": {
"type": "helm",
"name": "loki",
"repo": "grafana/loki-simple-scalable"
}
},
"Vars": {
"AuthEnabled": false,
"User": "loki",
"Group": "grafana",
"HTTPPort": "3100",
"GRPCPort": "9096",
"AlertManagerURL": "http://localhost:9093",
"StorageRoot": "/var/loki",
"SharedStore": "filesystem",
"ObjectStore": "filesystem",
"LogLevel": "error",
"S3": {
"URL": "",
"BucketName": "",
"APIKey": "",
"APISecretKey": ""
}
},
"Daemons": {
"Loki": {
"name": "loki",
"enabled": true
}
},
"Users": {
"loki": {
"username": "loki",
"group": "grafana",
"home" : "/srv/loki",
"shell": "/bin/nologin"
}
}
},
"Grafana": {
"ConfigFiles": [
{
"destination": "/etc/grafana.ini",
"source": "grafana.ini.pktpl.hcl",
"mode": "700",
"owner": "grafana",
"group": "grafana"
}
],
"Packages": {
"grafana": {
"name": "grafana",
"action": "install"
}
},
"Vars": {
"AuthEnabled": false,
"User": "toto",
"Group": "grafana"
},
"Users": {
"grafana": {
"username": "grafana",
"group": "grafana",
"home": "/srv/grafana",
"shell": "/bin/nologin"
}
},
"Daemons": {
"grafana": {
"name": "grafana",
"type": "auto",
"enabled": true
}
}
}
}
}

61
data/config/test-servies-2.json Normal file
View File

@ -0,0 +1,61 @@
{
"Name": "OpenNebula",
"Services": {
"Global": {
"Vars": {
"EnableOpenNebula": true
},
"ConfigFiles": [
{
"destination": "/etc/hosts",
"source": "hosts.pktpl.hcl",
"mode": "600",
"owner": "root",
"group": "root"
}
]
},
"OpenNebula": {
"EnabledBy": { "var": "EnableOpenNebula", "value": true },
"ConfigFiles": [
{
"destination": "/etc/one/oned.conf",
"source": "loki-local-config.pktpl.hcl",
"mode": "600",
"owner": "loki",
"group": "grafana"
}
],
"Vars": {
"AuthEnabled": false,
"User": "loki",
"Group": "grafana",
"HTTPPort": "3100",
"GRPCPort": "9096",
"AlertManagerURL": "http://localhost:9093",
"StorageRoot": "/var/loki",
"SharedStore": "filesystem",
"ObjectStore": "filesystem",
"LogLevel": "error",
"S3": {
"URL": "",
"BucketName": "",
"APIKey": "",
"APISecretKey": ""
}
},
"Daemon": {
"name": "oned",
"enabled": true
},
"Users": {
"loki": {
"username": "oneadmin",
"group": "oneadmin",
"home" : "/var/lib/one",
"shell": "/bin/sh"
}
}
}
}
}

26
data/config/test.json
View File

@ -1,26 +0,0 @@
{
"Name": "loki",
"ConfigFiles": [
{
"destination": "/etc/loki/loki-local-config.yaml",
"source": "loki-local-config.pktpl.hcl",
"mod": "600"
}
],
"AuthEnabled": false,
"User": "loki",
"Group": "grafana",
"HTTPPort": "3100",
"GRPCPort": "9096",
"AlertManagerURL": "http://localhost:9093",
"StorageRoot": "/var/loki",
"SharedStore": "filesystem",
"ObjectStore": "filesystem",
"LogLevel": "error",
"S3": {
"URL": "",
"BucketName": "",
"APIKey": "",
"APISecretKey": ""
}
}

0
data/schema/templater.hcl Normal file
View File

0
data/schema/templater.json Normal file
View File

5
data/templates/grafana.ini.pktpl.hcl Normal file
View File

@ -0,0 +1,5 @@
%{ if AuthEnabled ~}
auth_enabled: true
%{ else }
auth_enabled: false
%{ endif }

0
data/templates/hosts.pktpl.hcl Normal file
View File

39
go.mod Normal file
View File

@ -0,0 +1,39 @@
module forge.cadoles.com/pcaseiro/templatefile
go 1.18
require (
github.com/alexflint/go-arg v1.4.3
github.com/gin-gonic/gin v1.8.1
github.com/hashicorp/hcl/v2 v2.11.1
github.com/imdario/mergo v0.3.13
github.com/mitchellh/mapstructure v1.5.0
github.com/zclconf/go-cty v1.10.0
gopkg.in/ini.v1 v1.66.6
)
require (
github.com/agext/levenshtein v1.2.1 // indirect
github.com/alexflint/go-scalar v1.1.0 // indirect
github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
github.com/gin-contrib/sse v0.1.0 // indirect
github.com/go-playground/locales v0.14.0 // indirect
github.com/go-playground/universal-translator v0.18.0 // indirect
github.com/go-playground/validator/v10 v10.10.0 // indirect
github.com/goccy/go-json v0.9.7 // indirect
github.com/google/go-cmp v0.5.8 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/leodido/go-urn v1.2.1 // indirect
github.com/mattn/go-isatty v0.0.14 // indirect
github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.0.1 // indirect
github.com/ugorji/go/codec v1.2.7 // indirect
golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 // indirect
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110 // indirect
golang.org/x/sys v0.0.0-20211019181941-9d821ace8654 // indirect
golang.org/x/text v0.3.6 // indirect
google.golang.org/protobuf v1.28.0 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
)

163
pkg/templater/files.go Normal file
View File

@ -0,0 +1,163 @@
package templater
import (
"log"
"path/filepath"
"strconv"
"bytes"
encjson "encoding/json"
"fmt"
"os"
"text/template"
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hclsyntax"
"github.com/zclconf/go-cty/cty"
ctyjson "github.com/zclconf/go-cty/cty/json"
"forge.cadoles.com/pcaseiro/templatefile/pkg/utils"
)
type ConfigFile struct {
Destination string `form:"destination" json:"destination"` // Where do we write the configuration file
Source string `form:"source" json:"source"` // The template file short name
TemplateType string `json:"type"` // The template file type (hcl or gotemplate)
Mode string `form:"mod" json:"mode"` // The configuration file final permissions (mode)
Owner string `json:"owner"` // The configuration file owner
Service string `json:"service"` // Service to restart after configuration generation
Group string `json:"group"` // The configuration file group owner
}
// Generate the configuration file from the template (hcl or json)
func (cf *ConfigFile) Generate(root string, templateDir string, values []byte) error {
var template string
dest := filepath.Join(root, cf.Destination)
source := filepath.Join(templateDir, cf.Source)
intMod, err := strconv.ParseInt(cf.Mode, 8, 64)
if err != nil {
return (err)
}
template, err = cf.ProcessTemplate(source, values)
if err != nil {
return fmt.Errorf("Process templates failed with error: %v", err)
}
dirname := filepath.Dir(dest)
err = os.MkdirAll(dirname, os.FileMode(int(0700)))
if err != nil {
return fmt.Errorf("Process templates failed with error: %v", err)
}
err = os.WriteFile(dest, []byte(template), os.FileMode(intMod))
if err != nil {
return fmt.Errorf("Process templates failed with error: %v", err)
}
log.Printf("\tFile %s generated\n", dest)
if cf.Service != "" {
sv := SystemService{
Name: cf.Service,
Enabled: true,
Type: "",
ToStart: true,
}
return sv.Restart()
}
return nil
}
// Process the template with the provided values
func (cf *ConfigFile) ProcessTemplate(source string, values []byte) (string, error) {
var result string
var err error
if cf.TemplateType == "hcl" {
// The template is an hcl template so we call processHCLTemplate
result, err = cf.processHCLTemplate(source, values)
if err != nil {
return "", fmt.Errorf("Process HCL template failed with error: %v", err)
}
} else if cf.TemplateType == "go" {
// The template is a go template so we call processGoTemplate
result, err = cf.processGoTemplate(source, values)
if err != nil {
return "", fmt.Errorf("Process GO template failed with error: %v", err)
}
}
return result, nil
}
// The actual template processing for Go templates
func (cf *ConfigFile) processGoTemplate(file string, configValues []byte) (string, error) {
// The JSON configuration
var confData map[string]interface{}
var res bytes.Buffer
err := encjson.Unmarshal(configValues, &confData)
utils.CheckErr(err)
// Read the template
data, err := os.ReadFile(file)
utils.CheckErr(err)
tpl, err := template.New("conf").Parse(string(data))
utils.CheckErr(err)
utils.CheckErr(tpl.Execute(&res, confData["Config"]))
return res.String(), nil
}
// The actual template processing for HCL templates
func (cf *ConfigFile) processHCLTemplate(file string, config []byte) (string, error) {
fct, err := os.ReadFile(file)
utils.CheckErr(err)
expr, diags := hclsyntax.ParseTemplate(fct, file, hcl.Pos{Line: 0, Column: 1})
utils.CheckDiags(diags)
// Retrieve values from JSON
var varsVal cty.Value
ctyType, err := ctyjson.ImpliedType(config)
if err != nil {
return "", err
/* Maybe one day
cexpr, diags := hclsyntax.ParseExpression(config, "", hcl.Pos{Line: 0, Column: 1})
if diags.HasErrors() {
panic(diags.Error())
}
varsVal, diags = cexpr.Value(&hcl.EvalContext{})
fmt.Println(cexpr.Variables())
checkDiags(diags)
*/
} else {
varsVal, err = ctyjson.Unmarshal(config, ctyType)
utils.CheckErr(err)
}
ctx := &hcl.EvalContext{
Variables: varsVal.AsValueMap(),
}
for n := range ctx.Variables {
if !hclsyntax.ValidIdentifier(n) {
panic(fmt.Errorf("invalid template variable name %q: must start with a letter, followed by zero or more letters, digits, and underscores", n))
}
}
for _, traversal := range expr.Variables() {
root := traversal.RootName()
if _, ok := ctx.Variables[root]; !ok {
panic(fmt.Errorf("vars map does not contain key %q, referenced at %s", root, traversal[0].SourceRange()))
}
}
val, diags := expr.Value(ctx)
if diags.HasErrors() {
panic(diags.Error())
}
return val.AsString(), nil
}

132
pkg/templater/main.go
View File

@ -1,89 +1,85 @@
package templater
import (
"bytes"
encjson "encoding/json"
"fmt"
"io/ioutil"
"os"
"text/template"
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hclsyntax"
"github.com/zclconf/go-cty/cty"
ctyjson "github.com/zclconf/go-cty/cty/json"
"forge.cadoles.com/pcaseiro/templatefile/pkg/utils"
"github.com/imdario/mergo"
)
func ProcessGoTemplate(file string, config []byte) string {
var CacheFilePath = "/var/cache/templater.db"
// The JSON configuration
var confData map[string]interface{}
var res bytes.Buffer
err := encjson.Unmarshal(config, &confData)
utils.CheckErr(err)
// Read the template
data, err := os.ReadFile(file)
utils.CheckErr(err)
tpl, err := template.New("conf").Parse(string(data))
utils.CheckErr(err)
utils.CheckErr(tpl.Execute(&res, confData))
return res.String()
type TemplaterConfig struct {
Name string `json:"Name"`
TemplateDirectory string `json:"TemplateDirectory"`
Services map[string]Service `json:"Services"`
GlobalService Service `json:"Global"`
}
func ProcessHCLTemplate(file string, config []byte) string {
fct, err := os.ReadFile(file)
utils.CheckErr(err)
expr, diags := hclsyntax.ParseTemplate(fct, file, hcl.Pos{Line: 0, Column: 1})
utils.CheckDiags(diags)
// Retrieve values from JSON
var varsVal cty.Value
ctyType, err := ctyjson.ImpliedType(config)
func (tc *TemplaterConfig) loadCache() error {
// Load globals from cache
var cache Service
err := Load(CacheFilePath, &cache)
if err != nil {
panic(err)
/* Maybe one day
cexpr, diags := hclsyntax.ParseExpression(config, "", hcl.Pos{Line: 0, Column: 1})
if diags.HasErrors() {
panic(diags.Error())
fmt.Printf("Warning: No globals to load\n")
}
err = mergo.Merge(&tc.GlobalService, cache)
if err != nil {
return err
}
return nil
}
func (tc *TemplaterConfig) New(confpath string, templateDir string) error {
// Load stored globals if needed
lerr := tc.loadCache()
if lerr != nil {
return lerr
}
// Check if the configuration path is a Directory or a file
fileInfo, err := os.Stat(confpath)
if err != nil {
return err
}
if fileInfo.IsDir() {
// The conf path is a directory we load all the files and merge data
files, err := ioutil.ReadDir(confpath)
if err != nil {
return fmt.Errorf("Templater configuration load failed with error: %v", err)
}
for _, file := range files {
fname := fmt.Sprintf("%s/%s", confpath, file.Name())
var ntc TemplaterConfig
err := Load(fname, &ntc)
if err != nil {
return fmt.Errorf("Templater configuration load failed with error: %v", err)
}
err = mergo.Merge(tc, ntc)
if err != nil {
return fmt.Errorf("Templater configuration load failed with error: %v", err)
}
}
varsVal, diags = cexpr.Value(&hcl.EvalContext{})
fmt.Println(cexpr.Variables())
checkDiags(diags)
*/
} else {
varsVal, err = ctyjson.Unmarshal(config, ctyType)
utils.CheckErr(err)
}
ctx := &hcl.EvalContext{
Variables: varsVal.AsValueMap(),
}
for n := range ctx.Variables {
if !hclsyntax.ValidIdentifier(n) {
panic(fmt.Errorf("invalid template variable name %q: must start with a letter, followed by zero or more letters, digits, and underscores", n))
// The conf path is a file we only load this file (of course)
err = Load(confpath, tc)
if err != nil {
return fmt.Errorf("Confiuration read failed with error: %v", err)
}
}
for _, traversal := range expr.Variables() {
root := traversal.RootName()
if _, ok := ctx.Variables[root]; !ok {
panic(fmt.Errorf("vars map does not contain key %q, referenced at %s", root, traversal[0].SourceRange()))
}
tc.TemplateDirectory = templateDir
return nil
}
val, diags := expr.Value(ctx)
if diags.HasErrors() {
panic(diags.Error())
func (tc *TemplaterConfig) ManageServices() error {
for _, svr := range tc.Services {
if err := svr.Manage(tc.TemplateDirectory); err != nil {
return err
}
return val.AsString()
}
return nil
}

74
pkg/templater/packages.go Normal file
View File

@ -0,0 +1,74 @@
package templater
import (
"fmt"
"log"
"runtime"
"forge.cadoles.com/pcaseiro/templatefile/pkg/utils"
)
type SystemPackage struct {
Name string `json:"name"`
Type string `json:"type"`
Action string `json:"action"`
OS string `json:"os"`
Distribution string `json:"distribution"`
}
func (p *SystemPackage) SetDistribution() error {
OSConfig, err := utils.ReadOSRelease()
if err != nil {
return err
}
p.Distribution = OSConfig["ID_LIKE"]
return nil
}
func (p *SystemPackage) SetOS() error {
p.OS = runtime.GOOS
return nil
}
func (p *SystemPackage) Manage() error {
var pkErr error
var stdErr []byte
if p.OS == "" {
if err := p.SetOS(); err != nil {
return err
}
}
if p.Distribution == "" {
if err := p.SetDistribution(); err != nil {
return err
}
}
log.Printf("\tInstalling %s package\n", p.Name)
switch os := p.Distribution; os {
case "debian", "ubuntu":
_, stdErr, pkErr = utils.RunSystemCommand("apt", "install", "-y", p.Name)
case "alpine":
_, stdErr, pkErr = utils.RunSystemCommand("apk", "add", p.Name)
case "redhat":
_, stdErr, pkErr = utils.RunSystemCommand("yum", "install", "-y", p.Name)
case "arch":
_, stdErr, pkErr = utils.RunSystemCommand("pacman", "-Suy", p.Name)
default:
pkErr = fmt.Errorf("Unsupported OS %s [%s]", p.OS, stdErr)
}
if pkErr != nil {
var msg string
if len(stdErr) != 0 {
msg = string(stdErr)
} else {
msg = pkErr.Error()
}
return fmt.Errorf("Package %s, os %s, failed with error: %v", p.Name, p.OS, msg)
}
return nil
}

51
pkg/templater/persist.go Normal file
View File

@ -0,0 +1,51 @@
package templater
import (
"bytes"
"encoding/json"
"fmt"
"io"
"os"
"sync"
)
var lock sync.Mutex
func marshal(v interface{}) (io.Reader, error) {
b, err := json.MarshalIndent(v, "", "\t")
if err != nil {
return nil, err
}
return bytes.NewReader(b), nil
}
func unmarshal(r io.Reader, v interface{}) error {
return json.NewDecoder(r).Decode(v)
}
func Save(path string, v interface{}) error {
lock.Lock()
defer lock.Unlock()
f, err := os.Create(path)
if err != nil {
return fmt.Errorf("Saving Templater configuration failed with error : %v", err)
}
defer f.Close()
r, err := marshal(v)
if err != nil {
return err
}
_, err = io.Copy(f, r)
return err
}
func Load(path string, v interface{}) error {
lock.Lock()
defer lock.Unlock()
f, err := os.Open(path)
if err != nil {
return err
}
defer f.Close()
return unmarshal(f, v)
}

100
pkg/templater/repo-apk.go Normal file
View File

@ -0,0 +1,100 @@
package templater
import (
"bufio"
"fmt"
"io/ioutil"
"log"
"os"
"strings"
"forge.cadoles.com/pcaseiro/templatefile/pkg/utils"
)
var APKConfigFile = "/etc/apk/repositories"
type APKRepository struct {
Repository
}
func (hr *APKRepository) urlIsPresent() (bool, error) {
f, err := os.Open(APKConfigFile)
if err != nil {
return false, err
}
defer f.Close()
// Splits on newlines by default.
scanner := bufio.NewScanner(f)
line := 1
for scanner.Scan() {
if strings.Contains(scanner.Text(), hr.URL) {
log.Printf("Repository %s already present\n", hr.Name)
return true, nil
}
line++
}
if err := scanner.Err(); err != nil {
return false, err
}
return false, nil
}
func (hr *APKRepository) Add() error {
URLIsPresent, err := hr.urlIsPresent()
if err != nil {
return err
}
if URLIsPresent {
return nil
} else {
data := fmt.Sprintf("%s\n", hr.URL)
file, err := os.OpenFile(APKConfigFile, os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
return err
}
defer file.Close()
if _, err := file.WriteString(data); err != nil {
return err
} else {
log.Printf("Repository %s added\n", hr.Name)
}
return nil
}
}
func (hr *APKRepository) Update() error {
if _, stdErr, err := utils.RunSystemCommand("apk", "update"); err != nil {
return fmt.Errorf("%s [%s]", stdErr, err)
}
return nil
}
func (hr *APKRepository) Delete() error {
fileBytes, err := ioutil.ReadFile("/etc/apk/repositories")
if err != nil {
return err
}
lines := strings.Split(string(fileBytes), "\n")
for _, line := range lines {
fmt.Println(line)
}
return nil
}
func (hr *APKRepository) Manage() error {
if hr.Enabled {
if err := hr.Add(); err != nil {
return err
}
return hr.Update()
} else {
return hr.Delete()
}
}

43
pkg/templater/repo-deb.go Normal file
View File

@ -0,0 +1,43 @@
package templater
import (
"fmt"
"os"
"forge.cadoles.com/pcaseiro/templatefile/pkg/utils"
)
type DebRepository struct {
Repository
}
func (hr *DebRepository) Add() error {
//deb http://fr.archive.ubuntu.com/ubuntu/ focal main restricted
data := fmt.Sprintf("deb %s", hr.URL)
if err := os.WriteFile("/etc/apt/source.list.d", []byte(data), 0600); err != nil {
return err
}
return nil
}
func (hr *DebRepository) Update() error {
if _, stdErr, err := utils.RunSystemCommand("apt", "update", "-y"); err != nil {
return fmt.Errorf("%s [%s]", stdErr, err)
}
return nil
}
func (hr *DebRepository) Delete() error {
//TODO
return nil
}
func (hr *DebRepository) Manage() error {
if hr.Enabled {
return hr.Add()
} else {
return hr.Delete()
}
}

25
pkg/templater/repo-helm.go Normal file
View File

@ -0,0 +1,25 @@
package templater
type HelmRepository struct {
Repository
}
func (hr *HelmRepository) Add() error {
return nil
}
func (hr *HelmRepository) Update() error {
return nil
}
func (hr *HelmRepository) Delete() error {
return nil
}
func (hr *HelmRepository) Manage() error {
if hr.Enabled {
return hr.Add()
} else {
return hr.Delete()
}
}

17
pkg/templater/repo.go Normal file
View File

@ -0,0 +1,17 @@
package templater
type PackageRepository interface {
Manage() error
Update() error
Add() error
Delete() error
}
type Repository struct {
Actions PackageRepository
Name string `json:"name"`
Type string `json:"type"`
URL string `json:"url"`
Enabled bool `json:"enabled"`
}

99
pkg/templater/services.go Normal file
View File

@ -0,0 +1,99 @@
package templater
import (
"encoding/json"
"fmt"
"log"
"path/filepath"
)
type Service struct {
ConfigFiles []ConfigFile `json:"ConfigFiles"`
Vars map[string]interface{} `json:"Vars"`
Daemons map[string]SystemService `json:"Daemons"`
Users map[string]SystemUser `json:"Users"`
Repos map[string]Repository `json:"Repositories"`
Packages map[string]SystemPackage `json:"Packages"`
}
func (s *Service) manageRepos(repos map[string]Repository) error {
for _, repo := range s.Repos {
if repo.Type == "helm" {
rp := HelmRepository{repo}
if err := rp.Manage(); err != nil {
return err
}
}
if repo.Type == "apk" {
rp := APKRepository{repo}
if err := rp.Manage(); err != nil {
return err
}
}
if repo.Type == "deb" {
rp := DebRepository{}
if err := rp.Manage(); err != nil {
return err
}
}
}
return nil
}
func (s *Service) Manage(templateDir string) error {
// Manage packages repositories
err := s.manageRepos(s.Repos)
if err != nil {
return err
}
// Manage system packages
log.Printf("Installing packages:")
for _, pack := range s.Packages {
err := pack.Manage()
if err != nil {
return err
}
log.Printf("\tPackage %s installed\n", pack.Name)
}
log.Printf("Generating configuration files\n")
err = processConfigFiles(s.ConfigFiles, s.Vars, templateDir)
if err != nil {
return fmt.Errorf("ProcessingTemplatesFailed with error: %v", err)
}
log.Printf("Managing services:\n")
for _, daemon := range s.Daemons {
err = daemon.Manage()
if err != nil {
return fmt.Errorf("Error managing service daemons: %v", err)
}
}
return nil
}
func processConfigFiles(tpls []ConfigFile, variables map[string]interface{}, templateDir string) error {
values, err := json.Marshal(variables)
if err != nil {
return fmt.Errorf("Error unmarshaling values on template process; %v", err)
}
for _, tpl := range tpls {
fileExt := filepath.Ext(tpl.Source)
if fileExt == ".hcl" {
tpl.TemplateType = "hcl"
} else if fileExt == ".tpl" {
tpl.TemplateType = "go"
} else {
return fmt.Errorf("Unsupported file extention %s, templates extensions have to be '.hcl' or '.tpl'", fileExt)
}
if err := tpl.Generate("/tmp/test", templateDir, values); err != nil {
return fmt.Errorf("Template %s generation failed with error %v", tpl.Source, err)
}
}
return nil
}

132
pkg/templater/system_services.go Normal file
View File

@ -0,0 +1,132 @@
package templater
import (
"fmt"
"log"
"os"
"forge.cadoles.com/pcaseiro/templatefile/pkg/utils"
)
type SystemService struct {
Name string `json:"name"`
Enabled bool `json:"enabled"`
Type string `json:"type"`
ToStart bool `json:"start"`
}
func (sys *SystemService) SetType() {
systemdRunDirectory := "/run/systemd/system"
openRcBinaryFile := "/sbin/openrc"
// Check if the configuration path is a Directory or a file
fileInfo, err := os.Stat(systemdRunDirectory)
if err == nil {
if fileInfo.IsDir() {
sys.Type = "systemd"
}
}
fileInfo, err = os.Stat(openRcBinaryFile)
if err == nil {
if fileInfo.IsDir() {
return
}
sys.Type = "openrc"
}
}
func (sys *SystemService) Action() error {
if sys.ToStart {
return sys.Start()
}
return nil
}
func (sys *SystemService) Manage() error {
// By default if the property sys.ToStart is empty
if sys.Type == "" || sys.Type == "auto" {
sys.SetType()
}
if sys.Enabled {
err := sys.Enable()
if err != nil {
return err
}
if err = sys.Action(); err != nil {
return err
}
} else {
log.Printf("\nNothing to do for daemon %s\n", sys.Name)
}
return nil
}
func (sys *SystemService) Start() error {
log.Printf("\tStarting system service : %s\n", sys.Name)
if sys.Type == "systemd" {
_, stdErr, err := utils.RunSystemCommand("systemctl", "start", sys.Name)
if err != nil {
return fmt.Errorf("System service %s \n * Start error:\n - %s", sys.Name, stdErr)
}
} else if sys.Type == "openrc" {
_, stdErr, err := utils.RunSystemCommand("service", sys.Name, "stop")
if err != nil {
return fmt.Errorf("System service %s \n * Enable error:\n - %s", sys.Name, stdErr)
}
} else {
return fmt.Errorf("Unsupported service type %s for service %s", sys.Type, sys.Name)
}
return nil
}
func (sys *SystemService) Stop() error {
log.Printf("\tStopping system service : %s\n", sys.Name)
if sys.Type == "systemd" {
_, stdErr, err := utils.RunSystemCommand("systemctl", "stop", sys.Name)
if err != nil {
return fmt.Errorf("System service %s \n * Stop error:\n - %s", sys.Name, stdErr)
}
} else if sys.Type == "openrc" {
_, stdErr, err := utils.RunSystemCommand("service", sys.Name, "stop")
if err != nil {
return fmt.Errorf("System service %s \n * Enable error:\n - %s", sys.Name, stdErr)
}
} else {
return fmt.Errorf("Unsupported service type %s for service %s", sys.Type, sys.Name)
}
return nil
}
func (sys *SystemService) Restart() error {
if sys.Type == "" || sys.Type == "auto" {
sys.SetType()
}
if err := sys.Stop(); err != nil {
return err
}
if err := sys.Start(); err != nil {
return err
}
return nil
}
func (sys *SystemService) Enable() error {
if sys.Type == "systemd" {
_, stdErr, err := utils.RunSystemCommand("systemctl", "enable", sys.Name)
if err != nil {
return fmt.Errorf("System service %s \n * Enable error:\n - %s", sys.Name, stdErr)
}
log.Printf("\tSystemd service %s enabled", sys.Name)
} else if sys.Type == "openrc" {
_, stdErr, err := utils.RunSystemCommand("rc-update", "add", sys.Name, "default")
if err != nil {
return fmt.Errorf("System service %s \n * Enable error:\n - %s", sys.Name, stdErr)
}
log.Printf("\tOpenRC service %s enabled", sys.Name)
} else {
return fmt.Errorf("Unsupported service type %s for service %s", sys.Type, sys.Name)
}
return nil
}

8
pkg/templater/system_users.go Normal file
View File

@ -0,0 +1,8 @@
package templater
type SystemUser struct {
UserName string `json:"username"`
Group string `json:"group"`
Home string `json:"home"`
Shell string `json:"shell"`
}

15
pkg/utils/main.go
View File

@ -1,6 +1,9 @@
package utils
import (
"bytes"
"os/exec"
"github.com/hashicorp/hcl/v2"
)
@ -15,3 +18,15 @@ func CheckDiags(diag hcl.Diagnostics) {
panic(diag.Error())
}
}
// Execute a system command ...
func RunSystemCommand(name string, arg ...string) ([]byte, []byte, error) {
var stdOut bytes.Buffer
var stdErr bytes.Buffer
cmd := exec.Command(name, arg...)
cmd.Stderr = &stdErr
cmd.Stdout = &stdOut
err := cmd.Run()
return stdOut.Bytes(), stdErr.Bytes(), err
}

27
pkg/utils/os.go Normal file
View File

@ -0,0 +1,27 @@
package utils
import (
"fmt"
ini "gopkg.in/ini.v1"
)
var osReleaseFile = "/etc/os-release"
func ReadOSRelease() (map[string]string, error) {
cfg, err := ini.Load(osReleaseFile)
if err != nil {
return nil, fmt.Errorf("Fail to read file: %v ", err)
}
ConfigParams := make(map[string]string)
ConfigParams["ID"] = cfg.Section("").Key("ID").String()
idLike := cfg.Section("").Key("ID_LIKE").String()
if idLike != "" {
ConfigParams["ID_LIKE"] = idLike
} else {
ConfigParams["ID_LIKE"] = ConfigParams["ID"]
}
return ConfigParams, nil
}