Implement the validation that checks if every template file is up-to-date (open-telemetry#65)

This commit resolves the issue that the Helm chart maintainers need to manually compare the template files and the upstream manifest in order to determine which template files are outdated.

Example output of the release code:
```
2021/08/09 12:26:09 The OpenTelemetry Collector CRD update finished. It's up-to-date now.
2021/08/09 12:26:09 ATTENTION: opentelemetry-operator-leader-election-rolebinding configuration doesn't exist. Please create it in the file: rolebinding.yaml
2021/08/09 12:26:09 The values.yaml and Chart.yaml update finished. They are up-to-date now.
2021/08/09 12:26:09 ATTENTION: opentelemetry-operator-controller-manager configuration doesn't exist. Please create it in the file: deployment.yaml
2021/08/09 12:26:09 ATTENTION: validatingwebhookconfiguration.yaml file needs to be updated
```

Author: Saber-W

charts/opentelemetry-operator/Chart.yaml

@@ -1,6 +1,6 @@
 apiVersion: v2
 name: opentelemetry-operator
-version: 0.1.1
+version: 0.1.2
 description: OpenTelemetry Operator Helm chart for Kubernetes
 type: application
 home: https://opentelemetry.io/

charts/opentelemetry-operator/release/go.mod

@@ -1,5 +1,8 @@
-module main
+module github.com/opentelemetry-helm-charts/charts/opentelemetry-operator/release
 
 go 1.16
 
-require gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
+require (
+	github.com/stretchr/testify v1.7.0
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
+)

charts/opentelemetry-operator/release/go.sum

@@ -1,4 +1,12 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

charts/opentelemetry-operator/release/main.go

@@ -2,12 +2,11 @@ package main
 
 import (
 	"errors"
-	"gopkg.in/yaml.v3"
 	"io"
 	"log"
 	"net/http"
-	"os"
-	"strings"
+
+	"gopkg.in/yaml.v3"
 )
 
 const (
@@ -17,24 +16,37 @@ const (
 	chartYAMLPath         = "../Chart.yaml"
 	operatorRepoPath      = "repository: quay.io/opentelemetry/opentelemetry-operator"
 	kubeRBACProxyRepoPath = "repository: gcr.io/kubebuilder/kube-rbac-proxy"
-	appVersion            = "appVersion"
 )
 
 // K8sObject describes the values a Kubernetes object typically has.
 type K8sObject struct {
-	ApiVersion string                      `yaml:"apiVersion"`
-	Kind       string                      `yaml:"kind"`
-	Metadata   map[interface{}]interface{} `yaml:"metadata"`
-	Spec       map[interface{}]interface{} `yaml:"spec"`
-	Status     map[interface{}]interface{} `yaml:"status"`
+	ApiVersion string                        `yaml:"apiVersion"`
+	Kind       string                        `yaml:"kind"`
+	Metadata   map[interface{}]interface{}   `yaml:"metadata"`
+	Spec       map[interface{}]interface{}   `yaml:"spec"`
+	Status     map[interface{}]interface{}   `yaml:"status"`
+	Rules      []map[interface{}]interface{} `yaml:"rules"`
+	RoleRef    map[interface{}]interface{}   `yaml:"roleRef"`
+	Subjects   []map[interface{}]interface{} `yaml:"subjects"`
+	Webhooks   []map[interface{}]interface{} `yaml:"webhooks"`
 }
 
 // The main keeps the OpenTelemetry Operator (OTEL Operator) Helm chart configurations up-to-date with the upstream automatically.
 // First, it scrapes the latest OTEL Operator manifest from the OTEL Operator github:
 // https://github.com/open-telemetry/opentelemetry-operator.
 // Then, it will update the OpenTelemetry Collector CRD YAML file, which is the only CRD at this point.
-// At last, it will retrieve the latest image tag from the OTEL Operator manifest and update the values.yaml and Chart.yaml.
+// Next, it will retrieve the latest image tag from the OTEL Operator manifest and update the values.yaml and Chart.yaml.
+// At last, it will check if every template file is up-to-date with the manifest. If not, it will notify the Helm chart maintainers.
 func main() {
+	// Get all the templates of the OTEL Operator Helm chart.
+	templates, err := getTemplates()
+	if err != nil {
+		panic(err)
+	}
+
+	// needUpdate records if there is any template file needs to be updated.
+	needUpdate := false
+
 	// Get the OTEL Operator manifest data.
 	resp, err := http.Get(operatorManifestURL)
 	if err != nil {
@@ -45,6 +57,7 @@ func main() {
 	dc := yaml.NewDecoder(resp.Body)
 
 	for {
+		// current Kubernetes resource from the upstream manifest
 		var curObject K8sObject
 		err := dc.Decode(&curObject)
 		if errors.Is(err, io.EOF) {
@@ -56,65 +69,37 @@ func main() {
 
 		switch curObject.Kind {
 		case "CustomResourceDefinition":
-			// Update the OTEL Collector CRD YAML file.
-			out, err := yaml.Marshal(curObject)
-			if err != nil {
-				panic(err)
-			}
-			err = os.WriteFile(collectorCRDPath, out, 0644)
+			// Update the collector CRD template file.
+			err = updateCRD(curObject, collectorCRDPath)
 			if err != nil {
 				panic(err)
 			}
+
 			log.Println("The OpenTelemetry Collector CRD update finished. It's up-to-date now.")
 
 		case "Deployment":
-			// Retrieve the latest image repository and tag of the two container images.
-			managerImage := strings.Split(curObject.Spec["template"].(map[string]interface{})["spec"].(map[string]interface{})["containers"].([]interface{})[0].(map[string]interface{})["image"].(string), ":")
-			kubeRBACProxyImage := strings.Split(curObject.Spec["template"].(map[string]interface{})["spec"].(map[string]interface{})["containers"].([]interface{})[1].(map[string]interface{})["image"].(string), ":")
-
-			// Replace the image tags in values.yaml and appVersion in Chart.yaml with the latest ones.
-			valuesFile, err := os.ReadFile(valuesYAMLPath)
-			if err != nil {
-				panic(err)
-			}
-
-			valuesFileLines := strings.Split(string(valuesFile), "\n")
-			for i, line := range valuesFileLines {
-				if strings.Contains(line, operatorRepoPath) {
-					valuesFileLines[i+1] = "    tag: " + managerImage[1]
-				} else if strings.Contains(line, kubeRBACProxyRepoPath) {
-					valuesFileLines[i+1] = "    tag: " + kubeRBACProxyImage[1]
-				}
-			}
-
-			valuesFileOutput := strings.Join(valuesFileLines, "\n")
-			err = os.WriteFile(valuesYAMLPath, []byte(valuesFileOutput), 0644)
-			if err != nil {
-				panic(err)
-			}
-
-			chartFile, err := os.ReadFile(chartYAMLPath)
+			// Update the values.yaml and Chart.yaml with the latest image tags.
+			err = updateImageTags(curObject, valuesYAMLPath, chartYAMLPath)
 			if err != nil {
 				panic(err)
 			}
 
-			chartFileLines := strings.Split(string(chartFile), "\n")
-			for i, line := range chartFileLines {
-				if strings.Contains(line, appVersion) {
-					chartFileLines[i] = appVersion + ": " + managerImage[1][1:]
-				}
-			}
+			log.Println("The values.yaml and Chart.yaml update finished. They are up-to-date now.")
 
-			chartFileOutput := strings.Join(chartFileLines, "\n")
-			err = os.WriteFile(chartYAMLPath, []byte(chartFileOutput), 0644)
+			// Update the templates since we have made changes to values.yaml.
+			templates, err = getTemplates()
 			if err != nil {
 				panic(err)
 			}
 
-			log.Println("The values.yaml and Chart.yaml update finished. They are up-to-date now.")
+			needUpdate = checkTemplate(curObject, templates) || needUpdate
 
 		default:
-			continue
+			needUpdate = checkTemplate(curObject, templates) || needUpdate
 		}
 	}
+
+	if !needUpdate {
+		log.Println("All the template files are up-to-date.")
+	}
 }

charts/opentelemetry-operator/release/release-checklist.md

@@ -1,12 +1,13 @@
+# Prerequisites
+
+- [ ] Make sure you have installed Helm v3 or later versions. See [Helm website](https://helm.sh/docs/helm/helm_install/)
+  for installation information.
+
 # Checklist
 
 - [ ] Change directory to `opentelemetry-helm-charts/charts/opentelemetry-operator/release`. `cd ./charts/opentelemetry-operator/release` should be helpful.
-- [ ] Run the command `go run main.go` to update the OTEL Collector CRD, `values.yaml` and `Chart.yaml`
-- [ ] Download the latest OTEL Operator manifest from this [link](https://github.com/open-telemetry/opentelemetry-operator/releases/latest/download/opentelemetry-operator.yaml).
-  As you can see, there are several YAML files in this manifest separated by `---`.
-- [ ] Starting from the third YAML file, compare the YAML files in the manifest and the ones in the `charts/opentelemetry-operator/templates` directory.
-  The names of YAML files under `templates` directory are the same as the value of key `kind` of the YAML files in the manifest.
-- [ ] Update our template YAML files to maintain consistency with the ones in the manifest (especially be careful with `role.yaml` and `clusterrole.yaml`).
+- [ ] Run the command `go run .` to update the OTEL Collector CRD, `values.yaml` and `Chart.yaml`and detect if any template file needs to be updated
+- [ ] If you see any template files need to be updated, update them to maintain consistency with the ones in the manifest (especially be careful with `role.yaml` and `clusterrole.yaml`).  \
   Create a new YAML file under `templates` directory if it doesn't exist.
   Use `{{ template "opentelemetry-operator.name" . }}` to represent the name of OTEL Operator which probably is `opentelemetry-operator` in the manifest.
   Use `{{ template "opentelemetry-operator.namespace" . }}` to represent the namespace which probably is `opentelemetry-operator-system` in the manifest.
@@ -18,3 +19,4 @@
 - `values.yaml` stores the default values passed into the chart.
 - `Chart.yaml` contains all the basic information of the Helm chart.
 - `role.yaml` and `clusterrole.yaml` define what types of actions will be permitted.
+- `main.go` contains the release process code, `release.go` contains all the release functions

charts/opentelemetry-operator/release/release.go

@@ -0,0 +1,161 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"reflect"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	operatorChartPath = ".."
+	appVersion        = "appVersion"
+)
+
+// getTemplates renders all the template files in this Helm chart and stores them into a map whose keys are the
+// Kubernetes resource kind plus name and values are the Kubernetes resource itself.
+func getTemplates() (map[string]K8sObject, error) {
+	templates := make(map[string]K8sObject)
+
+	// Use `helm template` command to render all the template files.
+	cmd := exec.Command("helm", "template", operatorChartPath)
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	// Process all the YAML files and store the key-value pairs into templates map.
+	rawYAMLFiles := strings.Split(string(out), "---\n")
+	for _, rawYAMLFile := range rawYAMLFiles {
+		var curObject K8sObject
+		err = yaml.Unmarshal([]byte(rawYAMLFile), &curObject)
+		if err != nil {
+			return nil, err
+		}
+		templates[fmt.Sprintf("%s#%v", curObject.Kind, curObject.Metadata["name"])] = curObject
+	}
+
+	return templates, nil
+}
+
+// updateCRD writes the latest OpenTelemetry Collector CRD template file to the Helm chart's Collector CRD file.
+func updateCRD(object K8sObject, collectorCRDPath string) error {
+	out, err := yaml.Marshal(object)
+	if err != nil {
+		return err
+	}
+
+	err = os.WriteFile(collectorCRDPath, out, 0644)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// updateImageTags retrieves the latest image tags and update the values.yaml and Chart.yaml respectively.
+func updateImageTags(object K8sObject, valuesYAMLPath string, chartYAMLPath string) error {
+	var managerImageTag, kubeRBACProxyImageTag string
+
+	// Retrieve the latest image tags of the two container images.
+	containers := object.Spec["template"].(map[string]interface{})["spec"].(map[string]interface{})["containers"].([]interface{})
+
+	for i := range containers {
+		image := containers[i].(map[string]interface{})["image"].(string)
+		switch containers[i].(map[string]interface{})["name"].(string) {
+		case "manager":
+			managerImageTag = strings.Split(image, ":")[1]
+		case "kube-rbac-proxy":
+			kubeRBACProxyImageTag = strings.Split(image, ":")[1]
+		}
+	}
+
+	// Check whether both image tags are found.
+	if managerImageTag == "" || kubeRBACProxyImageTag == "" {
+		return errors.New("Error: could not find image tags of OpenTelemetry Operator")
+	}
+
+	// Replace the image tags in values.yaml with the latest ones.
+	valuesFile, err := os.ReadFile(valuesYAMLPath)
+	if err != nil {
+		return err
+	}
+
+	valuesFileLines := strings.Split(string(valuesFile), "\n")
+	for i, line := range valuesFileLines {
+		if strings.Contains(line, operatorRepoPath) {
+			valuesFileLines[i+1] = "    tag: " + managerImageTag
+		} else if strings.Contains(line, kubeRBACProxyRepoPath) {
+			valuesFileLines[i+1] = "    tag: " + kubeRBACProxyImageTag
+		}
+	}
+
+	valuesFileOutput := strings.Join(valuesFileLines, "\n")
+	err = os.WriteFile(valuesYAMLPath, []byte(valuesFileOutput), 0644)
+	if err != nil {
+		return err
+	}
+
+	// Update the appVersion in Chart.yaml.
+	if err = updateAPPVersion(managerImageTag[1:], chartYAMLPath); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// updateAPPVersion is a helper function of updateImageTags. It updates the appVersion in Chart.yaml with the given version.
+func updateAPPVersion(version string, chartYAMLPath string) error {
+	chartFile, err := os.ReadFile(chartYAMLPath)
+	if err != nil {
+		return err
+	}
+
+	chartFileLines := strings.Split(string(chartFile), "\n")
+	for i, line := range chartFileLines {
+		if strings.Contains(line, appVersion) {
+			chartFileLines[i] = appVersion + ": " + version
+		}
+	}
+
+	chartFileOutput := strings.Join(chartFileLines, "\n")
+	err = os.WriteFile(chartYAMLPath, []byte(chartFileOutput), 0644)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// checkTemplate checks if a given Kubernetes resource has a corresponding template file in this chart or not. If a counterpart exists,
+// it will also check if the two configuration files are the same.
+func checkTemplate(curObject K8sObject, templates map[string]K8sObject) bool {
+	// Get the template file in this chart.
+	templateObject := templates[fmt.Sprintf("%s#%v", curObject.Kind, curObject.Metadata["name"])]
+
+	if !reflect.DeepEqual(curObject, templateObject) {
+		var filename string
+
+		switch curObject.Kind {
+		case "Certificate", "Issuer":
+			filename = "certmanager.yaml"
+		default:
+			filename = strings.ToLower(curObject.Kind) + ".yaml"
+		}
+
+		if templateObject.Kind == "" {
+			log.Printf("ATTENTION: %v configuration doesn't exist. Please create it in the file: %s", curObject.Metadata["name"], filename)
+		} else {
+			log.Printf("ATTENTION: %s file needs to be updated", filename)
+		}
+
+		return true
+	}
+
+	return false
+}