Error installation failed cannot re use a name that is still in use

Comments

To use the same command when installing and upgrading a release, using helm upgrade with --install works.

To use the same command when installing and upgrading a release, using helm upgrade with --install works.

To use the same command when installing and upgrading a release, using helm upgrade with '--install' works.

Closes helm#3134

* docs(helm): Document how to update a release idempotently

To use the same command when installing and upgrading a release, using helm upgrade with '--install' works.

Closes #3134

* Upgrade instead of update

You can upgrade your release to a new version in Helm with the helm upgrade [release-name] [chart] command. But occasionally, trying to update your release can result in the “Error – Cannot Re-Use a Name That is Still in Use”.

We will discuss the root reasons for the “helm has no deployed releases” error in this tutorial, as well as a number of potential fixes.

What Causes the “helm has no deployed releases” Error?

Using the helm upgrade [release-name] [chart] command on a prior unsuccessful release now results in the following error as of Helm 2.7.1:

• Error: [release-name] has no deployed releases. Upgrade Failed

To apply the required patches, Helm 2 compares the old and new deployment manifests. However, it does not contrast the resource conditions between the manifestations.

It is conceivable that the cluster lacks some resources if a prior deployment failed. Helm will attempt to upgrade the deployment without installing the missing resources prior to Helm 2.7.1. As of version 2.7.1, Helm uses the most recent successful deployment as the baseline for the upgrade in order to avoid issues.

The system displays the message “Error – Cannot Re-Use a Name That is Still in Use” if there are no successful deployments to be discovered.

Getting rid of the error – Cannot Re-Use a Name That is Still in Use

The “helm has no deployed releases” Error – Cannot Re-Use a Name That is Still in Use, can be resolved in a number of ways, most of which concentrate on updating the status of the unsuccessful deployment that gave rise to the problem:

1: Altering the deployment status

You can get around the problem with Helm 2 by changing the release status to deploy:

• configmap [release name]. [release version] kubectl -n Kube-system ' —type=merge {"metadata”: {"labels”: {"STATUS":"DEPLOYED"}}}'

Where:

1. The name of the release you want to upgrade is [release name].
2. The most recent version of your release is [release version].

Since Kubernetes secrets are how Helm 3 records the deployment history. Verify the deployment tactics:

• get secrets with kubectl

To alter the deployment status, locate the secret pertaining to the failed deployment, then execute the command:

• Secret kubectl patch [name-of-secret-pertaining-to-deployment] ' —type=merge {"metadata”: {"labels”: {"status":"deployed"}}}'

2: Removing Failed Deployments

The problem can be fixed by scrapping the current release and beginning a new one from scratch. Using Helm 2, perform the following:

• [Release name] Helm remove —purge

Where:

• The name of the release you want to remove it [release name].

Since Helm 3, the uninstall command is necessary to remove a release:

• Helm uninstall [name of the release]

1: Before removing a failed release, make sure your deployment is in good shape.

• list helm -a

2: Verify the deployment secrets if your release’s status is not deployed:

• get secrets with kubectl

3: Describe the final item on the list of secrets to determine its status.

• the command kubectl describe secret

Where:

• The name of the secret you seek is [secret name].

4: Delete the secret if its status matches that of the failed deployment by using:

• delete secret "[private name]" with kubectl

5: Improve your release by adding:

• Helm upgrade [name of release]

3:  Requiring an Upgrade

The issue can also be fixed by forcing an upgrade using:

• Helm upgrade [name of release] —force

Where:

• The name of the release you want to upgrade is [release name].

This works similarly to helm delete —purge in the background, removing the previous release before installing the new one. This could result in service interruptions, making it inappropriate for some releases.

Conclusion

You ought to be able to update your release to a new version after finishing this instruction without getting the ” Error – Cannot Re-Use a Name That is Still in Use” message.

func returnActionConfig(ctx *gin.Context) (*SaveFilePath, *action.Configuration) {

	response := SaveFilePath{}
	InfoLogger.Println("Inside returnActionConfig")

	kubeConfigFile, err := ctx.FormFile("kubeconfig")
	if err != nil {
		ErrorLogger.Println("get form err for kubeconfig file: ", err.Error())
		response.Detail = "get form err for kubeconfig file: " + err.Error()
		response.Status = http.StatusBadRequest
		return &response, nil
	}

	kubeConfigPath := filepath.Base(kubeConfigFile.Filename)
	if err := ctx.SaveUploadedFile(kubeConfigFile, kubeConfigPath); err != nil {
		ErrorLogger.Println("upload file err for kubeconfig file: ", err.Error())
		response.Detail = "upload file err for kubeconfig file: " + err.Error()
		response.Status = http.StatusInternalServerError
		return &response, nil
	}

	releaseNamespace := ctx.Request.FormValue("releasenamespace")

	actionConfig := new(action.Configuration)
	if err := actionConfig.Init(kube.GetConfig(kubeConfigPath, "", releaseNamespace), releaseNamespace, os.Getenv("HELM_DRIVER"), func(format string, v ...interface{}) {
		str := fmt.Sprintf(format, v)
		InfoLogger.Println(str)
	}); err != nil {
		ErrorLogger.Println("Initialization of action configuration failed: ", err.Error())
		response.Detail = "Initialization of action configuration failed: " + err.Error()
		response.Status = http.StatusInternalServerError
		return &response, nil
	}

	response.Status = http.StatusOK
	response.KubeConfigPath = kubeConfigPath
	return &response, actionConfig
}

//ChartInstallFromRepo ...
func (services helmInstallService) ChartInstallFromRepo(ctx *gin.Context) {

	repoUpdateErr := repoUpdate()
	if repoUpdateErr != nil {
		ErrorLogger.Println("Repo Update Error: ", repoUpdateErr)
	}
	response := InstallOrUpgradeResponse{}

	var err error
	var release *release.Release
	var valueExtPath string

	saveFileResp, actionConfig := returnActionConfig(ctx)
	if saveFileResp.Status != http.StatusOK {
		ErrorLogger.Println("ChartInstallFromRepo: ", saveFileResp.Detail)
		response.Status = saveFileResp.Status
		response.Detail = saveFileResp.Detail
		ctx.JSON(http.StatusOK, response)
		return
	}

	valueExtFile, valueExtErr := ctx.FormFile("valueExt")
	if valueExtErr != nil {
		ErrorLogger.Println("get form err for valuesExt file: ", valueExtErr.Error())
	} else {
		valueExtPath = filepath.Base(valueExtFile.Filename)
		if err := ctx.SaveUploadedFile(valueExtFile, valueExtPath); err != nil {
			ErrorLogger.Println("upload file err for valueExt file:", err.Error())
			response.Detail = "upload file err for valueExt file:" + err.Error()
			response.Status = http.StatusInternalServerError
			ctx.JSON(http.StatusOK, response)
			return
		}
	}
	InfoLogger.Println("Values Ext File: ", valueExtFile)
	client := action.NewInstall(actionConfig)

	if client.Version == "" && client.Devel {
		client.Version = ">0.0.0-0"
	}
	client.ReleaseName = ctx.Request.FormValue("releasename")
	client.ChartPathOptions.Version = ctx.Request.FormValue("chartversion")
	repo := ctx.Request.FormValue("reponame")
	chart := ctx.Request.FormValue("chartname")
	cp, err := client.ChartPathOptions.LocateChart(fmt.Sprintf("%s/%s", repo, chart), setting)
	if err != nil {
		ErrorLogger.Println("Locating chart failed: ", err.Error())
		response.Detail = "Locating chart failed: " + err.Error()
		response.Status = http.StatusBadRequest
		ctx.JSON(http.StatusOK, response)
		removeFile(valueExtPath)
		return
	}

	p := getter.All(setting)
	// valueOpts := &values.Options{}
	// vals, err := valueOpts.MergeValues(p)
	// if err != nil {
	// 	log.Fatal(err)
	// }

	// Check chart dependencies to make sure all are present in /charts
	chartRequested, err := loader.Load(cp)
	if err != nil {
		ErrorLogger.Println("Loading chart failed: ", err.Error())
		response.Detail = "Loading chart failed: " + err.Error()
		response.Status = http.StatusInternalServerError
		ctx.JSON(http.StatusOK, response)
		removeFile(valueExtPath)
		return
	}

	// validInstallableChart, err := isChartInstallable(chartRequested)
	// if !validInstallableChart {
	// 	log.Fatal(err)
	// }

	if req := chartRequested.Metadata.Dependencies; req != nil {
		// If CheckDependencies returns an error, we have unfulfilled dependencies.
		// As of Helm 2.4.0, this is treated as a stopping condition:
		// https://github.com/helm/helm/issues/2209
		if err := action.CheckDependencies(chartRequested, req); err != nil {
			if client.DependencyUpdate {
				man := &downloader.Manager{
					Out:              os.Stdout,
					ChartPath:        cp,
					Keyring:          client.ChartPathOptions.Keyring,
					SkipUpdate:       false,
					Getters:          p,
					RepositoryConfig: setting.RepositoryConfig,
					RepositoryCache:  setting.RepositoryCache,
				}
				if err := man.Update(); err != nil {
					ErrorLogger.Println("updating local chart dir failed: ", err.Error())
					response.Detail = "updating local chart dir failed: " + err.Error()
					response.Status = http.StatusInternalServerError
					ctx.JSON(http.StatusOK, response)
					removeFile(valueExtPath)
					return
				}
			} else {
				InfoLogger.Println("Dependency Update failed: ", err.Error())
				response.Detail = "Dependency Update failed: " + err.Error()
				response.Status = http.StatusInternalServerError
				ctx.JSON(http.StatusOK, response)
				removeFile(valueExtPath)
				return
			}
		}
	}

	client.Namespace = ctx.Request.FormValue("releasenamespace")

	if valueExtErr == nil {
		var vals map[string]interface{}
		vals, err = chartutil.ReadValuesFile(valueExtPath)
		release, err = client.Run(chartRequested, vals)
	} else {
		release, err = client.Run(chartRequested, nil)
	}
	if err != nil {
		ErrorLogger.Println("Helm installtion failed: ", err.Error())
		response.Detail = "Helm installtion failed: " + err.Error()
		response.Status = http.StatusInternalServerError
		//uninstall chart to free release name
		ChartUninstallSvc(ctx)
		ctx.JSON(http.StatusOK, response)
		removeFile(valueExtPath)
		return
	}
	InfoLogger.Println(release.Manifest)
	InfoLogger.Println("Helm installation successful")
	response.Detail = "Helm installation successful"
	response.Status = http.StatusOK
	response.RevisionNumber = release.Version
	response.AppVersion = release.Chart.AppVersion()
	response.ChartName = release.Chart.Name() + "-" + release.Chart.Metadata.Version
	response.Description = release.Info.Description
	response.RevisionNumber = release.Version
	response.UpdatedTime = release.Info.LastDeployed.String()
	response.DeployStatus = release.Info.Status.String()
	removeFile(valueExtPath)
	ctx.JSON(http.StatusOK, response)
}

func ChartUninstallSvc(ctx *gin.Context) *Response {
	response := Response{}
	saveFileResp, actionConfig := returnActionConfig(ctx)
	if saveFileResp.Status != http.StatusOK {
		ErrorLogger.Println("ChartUnInstall : ", saveFileResp.Detail)
		response.Status = saveFileResp.Status
		response.Detail = saveFileResp.Detail
		return &response
	}

	releaseName := ctx.Request.FormValue("releasename")

	chartUninstall := action.NewUninstall(actionConfig)
	releaseresp, err := chartUninstall.Run(releaseName)

	if err != nil {
		ErrorLogger.Println("ChartUninstall Error: ", err.Error())
		response.Status = http.StatusInternalServerError
		response.Detail = err.Error()
		return &response
	}

	InfoLogger.Println("ChartUninstall successful for release Name: ", releaseName)

	InfoLogger.Println("ChartUninstall Info: ", releaseresp.Release.Info)
	response.Status = http.StatusOK
	response.Detail = "Chart Uninstall successful for release Name: " + releaseName
	return &response
}

All 5 comments

helm ls --namespace cattle-system
NAME    NAMESPACE       REVISION    UPDATED                                STATUS   CHART           APP VERSION
rancher cattle-system   1           2020-02-05 10:10:23.144025441 +0100 CETfailed   rancher-2.3.5   v2.3.5     

Cannot install the helm chart but when I use raw file generated by helm, I am able to install via kubectl apply.

Following error is displayed when i use helm install myChart . --debug

Error: cannot re-use a name that is still in use
helm.go:88: [debug] cannot re-use a name that is still in use
helm.sh/helm/v3/pkg/action.(*Install).availableName
        helm.sh/helm/v3/pkg/action/install.go:442
helm.sh/helm/v3/pkg/action.(*Install).Run
        helm.sh/helm/v3/pkg/action/install.go:185
main.runInstall
        helm.sh/helm/v3/cmd/helm/install.go:242
main.newInstallCmd.func2
        helm.sh/helm/v3/cmd/helm/install.go:120
github.com/spf13/cobra.(*Command).execute
        github.com/spf13/[email protected]/command.go:852
github.com/spf13/cobra.(*Command).ExecuteC
        github.com/spf13/[email protected]/command.go:960
github.com/spf13/cobra.(*Command).Execute
        github.com/spf13/[email protected]/command.go:897
main.main
        helm.sh/helm/v3/cmd/helm/helm.go:87
runtime.main
        runtime/proc.go:225
runtime.goexit
        runtime/asm_amd64.s:1371

Installing raw file generated by helm with the following command works great but when I run helm install myChart . it gives the above error

helm install myChart . --dry-run > myChart.yaml
kubectl apply -f myChart.yaml