Helper Functions for custom annotations

docs/custom-annotations.md

@@ -86,6 +86,37 @@ If you'd like to use custom annotations with Mergeable Ingress resources, please
 
 * Minions do not inherent custom annotations of the master.
 
+### Helper Functions
+
+Helper functions can be used in custom templates to transform the value of custom annotations.
+
+| Function | Description |
+| -------- | ----------- |
+| `splitinput` | Splits the arguments at specified delimiter and returns an array of strings |
+| `triminput` | Trims the trailing and leading whitespaces from the arguments |
+
+For example, the following custom annotation custom.nginx.org/allowed-ips represents a comma separated list of IP addresses as a string.
+```
+annotations:
+  custom.nginx.org/allowed-ips: "192.168.1.3, 10.0.0.13"
+```
+
+ It is possible to use helper functions such as splitinput and triminput to transform the annotation into something meaningful for NGINX. The example below shows how to use these functions in a custom template for the given annotation:
+
+```
+{{range $ip := splitinput (index $.Ingress.Annotations "custom.nginx.org/allowed-ips") ","}}
+    allow {{triminput $ip}};
+{{end}}
+deny all;
+```
+
+The template will generate the following configuration:
+```
+allow 192.168.1.3;
+allow 10.0.0.13;
+deny all;
+```
+
 ## Example
 
 See the [custom annotations example](../examples/custom-annotations).

internal/configs/version1/template_executor.go

@@ -20,7 +20,7 @@ func NewTemplateExecutor(mainTemplatePath string, ingressTemplatePath string) (*
 		return nil, err
 	}
 
-	ingressTemplate, err := template.New(path.Base(ingressTemplatePath)).ParseFiles(ingressTemplatePath)
+	ingressTemplate, err := template.New(path.Base(ingressTemplatePath)).Funcs(helperFunctions).ParseFiles(ingressTemplatePath)
 	if err != nil {
 		return nil, err
 	}
@@ -45,7 +45,7 @@ func (te *TemplateExecutor) UpdateMainTemplate(templateString *string) error {
 
 // UpdateIngressTemplate updates the ingress template.
 func (te *TemplateExecutor) UpdateIngressTemplate(templateString *string) error {
-	newTemplate, err := template.New("ingressTemplate").Parse(*templateString)
+	newTemplate, err := template.New("ingressTemplate").Funcs(helperFunctions).Parse(*templateString)
 	if err != nil {
 		return err
 	}

internal/configs/version1/template_helper.go

@@ -0,0 +1,22 @@
+package version1
+
+import (
+	"strings"
+	"text/template"
+)
+
+// SplitInput splits the input from "," and returns an array of strings
+func SplitInput(s string, delim string) []string {
+	return strings.Split(s, delim)
+}
+
+// TrimInput trims the leading and trailing spaces in the string
+func TrimInput(s string) string {
+	return strings.TrimSpace(s)
+}
+
+// HelperFunctions to parse the annotations
+var helperFunctions = template.FuncMap{
+	"splitinput": SplitInput, //returns array of strings
+	"triminput":  TrimInput,  //returns string with trimmed leading and trailing spaces
+}

internal/configs/version1/templates_test.go

@@ -111,7 +111,7 @@ var mainCfg = MainConfig{
 }
 
 func TestIngressForNGINXPlus(t *testing.T) {
-	tmpl, err := template.New(nginxPlusIngressTmpl).ParseFiles(nginxPlusIngressTmpl)
+	tmpl, err := template.New(nginxPlusIngressTmpl).Funcs(helperFunctions).ParseFiles(nginxPlusIngressTmpl)
 	if err != nil {
 		t.Fatalf("Failed to parse template file: %v", err)
 	}
@@ -126,7 +126,7 @@ func TestIngressForNGINXPlus(t *testing.T) {
 }
 
 func TestIngressForNGINX(t *testing.T) {
-	tmpl, err := template.New(nginxIngressTmpl).ParseFiles(nginxIngressTmpl)
+	tmpl, err := template.New(nginxIngressTmpl).Funcs(helperFunctions).ParseFiles(nginxIngressTmpl)
 	if err != nil {
 		t.Fatalf("Failed to parse template file: %v", err)
 	}
@@ -169,3 +169,47 @@ func TestMainForNGINX(t *testing.T) {
 		t.Fatalf("Failed to write template %v", err)
 	}
 }
+
+func TestSplitHelperFunctions(t *testing.T) {
+	const tpl = `{{range $n := splitinput (index .) ","}}{{$n}} {{end}}`
+
+	tmpl, err := template.New("testTemplate").Funcs(helperFunctions).Parse(tpl)
+	if err != nil {
+		t.Fatalf("Failed to parse template: %v", err)
+	}
+	var buf bytes.Buffer
+
+	slice := "foo,bar"
+	expected := "foo bar "
+	err = tmpl.Execute(&buf, slice)
+	t.Log(buf.String())
+	if err != nil {
+		t.Fatalf("Failed to write template %v", err)
+	}
+
+	if buf.String() != expected {
+		t.Fatalf("Failed parsing the template, got %v but expected %v.", buf.String(), expected)
+	}
+}
+
+func TestTrimHelperFunctions(t *testing.T) {
+	const tpl = `{{triminput (index .)}}`
+
+	tmpl, err := template.New("testTemplate").Funcs(helperFunctions).Parse(tpl)
+	if err != nil {
+		t.Fatalf("Failed to parse template: %v", err)
+	}
+	var buf bytes.Buffer
+
+	slice := "  foobar     "
+	expected := "foobar"
+	err = tmpl.Execute(&buf, slice)
+	t.Log(buf.String())
+	if err != nil {
+		t.Fatalf("Failed to write template %v", err)
+	}
+
+	if buf.String() != expected {
+		t.Fatalf("Failed parsing the template, got %v but expected %v.", buf.String(), expected)
+	}
+}