templates: add built-in functions to the engine

This patch adds several useful built-in functions
to the template engine, which can be used in templates.

* `port` generates a port
* `atoi` converts string to int
* `replicasets` generates names for replicasets and instances

Part of #489

Author: askalt

cli/templates/internal/engines/builtin_funcs.go

@@ -0,0 +1,62 @@
+package engines
+
+import (
+	"fmt"
+)
+
+// genState describes template generation state.
+type genState struct {
+	port int
+}
+
+// newGenState creates genState.
+func newGenState() *genState {
+	return &genState{port: 3301}
+}
+
+// genPort generates port.
+func (state *genState) genPort() int {
+	ret := state.port
+	state.port++
+	return ret
+}
+
+// replicaset describes generated replicaset information.
+type replicaset struct {
+	Name      string
+	InstNames []string
+}
+
+const (
+	maxReplicasetsNumber = 1000
+	maxReplicasetSize    = 32
+)
+
+// genReplicasets generates replicasets bunch.
+func genReplicasets(
+	baseName string,
+	replicasetsNumber int,
+	replicasetSize int) ([]replicaset, error) {
+	if replicasetsNumber <= 0 || replicasetsNumber > maxReplicasetsNumber {
+		return nil, fmt.Errorf("replicasetsNumber must be in [%d, %d]", 0, maxReplicasetsNumber)
+	}
+	if replicasetSize <= 0 || replicasetSize > maxReplicasetSize {
+		return nil, fmt.Errorf("replicasetSize must be in [%d, %d]", 0, maxReplicasetSize)
+	}
+
+	replicasets := make([]replicaset, replicasetsNumber)
+	for i := range replicasets {
+		replicasetName := fmt.Sprintf("%s-%03d", baseName, i+1)
+		instNames := make([]string, replicasetSize)
+		for j := range instNames {
+			if replicasetSize <= 26 {
+				instNames[j] = fmt.Sprintf("%s-%c", replicasetName, 'a'+byte(j))
+			} else {
+				instNames[j] = fmt.Sprintf("%s-%03d", replicasetName, j+1)
+			}
+		}
+		replicasets[i].Name = replicasetName
+		replicasets[i].InstNames = instNames
+	}
+	return replicasets, nil
+}

cli/templates/internal/engines/builtin_funcs_test.go

@@ -0,0 +1,44 @@
+package engines
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGenPort(t *testing.T) {
+	state := newGenState()
+	require.Equal(t, state.genPort(), 3301)
+	require.Equal(t, state.genPort(), 3302)
+}
+
+func TestGenReplicasets(t *testing.T) {
+	replicasets, err := genReplicasets("name", 4, 3)
+	require.NoError(t, err)
+	assert.Equal(t, replicasets, []replicaset{
+		{
+			Name:      "name-001",
+			InstNames: []string{"name-001-a", "name-001-b", "name-001-c"},
+		},
+		{
+			Name:      "name-002",
+			InstNames: []string{"name-002-a", "name-002-b", "name-002-c"},
+		},
+		{
+			Name:      "name-003",
+			InstNames: []string{"name-003-a", "name-003-b", "name-003-c"},
+		},
+		{
+			Name:      "name-004",
+			InstNames: []string{"name-004-a", "name-004-b", "name-004-c"},
+		},
+	})
+
+	replicasets, err = genReplicasets("name", 1, 27)
+	require.NoError(t, err)
+	assert.Equal(t, replicasets[0].InstNames[26], "name-001-027")
+
+	_, err = genReplicasets("name", -1, 0)
+	require.Error(t, err)
+}

cli/templates/internal/engines/go_text_engine.go

@@ -4,12 +4,25 @@ import (
 	"bytes"
 	"fmt"
 	"os"
+	"path"
+	"strconv"
 	"text/template"
 )
 
 type GoTextEngine struct {
 }
 
+// makeTemplate creates template for rendering.
+func makeTemplate(name string) *template.Template {
+	state := newGenState()
+	funcMap := template.FuncMap{
+		"port":        state.genPort,
+		"replicasets": genReplicasets,
+		"atoi":        strconv.Atoi,
+	}
+	return template.New(name).Funcs(funcMap)
+}
+
 // RenderFile renders srcPath template to dstPath using go text/template engine.
 func (GoTextEngine) RenderFile(srcPath string, dstPath string, data interface{}) error {
 	stat, err := os.Stat(srcPath)
@@ -18,7 +31,12 @@ func (GoTextEngine) RenderFile(srcPath string, dstPath string, data interface{})
 	}
 	originFileMode := stat.Mode()
 
-	parsedTemplate, err := template.ParseFiles(srcPath)
+	content, err := os.ReadFile(srcPath)
+	if err != nil {
+		return fmt.Errorf("error reading file %s: %s", srcPath, err)
+	}
+
+	parsedTemplate, err := makeTemplate(path.Base(srcPath)).Parse(string(content))
 	if err != nil {
 		return fmt.Errorf("error parsing %s: %s", srcPath, err)
 	}
@@ -41,7 +59,7 @@ func (GoTextEngine) RenderFile(srcPath string, dstPath string, data interface{})
 
 // RenderText renders in text using go tex/template engine.
 func (GoTextEngine) RenderText(in string, data interface{}) (string, error) {
-	parsedTemplate, err := template.New("file").Parse(in)
+	parsedTemplate, err := makeTemplate("file").Parse(in)
 	if err != nil {
 		return "", fmt.Errorf("failed to parse %s: %s", in, err)
 	}

cli/templates/internal/engines/go_text_engine_test.go

@@ -85,4 +85,24 @@ func TestTextRendering(t *testing.T) {
 	_, err = engine.RenderText(templateText, data)
 	require.EqualError(t, err, "template execution failed: template: file:1:2: "+
 		"executing \"file\" at <.hello>: map has no entry for key \"hello\"")
+
+	// Test builtin functions.
+	templateText = "{{port}}"
+	expectedText = "3301"
+	actualText, err = engine.RenderText(templateText, nil)
+	require.NoError(t, err)
+	assert.Equal(t, expectedText, actualText)
+
+	templateText = `{{range replicasets "name" 1 1}}` +
+		"Hi, {{.Name}}! Your instances: {{ range .InstNames }}{{.}}{{end}}{{end}}"
+	expectedText = "Hi, name-001! Your instances: name-001-a"
+	actualText, err = engine.RenderText(templateText, nil)
+	require.NoError(t, err)
+	assert.Equal(t, expectedText, actualText)
+
+	templateText = `{{atoi "5"}} apples`
+	expectedText = "5 apples"
+	actualText, err = engine.RenderText(templateText, nil)
+	require.NoError(t, err)
+	assert.Equal(t, expectedText, actualText)
 }