ref(pkg/tiller): simplify exported methods

pkg/tiller/release_install.go

@@ -17,6 +17,7 @@ limitations under the License.
 package tiller
 
 import (
+	"bytes"
 	"fmt"
 	"strings"
 
@@ -169,7 +170,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
 			Timeout:  req.Timeout,
 		}
 		s.recordRelease(r, false)
-		if err := s.Update(old, r, updateReq, s.env); err != nil {
+		if err := s.Update(old, r, updateReq); err != nil {
 			msg := fmt.Sprintf("Release replace %q failed: %s", r.Name, err)
 			s.Log("warning: %s", msg)
 			old.Info.Status.Code = release.Status_SUPERSEDED
@@ -184,7 +185,8 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
 		// nothing to replace, create as normal
 		// regular manifests
 		s.recordRelease(r, false)
-		if err := s.Create(r, req, s.env); err != nil {
+		b := bytes.NewBufferString(r.Manifest)
+		if err := s.env.KubeClient.Create(r.Namespace, b, req.Timeout, req.Wait); err != nil {
 			msg := fmt.Sprintf("Release %q failed: %s", r.Name, err)
 			s.Log("warning: %s", msg)
 			r.Info.Status.Code = release.Status_FAILED

pkg/tiller/release_rollback.go

@@ -17,6 +17,7 @@ limitations under the License.
 package tiller
 
 import (
+	"bytes"
 	"fmt"
 
 	"k8s.io/helm/pkg/hooks"
@@ -125,7 +126,9 @@ func (s *ReleaseServer) performRollback(currentRelease, targetRelease *release.R
 		s.Log("rollback hooks disabled for %s", req.Name)
 	}
 
-	if err := s.Rollback(currentRelease, targetRelease, req, s.env); err != nil {
+	c := bytes.NewBufferString(currentRelease.Manifest)
+	t := bytes.NewBufferString(targetRelease.Manifest)
+	if err := s.env.KubeClient.Update(targetRelease.Namespace, c, t, req.Force, req.Recreate, req.Timeout, req.Wait); err != nil {
 		msg := fmt.Sprintf("Rollback %q failed: %s", targetRelease.Name, err)
 		s.Log("warning: %s", msg)
 		currentRelease.Info.Status.Code = release.Status_SUPERSEDED

pkg/tiller/release_server.go

@@ -37,7 +37,6 @@ import (
 	"k8s.io/helm/pkg/proto/hapi/release"
 	"k8s.io/helm/pkg/proto/hapi/services"
 	relutil "k8s.io/helm/pkg/releaseutil"
-	"k8s.io/helm/pkg/storage"
 	"k8s.io/helm/pkg/tiller/environment"
 	"k8s.io/helm/pkg/timeconv"
 	"k8s.io/helm/pkg/version"
@@ -97,10 +96,6 @@ func NewReleaseServer(env *environment.Environment, discovery discovery.Discover
 	}
 }
 
-func (s *ReleaseServer) Storage() *storage.Storage {
-	return s.env.Releases
-}
-
 // reuseValues copies values from the current release to a new release if the
 // new release does not have any values.
 //
@@ -339,7 +334,6 @@ func (s *ReleaseServer) recordRelease(r *release.Release, reuse bool) {
 }
 
 func (s *ReleaseServer) execHook(hs []*release.Hook, name, namespace, hook string, timeout int64) error {
-	kubeCli := s.env.KubeClient
 	code, ok := events[hook]
 	if !ok {
 		return fmt.Errorf("unknown hook %s", hook)
@@ -358,12 +352,12 @@ func (s *ReleaseServer) execHook(hs []*release.Hook, name, namespace, hook strin
 	executingHooks = sortByHookWeight(executingHooks)
 
 	for _, h := range executingHooks {
-		if err := s.deleteHookIfShouldBeDeletedByDeletePolicy(h, hooks.BeforeHookCreation, name, namespace, hook, kubeCli); err != nil {
+		if err := s.deleteHookIfShouldBeDeletedByDeletePolicy(h, hooks.BeforeHookCreation, name, namespace, hook, s.env.KubeClient); err != nil {
 			return err
 		}
 
 		b := bytes.NewBufferString(h.Manifest)
-		if err := kubeCli.Create(namespace, b, timeout, false); err != nil {
+		if err := s.env.KubeClient.Create(namespace, b, timeout, false); err != nil {
 			s.Log("warning: Release %s %s %s failed: %s", name, hook, h.Path, err)
 			return err
 		}
@@ -371,11 +365,11 @@ func (s *ReleaseServer) execHook(hs []*release.Hook, name, namespace, hook strin
 		b.Reset()
 		b.WriteString(h.Manifest)
 
-		if err := kubeCli.WatchUntilReady(namespace, b, timeout, false); err != nil {
+		if err := s.env.KubeClient.WatchUntilReady(namespace, b, timeout, false); err != nil {
 			s.Log("warning: Release %s %s %s could not complete: %s", name, hook, h.Path, err)
 			// If a hook is failed, checkout the annotation of the hook to determine whether the hook should be deleted
 			// under failed condition. If so, then clear the corresponding resource object in the hook
-			if err := s.deleteHookIfShouldBeDeletedByDeletePolicy(h, hooks.HookFailed, name, namespace, hook, kubeCli); err != nil {
+			if err := s.deleteHookIfShouldBeDeletedByDeletePolicy(h, hooks.HookFailed, name, namespace, hook, s.env.KubeClient); err != nil {
 				return err
 			}
 			return err
@@ -386,7 +380,7 @@ func (s *ReleaseServer) execHook(hs []*release.Hook, name, namespace, hook strin
 	// If all hooks are succeeded, checkout the annotation of each hook to determine whether the hook should be deleted
 	// under succeeded condition. If so, then clear the corresponding resource object in each hook
 	for _, h := range executingHooks {
-		if err := s.deleteHookIfShouldBeDeletedByDeletePolicy(h, hooks.HookSucceeded, name, namespace, hook, kubeCli); err != nil {
+		if err := s.deleteHookIfShouldBeDeletedByDeletePolicy(h, hooks.HookSucceeded, name, namespace, hook, s.env.KubeClient); err != nil {
 			return err
 		}
 		h.LastRun = timeconv.Now()
@@ -438,42 +432,20 @@ func hookHasDeletePolicy(h *release.Hook, policy string) bool {
 	return false
 }
 
-// Create creates a release via kubeclient from provided environment
-func (m *ReleaseServer) Create(r *release.Release, req *services.InstallReleaseRequest, env *environment.Environment) error {
-	b := bytes.NewBufferString(r.Manifest)
-	return env.KubeClient.Create(r.Namespace, b, req.Timeout, req.Wait)
-}
-
 // Update performs an update from current to target release
-func (m *ReleaseServer) Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error {
+func (s *ReleaseServer) Update(current, target *release.Release, req *services.UpdateReleaseRequest) error {
 	c := bytes.NewBufferString(current.Manifest)
 	t := bytes.NewBufferString(target.Manifest)
-	return env.KubeClient.Update(target.Namespace, c, t, req.Force, req.Recreate, req.Timeout, req.Wait)
+	return s.env.KubeClient.Update(target.Namespace, c, t, req.Force, req.Recreate, req.Timeout, req.Wait)
-}
-
-// Rollback performs a rollback from current to target release
-func (m *ReleaseServer) Rollback(current, target *release.Release, req *services.RollbackReleaseRequest, env *environment.Environment) error {
-	c := bytes.NewBufferString(current.Manifest)
-	t := bytes.NewBufferString(target.Manifest)
-	return env.KubeClient.Update(target.Namespace, c, t, req.Force, req.Recreate, req.Timeout, req.Wait)
-}
-
-// Status returns kubectl-like formatted status of release objects
-func (m *ReleaseServer) Status(r *release.Release, req *services.GetReleaseStatusRequest, env *environment.Environment) (string, error) {
-	return env.KubeClient.Get(r.Namespace, bytes.NewBufferString(r.Manifest))
 }
 
 // Delete deletes the release and returns manifests that were kept in the deletion process
-func (m *ReleaseServer) Delete(rel *release.Release, req *services.UninstallReleaseRequest, env *environment.Environment) (kept string, errs []error) {
+func (s *ReleaseServer) Delete(rel *release.Release, req *services.UninstallReleaseRequest) (kept string, errs []error) {
-	vs, err := GetVersionSet(m.discovery)
+	vs, err := GetVersionSet(s.discovery)
 	if err != nil {
 		return rel.Manifest, []error{fmt.Errorf("Could not get apiVersions from Kubernetes: %v", err)}
 	}
-	return DeleteRelease(rel, vs, env.KubeClient)
-}
 
-// DeleteRelease is a helper that allows Rudder to delete a release without exposing most of Tiller inner functions
-func DeleteRelease(rel *release.Release, vs chartutil.VersionSet, kubeClient environment.KubeClient) (kept string, errs []error) {
 	manifests := relutil.SplitManifests(rel.Manifest)
 	_, files, err := sortManifests(manifests, vs, UninstallOrder)
 	if err != nil {
@@ -486,7 +458,7 @@ func DeleteRelease(rel *release.Release, vs chartutil.VersionSet, kubeClient env
 
 	filesToKeep, filesToDelete := filterManifestsToKeep(files)
 	if len(filesToKeep) > 0 {
-		kept = summarizeKeptManifests(filesToKeep, kubeClient, rel.Namespace)
+		kept = summarizeKeptManifests(filesToKeep, s.env.KubeClient, rel.Namespace)
 	}
 
 	for _, file := range filesToDelete {
@@ -494,7 +466,7 @@ func DeleteRelease(rel *release.Release, vs chartutil.VersionSet, kubeClient env
 		if b.Len() == 0 {
 			continue
 		}
-		if err := kubeClient.Delete(rel.Namespace, b); err != nil {
+		if err := s.env.KubeClient.Delete(rel.Namespace, b); err != nil {
 			log.Printf("uninstall: Failed deletion of %q: %s", rel.Name, err)
 			if err == kube.ErrNoObjectsVisited {
 				// Rewrite the message from "no objects visited"

pkg/tiller/release_server_test.go

@@ -300,7 +300,7 @@ func TestValidName(t *testing.T) {
 		"abcdefghi-abcdefghi-abcdefghi-abcdefghi-abcdefghi-abcd": errInvalidName,
 	} {
 		if valid != validateReleaseName(name) {
-			t.Errorf("Expected %q to be %t", name, valid)
+			t.Errorf("Expected %q to be %s", name, valid)
 		}
 	}
 }

pkg/tiller/release_status.go

@@ -17,6 +17,7 @@ limitations under the License.
 package tiller
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 
@@ -62,7 +63,7 @@ func (s *ReleaseServer) GetReleaseStatus(req *services.GetReleaseStatusRequest)
 
 	// Ok, we got the status of the release as we had jotted down, now we need to match the
 	// manifest we stashed away with reality from the cluster.
-	resp, err := s.Status(rel, req, s.env)
+	resp, err := s.env.KubeClient.Get(rel.Namespace, bytes.NewBufferString(rel.Manifest))
 	if sc == release.Status_DELETED || sc == release.Status_FAILED {
 		// Skip errors if this is already deleted or failed.
 		return statusResp, nil

pkg/tiller/release_uninstall.go

@@ -79,18 +79,12 @@ func (s *ReleaseServer) UninstallRelease(req *services.UninstallReleaseRequest)
 		s.Log("uninstall: Failed to store updated release: %s", err)
 	}
 
-	kept, errs := s.Delete(rel, req, s.env)
+	kept, errs := s.Delete(rel, req)
 	res.Info = kept
 
-	es := make([]string, 0, len(errs))
-	for _, e := range errs {
-		s.Log("error: %v", e)
-		es = append(es, e.Error())
-	}
-
 	if !req.DisableHooks {
 		if err := s.execHook(rel.Hooks, rel.Name, rel.Namespace, hooks.PostDelete, req.Timeout); err != nil {
-			es = append(es, err.Error())
+			errs = append(errs, err)
 		}
 	}
 
@@ -110,12 +104,20 @@ func (s *ReleaseServer) UninstallRelease(req *services.UninstallReleaseRequest)
 		s.Log("uninstall: Failed to store updated release: %s", err)
 	}
 
-	if len(es) > 0 {
+	if len(errs) > 0 {
-		return res, fmt.Errorf("deletion completed with %d error(s): %s", len(es), strings.Join(es, "; "))
+		return res, fmt.Errorf("deletion completed with %d error(s): %s", len(errs), joinErrors(errs))
 	}
 	return res, nil
 }
 
+func joinErrors(errs []error) string {
+	es := make([]string, 0, len(errs))
+	for _, e := range errs {
+		es = append(es, e.Error())
+	}
+	return strings.Join(es, "; ")
+}
+
 func (s *ReleaseServer) purgeReleases(rels ...*release.Release) error {
 	for _, rel := range rels {
 		if _, err := s.env.Releases.Delete(rel.Name, rel.Version); err != nil {

pkg/tiller/release_update.go

@@ -186,19 +186,14 @@ func (s *ReleaseServer) performUpdateForce(req *services.UpdateReleaseRequest) (
 	}
 
 	// delete manifests from the old release
-	_, errs := s.Delete(oldRelease, nil, s.env)
+	_, errs := s.Delete(oldRelease, nil)
 
 	oldRelease.Info.Status.Code = release.Status_DELETED
 	oldRelease.Info.Description = "Deletion complete"
 	s.recordRelease(oldRelease, true)
 
 	if len(errs) > 0 {
-		es := make([]string, 0, len(errs))
+		return newRelease, fmt.Errorf("Upgrade --force successfully deleted the previous release, but encountered %d error(s) and cannot continue: %s", len(errs), joinErrors(errs))
-		for _, e := range errs {
-			s.Log("error: %v", e)
-			es = append(es, e.Error())
-		}
-		return newRelease, fmt.Errorf("Upgrade --force successfully deleted the previous release, but encountered %d error(s) and cannot continue: %s", len(es), strings.Join(es, "; "))
 	}
 
 	// post-delete hooks
@@ -218,7 +213,7 @@ func (s *ReleaseServer) performUpdateForce(req *services.UpdateReleaseRequest) (
 	// update new release with next revision number so as to append to the old release's history
 	newRelease.Version = oldRelease.Version + 1
 	s.recordRelease(newRelease, false)
-	if err := s.Update(oldRelease, newRelease, req, s.env); err != nil {
+	if err := s.Update(oldRelease, newRelease, req); err != nil {
 		msg := fmt.Sprintf("Upgrade %q failed: %s", newRelease.Name, err)
 		s.Log("warning: %s", msg)
 		newRelease.Info.Status.Code = release.Status_FAILED
@@ -262,7 +257,7 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
 	} else {
 		s.Log("update hooks disabled for %s", req.Name)
 	}
-	if err := s.Update(originalRelease, updatedRelease, req, s.env); err != nil {
+	if err := s.Update(originalRelease, updatedRelease, req); err != nil {
 		msg := fmt.Sprintf("Upgrade %q failed: %s", updatedRelease.Name, err)
 		s.Log("warning: %s", msg)
 		updatedRelease.Info.Status.Code = release.Status_FAILED