msb-public
/
helm
mirror of https://github.com/helm/helm
1
0
Code Issues Projects Releases Wiki Activity

ref(pkg/tiller): simplify exported methods

Browse Source
pull/3945/head
Adam Reese 7 years ago
parent 7f6fa70a91
commit 883371b8ce
No known key found for this signature in database
GPG Key ID: 06F35E60A7A18DD6
7 changed files with 38 additions and 63 deletions
Show Stats Download Patch File Download Diff File

6
pkg/tiller/release_install.go
Unescape View File

@ -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

5
pkg/tiller/release_rollback.go
Unescape View File

@ -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

50
pkg/tiller/release_server.go
Unescape View File

@ -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)
}
// 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))
return s.env.KubeClient.Update(target.Namespace, c, t, req.Force, req.Recreate, req.Timeout, req.Wait)
}
// 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) {
vs, err := GetVersionSet(m.discovery)
func (s *ReleaseServer) Delete(rel *release.Release, req *services.UninstallReleaseRequest) (kept string, errs []error) {
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"

2
pkg/tiller/release_server_test.go
Unescape View File

@ -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)
}
}
}

3
pkg/tiller/release_status.go
Unescape View File

@ -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

22
pkg/tiller/release_uninstall.go
Unescape View File

@ -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 {
return res, fmt.Errorf("deletion completed with %d error(s): %s", len(es), strings.Join(es, "; "))
if len(errs) > 0 {
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 {

13
pkg/tiller/release_update.go
Unescape View File

@ -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))
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, "; "))
return newRelease, fmt.Errorf("Upgrade --force successfully deleted the previous release, but encountered %d error(s) and cannot continue: %s", len(errs), joinErrors(errs))
}
// 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

Write Preview
Loading…
Cancel
Save