From f7e3a0636586d080a419d72dba91bdf841b8a8a9 Mon Sep 17 00:00:00 2001 From: Andrew Suderman Date: Wed, 20 May 2020 13:17:22 -0600 Subject: [PATCH] Adding a namespace flag to restrict helm checking (#77) * Adding a namespace flag to restrict helm checking * Update kind node image --- .circleci/config.yml | 1 + README.md | 10 ++- cmd/root.go | 4 +- e2e/tests/01_helm-detect-3.yaml | 18 ++++- e2e/tests/02_helm-detect-2.yaml | 12 ++- ...helm2cm-no-deprecated-multi-namespace.yaml | 76 +++++++++++++++++++ e2e/tests/assets/helm3/secret-demo2.json | 49 ++++++++++++ e2e/tests/assets/helm3/secret.json | 23 ++++++ e2e/tests/assets/helm3/secret.yaml | 23 ------ pkg/helm/helm.go | 23 +++--- pkg/helm/helm_test.go | 56 ++++++++++++-- 11 files changed, 251 insertions(+), 44 deletions(-) create mode 100644 e2e/tests/assets/helm2/helm2cm-no-deprecated-multi-namespace.yaml create mode 100644 e2e/tests/assets/helm3/secret-demo2.json create mode 100644 e2e/tests/assets/helm3/secret.json delete mode 100644 e2e/tests/assets/helm3/secret.yaml diff --git a/.circleci/config.yml b/.circleci/config.yml index 2995cf5e..5371dea6 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -19,6 +19,7 @@ references: rm goreleaser.deb e2e_config: &e2e_config command_runner_image: quay.io/reactiveops/ci-images:v11-stretch + kind_node_image: "kindest/node:v1.18.0@sha256:0e20578828edd939d25eb98496a685c76c98d54084932f76069f886ec315d694" executor: golang-exec pre_script: e2e/pre.sh store-test-results: /tmp/test-results diff --git a/README.md b/README.md index 44d9780a..66edfa60 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ [goreport-image]: https://goreportcard.com/badge/github.com/FairwindsOps/pluto [goreport-link]: https://goreportcard.com/report/github.com/FairwindsOps/pluto -[circleci-image]: https://circleci.com/gh/FairwindsOps/pluto.svg?style=svg +[circleci-image]: https://circleci.com/gh/FairwindsOps/pluto/tree/master.svg?style=svg [circleci-link]: https://circleci.com/gh/FairwindsOps/pluto [codecov-image]: https://codecov.io/gh/FairwindsOps/pluto/branch/master/graph/badge.svg @@ -107,6 +107,14 @@ invincible-zebu-metrics-server Deployment extensions/v1beta1 apps/v1 lunging-bat-metrics-server Deployment apps/v1 false false ``` +If you only have access to a certain namespace (helm 3), or if you only want to see information for a single namespace, you can pass the `--namespace` or `-n` flag to restrict the output. Due to the way that helm2 stores configmaps, you will still need access to the tiller namespace if you are using helm 2. + +``` +$ pluto detect-helm -n cert-manager -owide +NAME NAMESPACE KIND VERSION REPLACEMENT DEPRECATED DEPRECATED IN REMOVED REMOVED IN +cert-manager/cert-manager-webhook cert-manager MutatingWebhookConfiguration admissionregistration.k8s.io/v1beta1 admissionregistration.k8s.io/v1 true v1.16.0 false v1.19.0 +``` + ### Helm Chart Checking (local files) You can run `helm template | pluto detect --show-all -` diff --git a/cmd/root.go b/cmd/root.go index 1c41217c..5016ef28 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -41,6 +41,7 @@ var ( ignoreDeprecations bool ignoreRemovals bool targetVersion string + namespace string ) func init() { @@ -56,6 +57,7 @@ func init() { rootCmd.AddCommand(detectHelmCmd) detectHelmCmd.PersistentFlags().StringVar(&helmVersion, "helm-version", "3", "Helm version in current cluster (2|3)") + detectHelmCmd.PersistentFlags().StringVarP(&namespace, "namespace", "n", "", "Only detect releases in a specific namespace.") rootCmd.AddCommand(listVersionsCmd) rootCmd.AddCommand(detectCmd) @@ -133,7 +135,7 @@ var detectHelmCmd = &cobra.Command{ Short: "detect-helm", Long: `Detect Kubernetes apiVersions in a helm release (in cluster)`, Run: func(cmd *cobra.Command, args []string) { - h := helm.NewHelm(helmVersion) + h := helm.NewHelm(helmVersion, namespace) err := h.FindVersions() if err != nil { fmt.Println("Error running helm-detect:", err) diff --git a/e2e/tests/01_helm-detect-3.yaml b/e2e/tests/01_helm-detect-3.yaml index e29f4650..6c0e62b8 100644 --- a/e2e/tests/01_helm-detect-3.yaml +++ b/e2e/tests/01_helm-detect-3.yaml @@ -1,9 +1,11 @@ version: "2" name: "Static Code Files (including helm)" testcases: -- name: install helm3 release secret +- name: install helm3 assets steps: - - script: kubectl apply -f assets/helm3 + - script: | + kubectl create ns demo2 + kubectl apply -f assets/helm3 assertions: - result.code ShouldEqual 0 @@ -51,6 +53,16 @@ testcases: - result.systemout ShouldContainSubstring "NAME NAMESPACE KIND VERSION REPLACEMENT DEPRECATED DEPRECATED IN REMOVED REMOVED IN" - result.systemout ShouldContainSubstring "test/test-helm3chart-v1beta1 default Deployment extensions/v1beta1 apps/v1 true v1.9.0 true v1.16.0" +- name: helm detect show all wide namespaced + steps: + - script: pluto detect-helm --helm-version=3 -A -t v1.16.0 -owide -n demo2 + assertions: + - result.code ShouldEqual 0 + - result.systemout ShouldContainSubstring "NAME NAMESPACE KIND VERSION REPLACEMENT DEPRECATED DEPRECATED IN REMOVED REMOVED IN" + - result.systemout ShouldContainSubstring "demo2/demo2-basic-demo demo2 Deployment apps/v1 false false" + - name: cleanup steps: - - script: kubectl delete -f assets/helm3 + - script: | + kubectl delete -f assets/helm3 + kubectl delete ns demo2 diff --git a/e2e/tests/02_helm-detect-2.yaml b/e2e/tests/02_helm-detect-2.yaml index afe2a781..ea1a53ff 100644 --- a/e2e/tests/02_helm-detect-2.yaml +++ b/e2e/tests/02_helm-detect-2.yaml @@ -26,6 +26,16 @@ testcases: - result.systemout ShouldContainSubstring "NAME KIND VERSION REPLACEMENT REMOVED DEPRECATED" - result.systemout ShouldContainSubstring "invincible-zebu/invincible-zebu-metrics-server Deployment extensions/v1beta1 apps/v1 true true" - result.systemout ShouldNotContainSubstring "lunging-bat/lunging-bat-metrics-server Deployment apps/v1 false false" + +- name: helm2 detect in-cluster show-all wide namespaced + steps: + - script: pluto detect-helm --helm-version=2 -A -t v1.15.0 -owide -n demo1 + assertions: + - result.code ShouldEqual 0 + - result.systemout ShouldContainSubstring "NAME NAMESPACE KIND VERSION REPLACEMENT DEPRECATED DEPRECATED IN REMOVED REMOVED IN" + - result.systemout ShouldContainSubstring "kindled-toucan/kindled-toucan-basic-demo demo1 Deployment apps/v1 false false" - name: cleanup steps: - - script: kubectl delete ns helm-system + - script: | + kubectl delete -f assets/helm2/ + kubectl delete ns helm-system diff --git a/e2e/tests/assets/helm2/helm2cm-no-deprecated-multi-namespace.yaml b/e2e/tests/assets/helm2/helm2cm-no-deprecated-multi-namespace.yaml new file mode 100644 index 00000000..a3e11547 --- /dev/null +++ b/e2e/tests/assets/helm2/helm2cm-no-deprecated-multi-namespace.yaml @@ -0,0 +1,76 @@ +apiVersion: v1 +items: +- apiVersion: v1 + data: + release: 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 + kind: ConfigMap + metadata: + creationTimestamp: "2020-05-19T21:15:59Z" + labels: + MODIFIED_AT: "1589922959" + NAME: kindled-toucan + OWNER: TILLER + STATUS: DEPLOYED + VERSION: "1" + managedFields: + - apiVersion: v1 + fieldsType: FieldsV1 + fieldsV1: + f:data: + .: {} + f:release: {} + f:metadata: + f:labels: + .: {} + f:MODIFIED_AT: {} + f:NAME: {} + f:OWNER: {} + f:STATUS: {} + f:VERSION: {} + manager: tiller + operation: Update + time: "2020-05-19T21:15:59Z" + name: kindled-toucan.v1 + namespace: helm-system + resourceVersion: "2008" + selfLink: /api/v1/namespaces/helm-system/configmaps/kindled-toucan.v1 + uid: 5e9399b5-26d6-4530-9b84-5d9f7edc471c +- apiVersion: v1 + data: + release: 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 + kind: ConfigMap + metadata: + creationTimestamp: "2020-05-19T21:15:38Z" + labels: + MODIFIED_AT: "1589922938" + NAME: kissing-sponge + OWNER: TILLER + STATUS: DEPLOYED + VERSION: "1" + managedFields: + - apiVersion: v1 + fieldsType: FieldsV1 + fieldsV1: + f:data: + .: {} + f:release: {} + f:metadata: + f:labels: + .: {} + f:MODIFIED_AT: {} + f:NAME: {} + f:OWNER: {} + f:STATUS: {} + f:VERSION: {} + manager: tiller + operation: Update + time: "2020-05-19T21:15:38Z" + name: kissing-sponge.v1 + namespace: helm-system + resourceVersion: "1873" + selfLink: /api/v1/namespaces/helm-system/configmaps/kissing-sponge.v1 + uid: 7790276b-e910-4234-b547-0324cc085388 +kind: List +metadata: + resourceVersion: "" + selfLink: "" diff --git a/e2e/tests/assets/helm3/secret-demo2.json b/e2e/tests/assets/helm3/secret-demo2.json new file mode 100644 index 00000000..4302686f --- /dev/null +++ b/e2e/tests/assets/helm3/secret-demo2.json @@ -0,0 +1,49 @@ +{ + "apiVersion": "v1", + "data": { + "release": "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" + }, + "kind": "Secret", + "metadata": { + "creationTimestamp": "2020-05-19T21:41:23Z", + "labels": { + "modifiedAt": "1589924483", + "name": "demo2", + "owner": "helm", + "status": "deployed", + "version": "1" + }, + "managedFields": [ + { + "apiVersion": "v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:data": { + ".": {}, + "f:release": {} + }, + "f:metadata": { + "f:labels": { + ".": {}, + "f:modifiedAt": {}, + "f:name": {}, + "f:owner": {}, + "f:status": {}, + "f:version": {} + } + }, + "f:type": {} + }, + "manager": "helm", + "operation": "Update", + "time": "2020-05-19T21:41:23Z" + } + ], + "name": "sh.helm.release.v1.demo2.v1", + "namespace": "demo2", + "resourceVersion": "1536", + "selfLink": "/api/v1/namespaces/demo2/secrets/sh.helm.release.v1.demo2.v1", + "uid": "d324fe69-840c-4978-8054-d860c7ff99ca" + }, + "type": "helm.sh/release.v1" +} diff --git a/e2e/tests/assets/helm3/secret.json b/e2e/tests/assets/helm3/secret.json new file mode 100644 index 00000000..a76ec270 --- /dev/null +++ b/e2e/tests/assets/helm3/secret.json @@ -0,0 +1,23 @@ +{ + "apiVersion": "v1", + "data": { + "release": "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" + }, + "kind": "Secret", + "metadata": { + "creationTimestamp": "2020-05-14T16:13:59Z", + "labels": { + "modifiedAt": "1589472839", + "name": "test", + "owner": "helm", + "status": "deployed", + "version": "1" + }, + "name": "sh.helm.release.v1.test.v1", + "namespace": "default", + "resourceVersion": "2869", + "selfLink": "/api/v1/namespaces/default/secrets/sh.helm.release.v1.test.v1", + "uid": "f8151892-2b13-4a55-929b-d7b138feeef6" + }, + "type": "helm.sh/release.v1" +} diff --git a/e2e/tests/assets/helm3/secret.yaml b/e2e/tests/assets/helm3/secret.yaml deleted file mode 100644 index a973ddeb..00000000 --- a/e2e/tests/assets/helm3/secret.yaml +++ /dev/null @@ -1,23 +0,0 @@ -{ - "apiVersion": "v1", - "data": { - "release": "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" - }, - "kind": "Secret", - "metadata": { - "creationTimestamp": "2020-05-14T16:13:59Z", - "labels": { - "modifiedAt": "1589472839", - "name": "test", - "owner": "helm", - "status": "deployed", - "version": "1" - }, - "name": "sh.helm.release.v1.test.v1", - "namespace": "default", - "resourceVersion": "2869", - "selfLink": "/api/v1/namespaces/default/secrets/sh.helm.release.v1.test.v1", - "uid": "f8151892-2b13-4a55-929b-d7b138feeef6" - }, - "type": "helm.sh/release.v1" -} diff --git a/pkg/helm/helm.go b/pkg/helm/helm.go index 9c44f3b4..e9ef9efe 100644 --- a/pkg/helm/helm.go +++ b/pkg/helm/helm.go @@ -28,10 +28,11 @@ import ( // Helm represents all current releases that we can find in the cluster type Helm struct { - Releases []*Release - Outputs []*api.Output - Version string - Kube *kube + Releases []*Release + Outputs []*api.Output + Version string + Kube *kube + Namespace string } // Release represents a single helm release @@ -54,10 +55,11 @@ type ChartMeta struct { } // NewHelm returns a basic helm struct with the version of helm requested -func NewHelm(version string) *Helm { +func NewHelm(version string, namespace string) *Helm { return &Helm{ - Version: version, - Kube: getConfigInstance(), + Version: version, + Kube: getConfigInstance(), + Namespace: namespace, } } @@ -83,11 +85,14 @@ func (h *Helm) getReleasesVersionTwo() error { } hcm := driverv2.NewConfigMaps(h.Kube.Client.CoreV1().ConfigMaps("")) helmClient := helmstoragev2.Init(hcm) - list, err := helmClient.ListDeployed() + list, err := helmClient.ListReleases() if err != nil { return err } for _, release := range list { + if h.Namespace != "" && release.Namespace != h.Namespace { + continue + } deployed, err := helmClient.Deployed(release.Name) if err != nil { return fmt.Errorf("error determining most recent deployed for '%s'\n %w", release.Name, err) @@ -112,7 +117,7 @@ func (h *Helm) getReleasesVersionThree() error { if h.Version != "3" { return fmt.Errorf("helm 3 function called without helm 3 version set") } - hs := driverv3.NewSecrets(h.Kube.Client.CoreV1().Secrets("")) + hs := driverv3.NewSecrets(h.Kube.Client.CoreV1().Secrets(h.Namespace)) helmClient := helmstoragev3.Init(hs) list, err := helmClient.ListDeployed() if err != nil { diff --git a/pkg/helm/helm_test.go b/pkg/helm/helm_test.go index eff1d377..b8d5b992 100644 --- a/pkg/helm/helm_test.go +++ b/pkg/helm/helm_test.go @@ -42,6 +42,21 @@ var ( "release": "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", }, } + helmConfigMap2 = v1.ConfigMap{ + ObjectMeta: metav1.ObjectMeta{ + Name: "helmtest2.v2", + Labels: map[string]string{ + "MODIFIED_AT": "1589922959", + "NAME": "kindled-toucan", + "OWNER": "TILLER", + "STATUS": "DEPLOYED", + "VERSION": "1", + }, + }, + Data: map[string]string{ + "release": "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", + }, + } helmSecret = v1.Secret{ ObjectMeta: metav1.ObjectMeta{ Name: "sh.helm.release.v1.helmtest.v1", @@ -81,12 +96,26 @@ var ( }, }, } + wantOutputNamespaced = []*api.Output{ + { + Name: "kindled-toucan/kindled-toucan-basic-demo", + Namespace: "demo1", + APIVersion: &api.Version{ + Name: "apps/v1", + Kind: "Deployment", + DeprecatedIn: "", + RemovedIn: "", + ReplacementAPI: "", + }, + }, + } ) -func newMockHelm(version string) *Helm { +func newMockHelm(version string, namespace string) *Helm { return &Helm{ - Version: version, - Kube: getMockConfigInstance(), + Version: version, + Namespace: namespace, + Kube: getMockConfigInstance(), } } @@ -136,6 +165,7 @@ func TestHelm_getManifestsVersionTwo(t *testing.T) { tests := []struct { name string helmVersion string + namespace string wantErr bool errMessage string configMap *v1.ConfigMap @@ -153,9 +183,23 @@ func TestHelm_getManifestsVersionTwo(t *testing.T) { configMap: &helmConfigMap, want: wantOutput, }, + { + name: "helm 2 other namespace", + namespace: "demo1", + helmVersion: "2", + configMap: &helmConfigMap, + want: nil, + }, + { + name: "helm 2 target namespace", + namespace: "demo1", + helmVersion: "2", + configMap: &helmConfigMap2, + want: wantOutputNamespaced, + }, } for _, tt := range tests { - h := newMockHelm(tt.helmVersion) + h := newMockHelm(tt.helmVersion, tt.namespace) if tt.configMap != nil { _, err := h.Kube.Client.CoreV1().ConfigMaps("kube-system").Create(tt.configMap) if err != nil { @@ -198,7 +242,7 @@ func TestHelm_getManifestsVersionThree(t *testing.T) { } for _, tt := range tests { - h := newMockHelm(tt.helmVersion) + h := newMockHelm(tt.helmVersion, "") if tt.secret != nil { _, err := h.Kube.Client.CoreV1().Secrets("default").Create(tt.secret) if err != nil { @@ -274,7 +318,7 @@ func TestHelm_FindVersions(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - h := newMockHelm(tt.helmVersion) + h := newMockHelm(tt.helmVersion, "") err := h.FindVersions() if tt.wantErr { assert.EqualError(t, err, tt.errMessage)