merge upstream

Author: tbugfinder

.github/workflows/ci.yaml

@@ -2,8 +2,8 @@
 name: CI
 
 env:
-  VERSION_GO: '1.19.6'
-  VERSION_HELM: 'v3.11.1'
+  VERSION_GO: '1.19.8'
+  VERSION_HELM: 'v3.11.3'
 
 on:
   pull_request:

Makefile

@@ -1,7 +1,7 @@
 HELM_HOME ?= $(shell helm home)
 VERSION := $(shell sed -n -e 's/version:[ "]*\([^"]*\).*/\1/p' plugin.yaml)
 
-HELM_3_PLUGINS := $(shell bash -c 'eval $$(helm env); echo $$HELM_PLUGINS')
+HELM_3_PLUGINS := $(shell helm env HELM_PLUGINS)
 
 PKG:= github.com/databus23/helm-diff/v3
 LDFLAGS := -X $(PKG)/cmd.Version=$(VERSION)

README.md

@@ -102,6 +102,9 @@ func (d *diffCmd) template(isUpgrade bool) ([]byte, error) {
 	if d.postRenderer != "" {
 		flags = append(flags, "--post-renderer", d.postRenderer)
 	}
+	for _, arg := range d.postRendererArgs {
+		flags = append(flags, "--post-renderer-args", arg)
+	}
 	// Helm automatically enable --reuse-values when there's no --set, --set-string, --set-values, --set-file present.
 	// Let's simulate that in helm-diff.
 	// See https://medium.com/@kcatstack/understand-helm-upgrade-flags-reset-values-reuse-values-6e58ac8f127e

cmd/helm3.go

@@ -11,7 +11,7 @@ func AddDiffOptions(f *pflag.FlagSet, o *diff.Options) {
 	f.BoolVar(&o.ShowSecrets, "show-secrets", false, "do not redact secret values in the output")
 	f.StringArrayVar(&o.SuppressedKinds, "suppress", []string{}, "allows suppression of the values listed in the diff output")
 	f.IntVarP(&o.OutputContext, "context", "C", -1, "output NUM lines of context around changes")
-	f.StringVar(&o.OutputFormat, "output", "diff", "Possible values: diff, simple, template. When set to \"template\", use the env var HELM_DIFF_TPL to specify the template.")
+	f.StringVar(&o.OutputFormat, "output", "diff", "Possible values: diff, simple, template, dyff. When set to \"template\", use the env var HELM_DIFF_TPL to specify the template.")
 	f.BoolVar(&o.StripTrailingCR, "strip-trailing-cr", false, "strip trailing carriage return on input")
 	f.Float32VarP(&o.FindRenames, "find-renames", "D", 0, "Enable rename detection if set to any value greater than 0. If specified, the value denotes the maximum fraction of changed content as lines added + removed compared to total lines in a diff for considering it a rename. Only objects of the same Kind are attempted to be matched")
 }

cmd/options.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"strings"
 
 	"github.com/spf13/cobra"
 	"k8s.io/helm/pkg/helm"
@@ -22,14 +23,16 @@ type release struct {
 }
 
 const releaseCmdLongUsage = `
-This command compares the manifests details of a different releases created from the same chart
+This command compares the manifests details of a different releases created from the same chart.
+The release name may be specified using namespace/release syntax.
 
 It can be used to compare the manifests of
 
  - release1 with release2
 	$ helm diff release [flags] release1 release2
    Example:
 	$ helm diff release my-prod my-stage
+	$ helm diff release prod/my-prod stage/my-stage
 `
 
 func releaseCmd() *cobra.Command {
@@ -83,33 +86,45 @@ func releaseCmd() *cobra.Command {
 }
 
 func (d *release) differentiateHelm3() error {
-	namespace := os.Getenv("HELM_NAMESPACE")
 	excludes := []string{helm3TestHook, helm2TestSuccessHook}
 	if d.includeTests {
 		excludes = []string{}
 	}
-	releaseResponse1, err := getRelease(d.releases[0], namespace)
+
+	namespace1 := os.Getenv("HELM_NAMESPACE")
+	release1 := d.releases[0]
+	if strings.Contains(release1, "/") {
+		namespace1 = strings.Split(release1, "/")[0]
+		release1 = strings.Split(release1, "/")[1]
+	}
+	releaseResponse1, err := getRelease(release1, namespace1)
 	if err != nil {
 		return err
 	}
-	releaseChart1, err := getChart(d.releases[0], namespace)
+	releaseChart1, err := getChart(release1, namespace1)
 	if err != nil {
 		return err
 	}
 
-	releaseResponse2, err := getRelease(d.releases[1], namespace)
+	namespace2 := os.Getenv("HELM_NAMESPACE")
+	release2 := d.releases[1]
+	if strings.Contains(release2, "/") {
+		namespace2 = strings.Split(release2, "/")[0]
+		release2 = strings.Split(release2, "/")[1]
+	}
+	releaseResponse2, err := getRelease(release2, namespace2)
 	if err != nil {
 		return err
 	}
-	releaseChart2, err := getChart(d.releases[1], namespace)
+	releaseChart2, err := getChart(release2, namespace2)
 	if err != nil {
 		return err
 	}
 
 	if releaseChart1 == releaseChart2 {
 		seenAnyChanges := diff.Releases(
-			manifest.Parse(string(releaseResponse1), namespace, d.normalizeManifests, excludes...),
-			manifest.Parse(string(releaseResponse2), namespace, d.normalizeManifests, excludes...),
+			manifest.Parse(string(releaseResponse1), namespace1, d.normalizeManifests, excludes...),
+			manifest.Parse(string(releaseResponse2), namespace2, d.normalizeManifests, excludes...),
 			&d.Options,
 			os.Stdout)
 

cmd/release.go

@@ -28,7 +28,7 @@ This command compares the manifests details of a named release.
 
 It can be used to compare the manifests of
 
- - lastest REVISION with specified REVISION
+ - latest REVISION with specified REVISION
 	$ helm diff revision [flags] RELEASE REVISION1
    Example:
 	$ helm diff revision my-release 2

cmd/revision.go

@@ -15,18 +15,18 @@ The Helm Diff Plugin
 
 * Shows a diff explaining what a helm upgrade would change:
     This fetches the currently deployed version of a release
-  and compares it to a local chart plus values. This can be 
+  and compares it to a local chart plus values. This can be
   used visualize what changes a helm upgrade will perform.
 
 * Shows a diff explaining what had changed between two revisions:
     This fetches previously deployed versions of a release
-  and compares them. This can be used visualize what changes 
+  and compares them. This can be used visualize what changes
   were made during revision change.
 
 * Shows a diff explaining what a helm rollback would change:
     This fetches the currently deployed version of a release
-  and compares it to the previously deployed version of the release, that you 
-  want to rollback. This can be used visualize what changes a 
+  and compares it to the previously deployed version of the release, that you
+  want to rollback. This can be used visualize what changes a
   helm rollback will perform.
 `
 

cmd/root.go

@@ -53,6 +53,7 @@ type diffCmd struct {
 	noHooks                  bool
 	includeTests             bool
 	postRenderer             string
+	postRendererArgs         []string
 	install                  bool
 	normalizeManifests       bool
 	threeWayMerge            bool
@@ -206,6 +207,7 @@ func newChartCommand() *cobra.Command {
 	f.BoolVar(&diff.disableOpenAPIValidation, "disable-openapi-validation", false, "disables rendered templates validation against the Kubernetes OpenAPI Schema")
 	f.BoolVar(&diff.dryRun, "dry-run", false, "disables cluster access and show diff as if it was install. Implies --install, --reset-values, and --disable-validation")
 	f.StringVar(&diff.postRenderer, "post-renderer", "", "the path to an executable to be used for post rendering. If it exists in $PATH, the binary will be used, otherwise it will try to look for the executable at the given path")
+	f.StringArrayVar(&diff.postRendererArgs, "post-renderer-args", []string{}, "an argument to the post-renderer (can specify multiple)")
 	f.BoolVar(&diff.normalizeManifests, "normalize-manifests", false, "normalize manifests before running diff to exclude style differences from the output")
 
 	AddDiffOptions(f, &diff.Options)
@@ -280,7 +282,7 @@ func (d *diffCmd) runHelm3() error {
 
 	currentSpecs := make(map[string]*manifest.MappingResult)
 	if !newInstall && !d.dryRun {
-		if !d.noHooks {
+		if !d.noHooks && !d.threeWayMerge {
 			hooks, err := getHooks(d.release, d.namespace)
 			if err != nil {
 				return err

cmd/upgrade.go

@@ -3,6 +3,8 @@ package diff
 import (
 	"errors"
 	"fmt"
+	"github.com/gonvenience/ytbx"
+	"github.com/homeport/dyff/pkg/dyff"
 	"io"
 	"log"
 	"os"
@@ -61,11 +63,52 @@ func (r *Report) setupReportFormat(format string) {
 		setupTemplateReport(r)
 	case "json":
 		setupJSONReport(r)
+	case "dyff":
+		setupDyffReport(r)
 	default:
 		setupDiffReport(r)
 	}
 }
 
+func setupDyffReport(r *Report) {
+	r.format.output = printDyffReport
+}
+
+func printDyffReport(r *Report, to io.Writer) {
+	currentFile, _ := os.CreateTemp("", "existing-values")
+	defer os.Remove(currentFile.Name())
+	newFile, _ := os.CreateTemp("", "new-values")
+	defer os.Remove(newFile.Name())
+
+	for _, entry := range r.entries {
+		_, _ = currentFile.WriteString("---\n")
+		_, _ = newFile.WriteString("---\n")
+		for _, record := range entry.diffs {
+			switch record.Delta {
+			case difflib.Common:
+				_, _ = currentFile.WriteString(record.Payload + "\n")
+				_, _ = newFile.WriteString(record.Payload + "\n")
+			case difflib.LeftOnly:
+				_, _ = currentFile.WriteString(record.Payload + "\n")
+			case difflib.RightOnly:
+				_, _ = newFile.WriteString(record.Payload + "\n")
+			}
+		}
+	}
+	_ = currentFile.Close()
+	_ = newFile.Close()
+
+	currentInputFile, newInputFile, _ := ytbx.LoadFiles(currentFile.Name(), newFile.Name())
+
+	report, _ := dyff.CompareInputFiles(currentInputFile, newInputFile)
+	reportWriter := &dyff.HumanReport{
+		Report:               report,
+		OmitHeader:           true,
+		MinorChangeThreshold: 0.1,
+	}
+	_ = reportWriter.WriteReport(to)
+}
+
 // addEntry: stores diff changes.
 func (r *Report) addEntry(key string, suppressedKinds []string, kind string, context int, diffs []difflib.DiffRecord, changeType string) {
 	entry := ReportEntry{