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

replace interface with function

Browse Source
pull/2394/head
Adam Reese 8 years ago
parent e268d18b7a
commit d89ba3f813
No known key found for this signature in database
GPG Key ID: 06F35E60A7A18DD6
10 changed files with 116 additions and 174 deletions
Show Stats Download Patch File Download Diff File

31
cmd/tiller/tiller.go
Unescape View File

@ -70,6 +70,8 @@ var rootServer *grpc.Server
// Any changes to env should be done before rootServer.Serve() is called. // Any changes to env should be done before rootServer.Serve() is called.
var env = environment.New() var env = environment.New()
var logger *log.Logger
var ( var (
grpcAddr = ":44134" grpcAddr = ":44134"
probeAddr = ":44135" probeAddr = ":44135"
@ -111,6 +113,7 @@ func initLog() {
if enableTracing { if enableTracing {
log.SetFlags(log.Lshortfile) log.SetFlags(log.Lshortfile)
} }
logger = newLogger("main")
} }
func main() { func main() {
@ -126,7 +129,7 @@ func main() {
addFlags(root.Flags()) addFlags(root.Flags())
if err := root.Execute(); err != nil { if err := root.Execute(); err != nil {
log.Fatal(err) logger.Fatal(err)
} }
} }
@ -140,7 +143,7 @@ func newLogger(prefix string) *log.Logger {
func start(c *cobra.Command, args []string) { func start(c *cobra.Command, args []string) {
clientset, err := kube.New(nil).ClientSet() clientset, err := kube.New(nil).ClientSet()
if err != nil { if err != nil {
log.Fatalf("Cannot initialize Kubernetes connection: %s", err) logger.Fatalf("Cannot initialize Kubernetes connection: %s", err)
} }
switch store { switch store {
@ -148,14 +151,14 @@ func start(c *cobra.Command, args []string) {
env.Releases = storage.Init(driver.NewMemory()) env.Releases = storage.Init(driver.NewMemory())
case storageConfigMap: case storageConfigMap:
cfgmaps := driver.NewConfigMaps(clientset.Core().ConfigMaps(namespace())) cfgmaps := driver.NewConfigMaps(clientset.Core().ConfigMaps(namespace()))
cfgmaps.Logger = newLogger("storage/driver") cfgmaps.Log = newLogger("storage/driver").Printf
env.Releases = storage.Init(cfgmaps) env.Releases = storage.Init(cfgmaps)
env.Releases.Logger = newLogger("storage") env.Releases.Log = newLogger("storage").Printf
} }
kubeClient := kube.New(nil) kubeClient := kube.New(nil)
kubeClient.Logger = newLogger("kube") kubeClient.Log = newLogger("kube").Printf
env.KubeClient = kubeClient env.KubeClient = kubeClient
if tlsEnable || tlsVerify { if tlsEnable || tlsVerify {
@ -169,7 +172,7 @@ func start(c *cobra.Command, args []string) {
if tlsEnable || tlsVerify { if tlsEnable || tlsVerify {
cfg, err := tlsutil.ServerConfig(tlsOptions()) cfg, err := tlsutil.ServerConfig(tlsOptions())
if err != nil { if err != nil {
log.Fatalf("Could not create server TLS configuration: %v", err) logger.Fatalf("Could not create server TLS configuration: %v", err)
} }
opts = append(opts, grpc.Creds(credentials.NewTLS(cfg))) opts = append(opts, grpc.Creds(credentials.NewTLS(cfg)))
} }
@ -178,13 +181,13 @@ func start(c *cobra.Command, args []string) {
lstn, err := net.Listen("tcp", grpcAddr) lstn, err := net.Listen("tcp", grpcAddr)
if err != nil { if err != nil {
log.Fatalf("Server died: %s", err) logger.Fatalf("Server died: %s", err)
} }
log.Printf("Starting Tiller %s (tls=%t)", version.GetVersion(), tlsEnable || tlsVerify) logger.Printf("Starting Tiller %s (tls=%t)", version.GetVersion(), tlsEnable || tlsVerify)
log.Printf("GRPC listening on %s", grpcAddr) logger.Printf("GRPC listening on %s", grpcAddr)
log.Printf("Probes listening on %s", probeAddr) logger.Printf("Probes listening on %s", probeAddr)
log.Printf("Storage driver is %s", env.Releases.Name()) logger.Printf("Storage driver is %s", env.Releases.Name())
if enableTracing { if enableTracing {
startTracing(traceAddr) startTracing(traceAddr)
@ -194,7 +197,7 @@ func start(c *cobra.Command, args []string) {
probeErrCh := make(chan error) probeErrCh := make(chan error)
go func() { go func() {
svc := tiller.NewReleaseServer(env, clientset, remoteReleaseModules) svc := tiller.NewReleaseServer(env, clientset, remoteReleaseModules)
svc.Logger = newLogger("tiller") svc.Log = newLogger("tiller").Printf
services.RegisterReleaseServiceServer(rootServer, svc) services.RegisterReleaseServiceServer(rootServer, svc)
if err := rootServer.Serve(lstn); err != nil { if err := rootServer.Serve(lstn); err != nil {
srvErrCh <- err srvErrCh <- err
@ -215,9 +218,9 @@ func start(c *cobra.Command, args []string) {
select { select {
case err := <-srvErrCh: case err := <-srvErrCh:
log.Fatalf("Server died: %s", err) logger.Fatalf("Server died: %s", err)
case err := <-probeErrCh: case err := <-probeErrCh:
log.Printf("Probes server died: %s", err) logger.Printf("Probes server died: %s", err)
} }
} }

5
cmd/tiller/trace.go
Unescape View File

@ -17,7 +17,6 @@ limitations under the License.
package main // import "k8s.io/helm/cmd/tiller" package main // import "k8s.io/helm/cmd/tiller"
import ( import (
"log"
"net/http" "net/http"
_ "net/http/pprof" _ "net/http/pprof"
@ -26,7 +25,7 @@ import (
) )
func startTracing(addr string) { func startTracing(addr string) {
log.Printf("Tracing server is listening on %s\n", addr) logger.Printf("Tracing server is listening on %s\n", addr)
grpc.EnableTracing = true grpc.EnableTracing = true
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
@ -40,7 +39,7 @@ func startTracing(addr string) {
go func() { go func() {
if err := http.ListenAndServe(addr, nil); err != nil { if err := http.ListenAndServe(addr, nil); err != nil {
log.Printf("tracing error: %s", err) logger.Printf("tracing error: %s", err)
} }
}() }()
} }

48
pkg/kube/client.go
Unescape View File

@ -49,8 +49,6 @@ import (
cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
"k8s.io/kubernetes/pkg/kubectl/resource" "k8s.io/kubernetes/pkg/kubectl/resource"
"k8s.io/kubernetes/pkg/printers" "k8s.io/kubernetes/pkg/printers"
"k8s.io/helm/pkg/logger"
) )
// ErrNoObjectsVisited indicates that during a visit operation, no matching objects were found. // ErrNoObjectsVisited indicates that during a visit operation, no matching objects were found.
@ -62,7 +60,7 @@ type Client struct {
// SchemaCacheDir is the path for loading cached schema. // SchemaCacheDir is the path for loading cached schema.
SchemaCacheDir string SchemaCacheDir string
Logger logger.Logger Log func(string, ...interface{})
} }
// New create a new Client // New create a new Client
@ -70,7 +68,7 @@ func New(config clientcmd.ClientConfig) *Client {
return &Client{ return &Client{
Factory: cmdutil.NewFactory(config), Factory: cmdutil.NewFactory(config),
SchemaCacheDir: clientcmd.RecommendedSchemaFile, SchemaCacheDir: clientcmd.RecommendedSchemaFile,
Logger: logger.DefaultLogger, Log: func(_ string, _ ...interface{}) {},
} }
} }
@ -104,7 +102,7 @@ func (c *Client) Create(namespace string, reader io.Reader, timeout int64, shoul
func (c *Client) newBuilder(namespace string, reader io.Reader) *resource.Result { func (c *Client) newBuilder(namespace string, reader io.Reader) *resource.Result {
schema, err := c.Validator(true, c.SchemaCacheDir) schema, err := c.Validator(true, c.SchemaCacheDir)
if err != nil { if err != nil {
c.Logger.Printf("warning: failed to load schema: %s", err) c.Log("warning: failed to load schema: %s", err)
} }
return c.NewBuilder(). return c.NewBuilder().
ContinueOnError(). ContinueOnError().
@ -120,12 +118,12 @@ func (c *Client) newBuilder(namespace string, reader io.Reader) *resource.Result
func (c *Client) BuildUnstructured(namespace string, reader io.Reader) (Result, error) { func (c *Client) BuildUnstructured(namespace string, reader io.Reader) (Result, error) {
schema, err := c.Validator(true, c.SchemaCacheDir) schema, err := c.Validator(true, c.SchemaCacheDir)
if err != nil { if err != nil {
c.Logger.Printf("warning: failed to load schema: %s", err) c.Log("warning: failed to load schema: %s", err)
} }
mapper, typer, err := c.UnstructuredObject() mapper, typer, err := c.UnstructuredObject()
if err != nil { if err != nil {
c.Logger.Printf("failed to load mapper: %s", err) c.Log("failed to load mapper: %s", err)
return nil, err return nil, err
} }
var result Result var result Result
@ -160,9 +158,9 @@ func (c *Client) Get(namespace string, reader io.Reader) (string, error) {
} }
missing := []string{} missing := []string{}
err = perform(infos, func(info *resource.Info) error { err = perform(infos, func(info *resource.Info) error {
c.Logger.Printf("Doing get for %s: %q", info.Mapping.GroupVersionKind.Kind, info.Name) c.Log("Doing get for %s: %q", info.Mapping.GroupVersionKind.Kind, info.Name)
if err := info.Get(); err != nil { if err := info.Get(); err != nil {
c.Logger.Printf("WARNING: Failed Get for resource %q: %s", info.Name, err) c.Log("WARNING: Failed Get for resource %q: %s", info.Name, err)
missing = append(missing, fmt.Sprintf("%v\t\t%s", info.Mapping.Resource, info.Name)) missing = append(missing, fmt.Sprintf("%v\t\t%s", info.Mapping.Resource, info.Name))
return nil return nil
} }
@ -190,7 +188,7 @@ func (c *Client) Get(namespace string, reader io.Reader) (string, error) {
} }
for _, o := range ot { for _, o := range ot {
if err := p.PrintObj(o, buf); err != nil { if err := p.PrintObj(o, buf); err != nil {
c.Logger.Printf("failed to print object type %s, object: %q :\n %v", t, o, err) c.Log("failed to print object type %s, object: %q :\n %v", t, o, err)
return "", err return "", err
} }
} }
@ -243,7 +241,7 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader
} }
kind := info.Mapping.GroupVersionKind.Kind kind := info.Mapping.GroupVersionKind.Kind
c.Logger.Printf("Created a new %s called %q\n", kind, info.Name) c.Log("Created a new %s called %q\n", kind, info.Name)
return nil return nil
} }
@ -253,7 +251,7 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader
} }
if err := updateResource(c, info, originalInfo.Object, recreate); err != nil { if err := updateResource(c, info, originalInfo.Object, recreate); err != nil {
c.Logger.Printf("error updating the resource %q:\n\t %v", info.Name, err) c.Log("error updating the resource %q:\n\t %v", info.Name, err)
updateErrors = append(updateErrors, err.Error()) updateErrors = append(updateErrors, err.Error())
} }
@ -268,9 +266,9 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader
} }
for _, info := range original.Difference(target) { for _, info := range original.Difference(target) {
c.Logger.Printf("Deleting %q in %s...", info.Name, info.Namespace) c.Log("Deleting %q in %s...", info.Name, info.Namespace)
if err := deleteResource(c, info); err != nil { if err := deleteResource(c, info); err != nil {
c.Logger.Printf("Failed to delete %q, err: %s", info.Name, err) c.Log("Failed to delete %q, err: %s", info.Name, err)
} }
} }
if shouldWait { if shouldWait {
@ -288,7 +286,7 @@ func (c *Client) Delete(namespace string, reader io.Reader) error {
return err return err
} }
return perform(infos, func(info *resource.Info) error { return perform(infos, func(info *resource.Info) error {
c.Logger.Printf("Starting delete for %q %s", info.Name, info.Mapping.GroupVersionKind.Kind) c.Log("Starting delete for %q %s", info.Name, info.Mapping.GroupVersionKind.Kind)
err := deleteResource(c, info) err := deleteResource(c, info)
return c.skipIfNotFound(err) return c.skipIfNotFound(err)
}) })
@ -296,7 +294,7 @@ func (c *Client) Delete(namespace string, reader io.Reader) error {
func (c *Client) skipIfNotFound(err error) error { func (c *Client) skipIfNotFound(err error) error {
if errors.IsNotFound(err) { if errors.IsNotFound(err) {
c.Logger.Printf("%v", err) c.Log("%v", err)
return nil return nil
} }
return err return err
@ -360,7 +358,7 @@ func deleteResource(c *Client, info *resource.Info) error {
} }
return err return err
} }
c.Logger.Printf("Using reaper for deleting %q", info.Name) c.Log("Using reaper for deleting %q", info.Name)
return reaper.Stop(info.Namespace, info.Name, 0, nil) return reaper.Stop(info.Namespace, info.Name, 0, nil)
} }
@ -400,7 +398,7 @@ func updateResource(c *Client, target *resource.Info, currentObj runtime.Object,
return fmt.Errorf("failed to create patch: %s", err) return fmt.Errorf("failed to create patch: %s", err)
} }
if patch == nil { if patch == nil {
c.Logger.Printf("Looks like there are no changes for %s %q", target.Mapping.GroupVersionKind.Kind, target.Name) c.Log("Looks like there are no changes for %s %q", target.Mapping.GroupVersionKind.Kind, target.Name)
// This needs to happen to make sure that tiller has the latest info from the API // This needs to happen to make sure that tiller has the latest info from the API
// Otherwise there will be no labels and other functions that use labels will panic // Otherwise there will be no labels and other functions that use labels will panic
if err := target.Get(); err != nil { if err := target.Get(); err != nil {
@ -450,7 +448,7 @@ func updateResource(c *Client, target *resource.Info, currentObj runtime.Object,
// Restart pods // Restart pods
for _, pod := range pods.Items { for _, pod := range pods.Items {
c.Logger.Printf("Restarting pod: %v/%v", pod.Namespace, pod.Name) c.Log("Restarting pod: %v/%v", pod.Namespace, pod.Name)
// Delete each pod for get them restarted with changed spec. // Delete each pod for get them restarted with changed spec.
if err := client.Core().Pods(pod.Namespace).Delete(pod.Name, metav1.NewPreconditionDeleteOptions(string(pod.UID))); err != nil { if err := client.Core().Pods(pod.Namespace).Delete(pod.Name, metav1.NewPreconditionDeleteOptions(string(pod.UID))); err != nil {
@ -486,7 +484,7 @@ func (c *Client) watchUntilReady(timeout time.Duration, info *resource.Info) err
} }
kind := info.Mapping.GroupVersionKind.Kind kind := info.Mapping.GroupVersionKind.Kind
c.Logger.Printf("Watching for changes to %s %s with timeout of %v", kind, info.Name, timeout) c.Log("Watching for changes to %s %s with timeout of %v", kind, info.Name, timeout)
// What we watch for depends on the Kind. // What we watch for depends on the Kind.
// - For a Job, we watch for completion. // - For a Job, we watch for completion.
@ -501,17 +499,17 @@ func (c *Client) watchUntilReady(timeout time.Duration, info *resource.Info) err
// we get. We care mostly about jobs, where what we want to see is // we get. We care mostly about jobs, where what we want to see is
// the status go into a good state. For other types, like ReplicaSet // the status go into a good state. For other types, like ReplicaSet
// we don't really do anything to support these as hooks. // we don't really do anything to support these as hooks.
c.Logger.Printf("Add/Modify event for %s: %v", info.Name, e.Type) c.Log("Add/Modify event for %s: %v", info.Name, e.Type)
if kind == "Job" { if kind == "Job" {
return c.waitForJob(e, info.Name) return c.waitForJob(e, info.Name)
} }
return true, nil return true, nil
case watch.Deleted: case watch.Deleted:
c.Logger.Printf("Deleted event for %s", info.Name) c.Log("Deleted event for %s", info.Name)
return true, nil return true, nil
case watch.Error: case watch.Error:
// Handle error and return with an error. // Handle error and return with an error.
c.Logger.Printf("Error event for %s", info.Name) c.Log("Error event for %s", info.Name)
return true, fmt.Errorf("Failed to deploy %s", info.Name) return true, fmt.Errorf("Failed to deploy %s", info.Name)
default: default:
return false, nil return false, nil
@ -548,7 +546,7 @@ func (c *Client) waitForJob(e watch.Event, name string) (bool, error) {
} }
} }
c.Logger.Printf("%s: Jobs active: %d, jobs failed: %d, jobs succeeded: %d", name, o.Status.Active, o.Status.Failed, o.Status.Succeeded) c.Log("%s: Jobs active: %d, jobs failed: %d, jobs succeeded: %d", name, o.Status.Active, o.Status.Failed, o.Status.Succeeded)
return false, nil return false, nil
} }
@ -597,7 +595,7 @@ func (c *Client) watchPodUntilComplete(timeout time.Duration, info *resource.Inf
return err return err
} }
c.Logger.Printf("Watching pod %s for completion with timeout of %v", info.Name, timeout) c.Log("Watching pod %s for completion with timeout of %v", info.Name, timeout)
_, err = watch.Until(timeout, w, func(e watch.Event) (bool, error) { _, err = watch.Until(timeout, w, func(e watch.Event) (bool, error) {
return conditions.PodCompleted(e) return conditions.PodCompleted(e)
}) })

9
pkg/kube/client_test.go
Unescape View File

@ -42,8 +42,6 @@ import (
"k8s.io/kubernetes/pkg/kubectl/resource" "k8s.io/kubernetes/pkg/kubectl/resource"
"k8s.io/kubernetes/pkg/printers" "k8s.io/kubernetes/pkg/printers"
watchjson "k8s.io/kubernetes/pkg/watch/json" watchjson "k8s.io/kubernetes/pkg/watch/json"
"k8s.io/helm/pkg/logger"
) )
func objBody(codec runtime.Codec, obj runtime.Object) io.ReadCloser { func objBody(codec runtime.Codec, obj runtime.Object) io.ReadCloser {
@ -141,10 +139,9 @@ func encodeAndMarshalEvent(e *watch.Event) ([]byte, error) {
} }
func newTestClient(f cmdutil.Factory) *Client { func newTestClient(f cmdutil.Factory) *Client {
return &Client{ c := New(nil)
Factory: f, c.Factory = f
Logger: logger.NewNopLogger(), return c
}
} }
func TestUpdate(t *testing.T) { func TestUpdate(t *testing.T) {

18
pkg/logger/doc.go
Unescape View File

@ -1,18 +0,0 @@
/*
Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Package logger provides an abstract interface for logging.
package logger // import "k8s.io/helm/pkg/logger"

36
pkg/logger/logger.go
Unescape View File

@ -1,36 +0,0 @@
/*
Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package logger // import "k8s.io/helm/pkg/logger"
// Logger provides a generic way of handling logging.
type Logger interface {
Printf(format string, args ...interface{})
}
// Func is an adaptor to allow the use of ordinary functions as loggers.
type Func func(string, ...interface{})
// Printf implements Logger.
func (l Func) Printf(format string, args ...interface{}) {
l(format, args...)
}
// DefaultLogger is a globally set Logger used when initializing clients.
var DefaultLogger Logger = NewNopLogger()
// NewNopLogger returns a Logger that does nothing.
func NewNopLogger() Func { return func(_ string, _ ...interface{}) {} }

30
pkg/storage/driver/cfgmaps.go
Unescape View File

@ -34,7 +34,6 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion" "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
"k8s.io/helm/pkg/logger"
rspb "k8s.io/helm/pkg/proto/hapi/release" rspb "k8s.io/helm/pkg/proto/hapi/release"
) )
@ -51,13 +50,16 @@ var magicGzip = []byte{0x1f, 0x8b, 0x08}
// ConfigMapsInterface. // ConfigMapsInterface.
type ConfigMaps struct { type ConfigMaps struct {
impl internalversion.ConfigMapInterface impl internalversion.ConfigMapInterface
Logger logger.Logger Log func(string, ...interface{})
} }
// NewConfigMaps initializes a new ConfigMaps wrapping an implmenetation of // NewConfigMaps initializes a new ConfigMaps wrapping an implmenetation of
// the kubernetes ConfigMapsInterface. // the kubernetes ConfigMapsInterface.
func NewConfigMaps(impl internalversion.ConfigMapInterface) *ConfigMaps { func NewConfigMaps(impl internalversion.ConfigMapInterface) *ConfigMaps {
return &ConfigMaps{impl: impl} return &ConfigMaps{
impl: impl,
Log: func(_ string, _ ...interface{}) {},
}
} }
// Name returns the name of the driver. // Name returns the name of the driver.
@ -75,13 +77,13 @@ func (cfgmaps *ConfigMaps) Get(key string) (*rspb.Release, error) {
return nil, ErrReleaseNotFound(key) return nil, ErrReleaseNotFound(key)
} }
cfgmaps.Logger.Printf("get: failed to get %q: %s", key, err) cfgmaps.Log("get: failed to get %q: %s", key, err)
return nil, err return nil, err
} }
// found the configmap, decode the base64 data string // found the configmap, decode the base64 data string
r, err := decodeRelease(obj.Data["release"]) r, err := decodeRelease(obj.Data["release"])
if err != nil { if err != nil {
cfgmaps.Logger.Printf("get: failed to decode data %q: %s", key, err) cfgmaps.Log("get: failed to decode data %q: %s", key, err)
return nil, err return nil, err
} }
// return the release object // return the release object
@ -97,7 +99,7 @@ func (cfgmaps *ConfigMaps) List(filter func(*rspb.Release) bool) ([]*rspb.Releas
list, err := cfgmaps.impl.List(opts) list, err := cfgmaps.impl.List(opts)
if err != nil { if err != nil {
cfgmaps.Logger.Printf("list: failed to list: %s", err) cfgmaps.Log("list: failed to list: %s", err)
return nil, err return nil, err
} }
@ -108,7 +110,7 @@ func (cfgmaps *ConfigMaps) List(filter func(*rspb.Release) bool) ([]*rspb.Releas
for _, item := range list.Items { for _, item := range list.Items {
rls, err := decodeRelease(item.Data["release"]) rls, err := decodeRelease(item.Data["release"])
if err != nil { if err != nil {
cfgmaps.Logger.Printf("list: failed to decode release: %v: %s", item, err) cfgmaps.Log("list: failed to decode release: %v: %s", item, err)
continue continue
} }
if filter(rls) { if filter(rls) {
@ -133,7 +135,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
list, err := cfgmaps.impl.List(opts) list, err := cfgmaps.impl.List(opts)
if err != nil { if err != nil {
cfgmaps.Logger.Printf("query: failed to query with labels: %s", err) cfgmaps.Log("query: failed to query with labels: %s", err)
return nil, err return nil, err
} }
@ -145,7 +147,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
for _, item := range list.Items { for _, item := range list.Items {
rls, err := decodeRelease(item.Data["release"]) rls, err := decodeRelease(item.Data["release"])
if err != nil { if err != nil {
cfgmaps.Logger.Printf("query: failed to decode release: %s", err) cfgmaps.Log("query: failed to decode release: %s", err)
continue continue
} }
results = append(results, rls) results = append(results, rls)
@ -165,7 +167,7 @@ func (cfgmaps *ConfigMaps) Create(key string, rls *rspb.Release) error {
// create a new configmap to hold the release // create a new configmap to hold the release
obj, err := newConfigMapsObject(key, rls, lbs) obj, err := newConfigMapsObject(key, rls, lbs)
if err != nil { if err != nil {
cfgmaps.Logger.Printf("create: failed to encode release %q: %s", rls.Name, err) cfgmaps.Log("create: failed to encode release %q: %s", rls.Name, err)
return err return err
} }
// push the configmap object out into the kubiverse // push the configmap object out into the kubiverse
@ -174,7 +176,7 @@ func (cfgmaps *ConfigMaps) Create(key string, rls *rspb.Release) error {
return ErrReleaseExists(rls.Name) return ErrReleaseExists(rls.Name)
} }
cfgmaps.Logger.Printf("create: failed to create: %s", err) cfgmaps.Log("create: failed to create: %s", err)
return err return err
} }
return nil return nil
@ -192,13 +194,13 @@ func (cfgmaps *ConfigMaps) Update(key string, rls *rspb.Release) error {
// create a new configmap object to hold the release // create a new configmap object to hold the release
obj, err := newConfigMapsObject(key, rls, lbs) obj, err := newConfigMapsObject(key, rls, lbs)
if err != nil { if err != nil {
cfgmaps.Logger.Printf("update: failed to encode release %q: %s", rls.Name, err) cfgmaps.Log("update: failed to encode release %q: %s", rls.Name, err)
return err return err
} }
// push the configmap object out into the kubiverse // push the configmap object out into the kubiverse
_, err = cfgmaps.impl.Update(obj) _, err = cfgmaps.impl.Update(obj)
if err != nil { if err != nil {
cfgmaps.Logger.Printf("update: failed to update: %s", err) cfgmaps.Log("update: failed to update: %s", err)
return err return err
} }
return nil return nil
@ -212,7 +214,7 @@ func (cfgmaps *ConfigMaps) Delete(key string) (rls *rspb.Release, err error) {
return nil, ErrReleaseExists(rls.Name) return nil, ErrReleaseExists(rls.Name)
} }
cfgmaps.Logger.Printf("delete: failed to get release %q: %s", key, err) cfgmaps.Log("delete: failed to get release %q: %s", key, err)
return nil, err return nil, err
} }
// delete the release // delete the release

29
pkg/storage/storage.go
Unescape View File

@ -20,7 +20,6 @@ import (
"fmt" "fmt"
"sync" "sync"
"k8s.io/helm/pkg/logger"
rspb "k8s.io/helm/pkg/proto/hapi/release" rspb "k8s.io/helm/pkg/proto/hapi/release"
relutil "k8s.io/helm/pkg/releaseutil" relutil "k8s.io/helm/pkg/releaseutil"
"k8s.io/helm/pkg/storage/driver" "k8s.io/helm/pkg/storage/driver"
@ -35,14 +34,14 @@ type Storage struct {
// releaseLocksLock is a mutex for accessing releaseLocks // releaseLocksLock is a mutex for accessing releaseLocks
releaseLocksLock *sync.Mutex releaseLocksLock *sync.Mutex
Logger logger.Logger Log func(string, ...interface{})
} }
// Get retrieves the release from storage. An error is returned // Get retrieves the release from storage. An error is returned
// if the storage driver failed to fetch the release, or the // if the storage driver failed to fetch the release, or the
// release identified by the key, version pair does not exist. // release identified by the key, version pair does not exist.
func (s *Storage) Get(name string, version int32) (*rspb.Release, error) { func (s *Storage) Get(name string, version int32) (*rspb.Release, error) {
s.Logger.Printf("Getting release %q", makeKey(name, version)) s.Log("Getting release %q", makeKey(name, version))
return s.Driver.Get(makeKey(name, version)) return s.Driver.Get(makeKey(name, version))
} }
@ -50,7 +49,7 @@ func (s *Storage) Get(name string, version int32) (*rspb.Release, error) {
// error is returned if the storage driver failed to store the // error is returned if the storage driver failed to store the
// release, or a release with identical an key already exists. // release, or a release with identical an key already exists.
func (s *Storage) Create(rls *rspb.Release) error { func (s *Storage) Create(rls *rspb.Release) error {
s.Logger.Printf("Creating release %q", makeKey(rls.Name, rls.Version)) s.Log("Creating release %q", makeKey(rls.Name, rls.Version))
return s.Driver.Create(makeKey(rls.Name, rls.Version), rls) return s.Driver.Create(makeKey(rls.Name, rls.Version), rls)
} }
@ -58,7 +57,7 @@ func (s *Storage) Create(rls *rspb.Release) error {
// storage backend fails to update the release or if the release // storage backend fails to update the release or if the release
// does not exist. // does not exist.
func (s *Storage) Update(rls *rspb.Release) error { func (s *Storage) Update(rls *rspb.Release) error {
s.Logger.Printf("Updating release %q", makeKey(rls.Name, rls.Version)) s.Log("Updating release %q", makeKey(rls.Name, rls.Version))
return s.Driver.Update(makeKey(rls.Name, rls.Version), rls) return s.Driver.Update(makeKey(rls.Name, rls.Version), rls)
} }
@ -66,21 +65,21 @@ func (s *Storage) Update(rls *rspb.Release) error {
// the storage backend fails to delete the release or if the release // the storage backend fails to delete the release or if the release
// does not exist. // does not exist.
func (s *Storage) Delete(name string, version int32) (*rspb.Release, error) { func (s *Storage) Delete(name string, version int32) (*rspb.Release, error) {
s.Logger.Printf("Deleting release %q", makeKey(name, version)) s.Log("Deleting release %q", makeKey(name, version))
return s.Driver.Delete(makeKey(name, version)) return s.Driver.Delete(makeKey(name, version))
} }
// ListReleases returns all releases from storage. An error is returned if the // ListReleases returns all releases from storage. An error is returned if the
// storage backend fails to retrieve the releases. // storage backend fails to retrieve the releases.
func (s *Storage) ListReleases() ([]*rspb.Release, error) { func (s *Storage) ListReleases() ([]*rspb.Release, error) {
s.Logger.Printf("Listing all releases in storage") s.Log("Listing all releases in storage")
return s.Driver.List(func(_ *rspb.Release) bool { return true }) return s.Driver.List(func(_ *rspb.Release) bool { return true })
} }
// ListDeleted returns all releases with Status == DELETED. An error is returned // ListDeleted returns all releases with Status == DELETED. An error is returned
// if the storage backend fails to retrieve the releases. // if the storage backend fails to retrieve the releases.
func (s *Storage) ListDeleted() ([]*rspb.Release, error) { func (s *Storage) ListDeleted() ([]*rspb.Release, error) {
s.Logger.Printf("Listing deleted releases in storage") s.Log("Listing deleted releases in storage")
return s.Driver.List(func(rls *rspb.Release) bool { return s.Driver.List(func(rls *rspb.Release) bool {
return relutil.StatusFilter(rspb.Status_DELETED).Check(rls) return relutil.StatusFilter(rspb.Status_DELETED).Check(rls)
}) })
@ -89,7 +88,7 @@ func (s *Storage) ListDeleted() ([]*rspb.Release, error) {
// ListDeployed returns all releases with Status == DEPLOYED. An error is returned // ListDeployed returns all releases with Status == DEPLOYED. An error is returned
// if the storage backend fails to retrieve the releases. // if the storage backend fails to retrieve the releases.
func (s *Storage) ListDeployed() ([]*rspb.Release, error) { func (s *Storage) ListDeployed() ([]*rspb.Release, error) {
s.Logger.Printf("Listing all deployed releases in storage") s.Log("Listing all deployed releases in storage")
return s.Driver.List(func(rls *rspb.Release) bool { return s.Driver.List(func(rls *rspb.Release) bool {
return relutil.StatusFilter(rspb.Status_DEPLOYED).Check(rls) return relutil.StatusFilter(rspb.Status_DEPLOYED).Check(rls)
}) })
@ -99,7 +98,7 @@ func (s *Storage) ListDeployed() ([]*rspb.Release, error) {
// (filter0 && filter1 && ... && filterN), i.e. a Release is included in the results // (filter0 && filter1 && ... && filterN), i.e. a Release is included in the results
// if and only if all filters return true. // if and only if all filters return true.
func (s *Storage) ListFilterAll(fns ...relutil.FilterFunc) ([]*rspb.Release, error) { func (s *Storage) ListFilterAll(fns ...relutil.FilterFunc) ([]*rspb.Release, error) {
s.Logger.Printf("Listing all releases with filter") s.Log("Listing all releases with filter")
return s.Driver.List(func(rls *rspb.Release) bool { return s.Driver.List(func(rls *rspb.Release) bool {
return relutil.All(fns...).Check(rls) return relutil.All(fns...).Check(rls)
}) })
@ -109,7 +108,7 @@ func (s *Storage) ListFilterAll(fns ...relutil.FilterFunc) ([]*rspb.Release, err
// (filter0 || filter1 || ... || filterN), i.e. a Release is included in the results // (filter0 || filter1 || ... || filterN), i.e. a Release is included in the results
// if at least one of the filters returns true. // if at least one of the filters returns true.
func (s *Storage) ListFilterAny(fns ...relutil.FilterFunc) ([]*rspb.Release, error) { func (s *Storage) ListFilterAny(fns ...relutil.FilterFunc) ([]*rspb.Release, error) {
s.Logger.Printf("Listing any releases with filter") s.Log("Listing any releases with filter")
return s.Driver.List(func(rls *rspb.Release) bool { return s.Driver.List(func(rls *rspb.Release) bool {
return relutil.Any(fns...).Check(rls) return relutil.Any(fns...).Check(rls)
}) })
@ -118,7 +117,7 @@ func (s *Storage) ListFilterAny(fns ...relutil.FilterFunc) ([]*rspb.Release, err
// Deployed returns the deployed release with the provided release name, or // Deployed returns the deployed release with the provided release name, or
// returns ErrReleaseNotFound if not found. // returns ErrReleaseNotFound if not found.
func (s *Storage) Deployed(name string) (*rspb.Release, error) { func (s *Storage) Deployed(name string) (*rspb.Release, error) {
s.Logger.Printf("Getting deployed release from %q history", name) s.Log("Getting deployed release from %q history", name)
ls, err := s.Driver.Query(map[string]string{ ls, err := s.Driver.Query(map[string]string{
"NAME": name, "NAME": name,
@ -138,14 +137,14 @@ func (s *Storage) Deployed(name string) (*rspb.Release, error) {
// History returns the revision history for the release with the provided name, or // History returns the revision history for the release with the provided name, or
// returns ErrReleaseNotFound if no such release name exists. // returns ErrReleaseNotFound if no such release name exists.
func (s *Storage) History(name string) ([]*rspb.Release, error) { func (s *Storage) History(name string) ([]*rspb.Release, error) {
s.Logger.Printf("Getting release history for %q", name) s.Log("Getting release history for %q", name)
return s.Driver.Query(map[string]string{"NAME": name, "OWNER": "TILLER"}) return s.Driver.Query(map[string]string{"NAME": name, "OWNER": "TILLER"})
} }
// Last fetches the last revision of the named release. // Last fetches the last revision of the named release.
func (s *Storage) Last(name string) (*rspb.Release, error) { func (s *Storage) Last(name string) (*rspb.Release, error) {
s.Logger.Printf("Getting last revision of %q", name) s.Log("Getting last revision of %q", name)
h, err := s.History(name) h, err := s.History(name)
if err != nil { if err != nil {
return nil, err return nil, err
@ -221,6 +220,6 @@ func Init(d driver.Driver) *Storage {
Driver: d, Driver: d,
releaseLocks: make(map[string]*sync.Mutex), releaseLocks: make(map[string]*sync.Mutex),
releaseLocksLock: &sync.Mutex{}, releaseLocksLock: &sync.Mutex{},
Logger: logger.DefaultLogger, Log: func(_ string, _ ...interface{}) {},
} }
} }

79
pkg/tiller/release_server.go
Unescape View File

@ -32,7 +32,6 @@ import (
"k8s.io/helm/pkg/chartutil" "k8s.io/helm/pkg/chartutil"
"k8s.io/helm/pkg/hooks" "k8s.io/helm/pkg/hooks"
"k8s.io/helm/pkg/logger"
"k8s.io/helm/pkg/proto/hapi/chart" "k8s.io/helm/pkg/proto/hapi/chart"
"k8s.io/helm/pkg/proto/hapi/release" "k8s.io/helm/pkg/proto/hapi/release"
"k8s.io/helm/pkg/proto/hapi/services" "k8s.io/helm/pkg/proto/hapi/services"
@ -84,7 +83,7 @@ type ReleaseServer struct {
ReleaseModule ReleaseModule
env *environment.Environment env *environment.Environment
clientset internalclientset.Interface clientset internalclientset.Interface
Logger logger.Logger Log func(string, ...interface{})
} }
// NewReleaseServer creates a new release server. // NewReleaseServer creates a new release server.
@ -102,7 +101,7 @@ func NewReleaseServer(env *environment.Environment, clientset internalclientset.
env: env, env: env,
clientset: clientset, clientset: clientset,
ReleaseModule: releaseModule, ReleaseModule: releaseModule,
Logger: logger.DefaultLogger, Log: func(_ string, _ ...interface{}) {},
} }
} }
@ -270,7 +269,7 @@ func (s *ReleaseServer) GetReleaseStatus(c ctx.Context, req *services.GetRelease
// Skip errors if this is already deleted or failed. // Skip errors if this is already deleted or failed.
return statusResp, nil return statusResp, nil
} else if err != nil { } else if err != nil {
s.Logger.Printf("warning: Get for %s failed: %v", rel.Name, err) s.Log("warning: Get for %s failed: %v", rel.Name, err)
return nil, err return nil, err
} }
rel.Info.Status.Resources = resp rel.Info.Status.Resources = resp
@ -323,7 +322,7 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
res := &services.UpdateReleaseResponse{Release: updatedRelease} res := &services.UpdateReleaseResponse{Release: updatedRelease}
if req.DryRun { if req.DryRun {
s.Logger.Printf("Dry run for %s", updatedRelease.Name) s.Log("Dry run for %s", updatedRelease.Name)
res.Release.Info.Description = "Dry run complete" res.Release.Info.Description = "Dry run complete"
return res, nil return res, nil
} }
@ -336,7 +335,7 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
} }
if err := s.ReleaseModule.Update(originalRelease, updatedRelease, req, s.env); err != nil { if err := s.ReleaseModule.Update(originalRelease, updatedRelease, req, s.env); err != nil {
msg := fmt.Sprintf("Upgrade %q failed: %s", updatedRelease.Name, err) msg := fmt.Sprintf("Upgrade %q failed: %s", updatedRelease.Name, err)
s.Logger.Printf("warning: %s", msg) s.Log("warning: %s", msg)
originalRelease.Info.Status.Code = release.Status_SUPERSEDED originalRelease.Info.Status.Code = release.Status_SUPERSEDED
updatedRelease.Info.Status.Code = release.Status_FAILED updatedRelease.Info.Status.Code = release.Status_FAILED
updatedRelease.Info.Description = msg updatedRelease.Info.Description = msg
@ -372,19 +371,19 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
func (s *ReleaseServer) reuseValues(req *services.UpdateReleaseRequest, current *release.Release) error { func (s *ReleaseServer) reuseValues(req *services.UpdateReleaseRequest, current *release.Release) error {
if req.ResetValues { if req.ResetValues {
// If ResetValues is set, we comletely ignore current.Config. // If ResetValues is set, we comletely ignore current.Config.
s.Logger.Printf("Reset values to the chart's original version.") s.Log("Reset values to the chart's original version.")
return nil return nil
} }
// If the ReuseValues flag is set, we always copy the old values over the new config's values. // If the ReuseValues flag is set, we always copy the old values over the new config's values.
if req.ReuseValues { if req.ReuseValues {
s.Logger.Printf("Reusing the old release's values") s.Log("Reusing the old release's values")
// We have to regenerate the old coalesced values: // We have to regenerate the old coalesced values:
oldVals, err := chartutil.CoalesceValues(current.Chart, current.Config) oldVals, err := chartutil.CoalesceValues(current.Chart, current.Config)
if err != nil { if err != nil {
err := fmt.Errorf("failed to rebuild old values: %s", err) err := fmt.Errorf("failed to rebuild old values: %s", err)
s.Logger.Printf("%s", err) s.Log("%s", err)
return err return err
} }
nv, err := oldVals.YAML() nv, err := oldVals.YAML()
@ -401,7 +400,7 @@ func (s *ReleaseServer) reuseValues(req *services.UpdateReleaseRequest, current
current.Config != nil && current.Config != nil &&
current.Config.Raw != "" && current.Config.Raw != "" &&
current.Config.Raw != "{}\n" { current.Config.Raw != "{}\n" {
s.Logger.Printf("Copying values from %s (v%d) to new release.", current.Name, current.Version) s.Log("Copying values from %s (v%d) to new release.", current.Name, current.Version)
req.Values = current.Config req.Values = current.Config
} }
return nil return nil
@ -510,7 +509,7 @@ func (s *ReleaseServer) performRollback(currentRelease, targetRelease *release.R
res := &services.RollbackReleaseResponse{Release: targetRelease} res := &services.RollbackReleaseResponse{Release: targetRelease}
if req.DryRun { if req.DryRun {
s.Logger.Printf("Dry run for %s", targetRelease.Name) s.Log("Dry run for %s", targetRelease.Name)
return res, nil return res, nil
} }
@ -523,7 +522,7 @@ func (s *ReleaseServer) performRollback(currentRelease, targetRelease *release.R
if err := s.ReleaseModule.Rollback(currentRelease, targetRelease, req, s.env); err != nil { if err := s.ReleaseModule.Rollback(currentRelease, targetRelease, req, s.env); err != nil {
msg := fmt.Sprintf("Rollback %q failed: %s", targetRelease.Name, err) msg := fmt.Sprintf("Rollback %q failed: %s", targetRelease.Name, err)
s.Logger.Printf("warning: %s", msg) s.Log("warning: %s", msg)
currentRelease.Info.Status.Code = release.Status_SUPERSEDED currentRelease.Info.Status.Code = release.Status_SUPERSEDED
targetRelease.Info.Status.Code = release.Status_FAILED targetRelease.Info.Status.Code = release.Status_FAILED
targetRelease.Info.Description = msg targetRelease.Info.Description = msg
@ -567,7 +566,7 @@ func (s *ReleaseServer) prepareRollback(req *services.RollbackReleaseRequest) (*
rbv = crls.Version - 1 rbv = crls.Version - 1
} }
s.Logger.Printf("rolling back %s (current: v%d, target: v%d)", req.Name, crls.Version, rbv) s.Log("rolling back %s (current: v%d, target: v%d)", req.Name, crls.Version, rbv)
prls, err := s.env.Releases.Get(req.Name, rbv) prls, err := s.env.Releases.Get(req.Name, rbv)
if err != nil { if err != nil {
@ -619,7 +618,7 @@ func (s *ReleaseServer) uniqName(start string, reuse bool) (string, error) {
if st := rel.Info.Status.Code; reuse && (st == release.Status_DELETED || st == release.Status_FAILED) { if st := rel.Info.Status.Code; reuse && (st == release.Status_DELETED || st == release.Status_FAILED) {
// Allowe re-use of names if the previous release is marked deleted. // Allowe re-use of names if the previous release is marked deleted.
s.Logger.Printf("reusing name %q", start) s.Log("reusing name %q", start)
return start, nil return start, nil
} else if reuse { } else if reuse {
return "", errors.New("cannot re-use a name that is still in use") return "", errors.New("cannot re-use a name that is still in use")
@ -638,9 +637,9 @@ func (s *ReleaseServer) uniqName(start string, reuse bool) (string, error) {
if _, err := s.env.Releases.Get(name, 1); strings.Contains(err.Error(), "not found") { if _, err := s.env.Releases.Get(name, 1); strings.Contains(err.Error(), "not found") {
return name, nil return name, nil
} }
s.Logger.Printf("info: Name %q is taken. Searching again.", name) s.Log("info: Name %q is taken. Searching again.", name)
} }
s.Logger.Printf("warning: No available release names found after %d tries", maxTries) s.Log("warning: No available release names found after %d tries", maxTries)
return "ERROR", errors.New("no available release name found") return "ERROR", errors.New("no available release name found")
} }
@ -650,7 +649,7 @@ func (s *ReleaseServer) engine(ch *chart.Chart) environment.Engine {
if r, ok := s.env.EngineYard.Get(ch.Metadata.Engine); ok { if r, ok := s.env.EngineYard.Get(ch.Metadata.Engine); ok {
renderer = r renderer = r
} else { } else {
s.Logger.Printf("warning: %s requested non-existent template engine %s", ch.Metadata.Name, ch.Metadata.Engine) s.Log("warning: %s requested non-existent template engine %s", ch.Metadata.Name, ch.Metadata.Engine)
} }
} }
return renderer return renderer
@ -660,7 +659,7 @@ func (s *ReleaseServer) engine(ch *chart.Chart) environment.Engine {
func (s *ReleaseServer) InstallRelease(c ctx.Context, req *services.InstallReleaseRequest) (*services.InstallReleaseResponse, error) { func (s *ReleaseServer) InstallRelease(c ctx.Context, req *services.InstallReleaseRequest) (*services.InstallReleaseResponse, error) {
rel, err := s.prepareRelease(req) rel, err := s.prepareRelease(req)
if err != nil { if err != nil {
s.Logger.Printf("Failed install prepare step: %s", err) s.Log("Failed install prepare step: %s", err)
res := &services.InstallReleaseResponse{Release: rel} res := &services.InstallReleaseResponse{Release: rel}
// On dry run, append the manifest contents to a failed release. This is // On dry run, append the manifest contents to a failed release. This is
@ -673,7 +672,7 @@ func (s *ReleaseServer) InstallRelease(c ctx.Context, req *services.InstallRelea
res, err := s.performRelease(rel, req) res, err := s.performRelease(rel, req)
if err != nil { if err != nil {
s.Logger.Printf("Failed install perform step: %s", err) s.Log("Failed install perform step: %s", err)
} }
return res, err return res, err
} }
@ -856,10 +855,10 @@ func (s *ReleaseServer) renderResources(ch *chart.Chart, values chartutil.Values
func (s *ReleaseServer) recordRelease(r *release.Release, reuse bool) { func (s *ReleaseServer) recordRelease(r *release.Release, reuse bool) {
if reuse { if reuse {
if err := s.env.Releases.Update(r); err != nil { if err := s.env.Releases.Update(r); err != nil {
s.Logger.Printf("warning: Failed to update release %q: %s", r.Name, err) s.Log("warning: Failed to update release %q: %s", r.Name, err)
} }
} else if err := s.env.Releases.Create(r); err != nil { } else if err := s.env.Releases.Create(r); err != nil {
s.Logger.Printf("warning: Failed to record release %q: %s", r.Name, err) s.Log("warning: Failed to record release %q: %s", r.Name, err)
} }
} }
@ -868,7 +867,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
res := &services.InstallReleaseResponse{Release: r} res := &services.InstallReleaseResponse{Release: r}
if req.DryRun { if req.DryRun {
s.Logger.Printf("Dry run for %s", r.Name) s.Log("Dry run for %s", r.Name)
res.Release.Info.Description = "Dry run complete" res.Release.Info.Description = "Dry run complete"
return res, nil return res, nil
} }
@ -903,7 +902,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
} }
if err := s.ReleaseModule.Update(old, r, updateReq, s.env); err != nil { if err := s.ReleaseModule.Update(old, r, updateReq, s.env); err != nil {
msg := fmt.Sprintf("Release replace %q failed: %s", r.Name, err) msg := fmt.Sprintf("Release replace %q failed: %s", r.Name, err)
s.Logger.Printf("warning: %s", msg) s.Log("warning: %s", msg)
old.Info.Status.Code = release.Status_SUPERSEDED old.Info.Status.Code = release.Status_SUPERSEDED
r.Info.Status.Code = release.Status_FAILED r.Info.Status.Code = release.Status_FAILED
r.Info.Description = msg r.Info.Description = msg
@ -917,7 +916,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
// regular manifests // regular manifests
if err := s.ReleaseModule.Create(r, req, s.env); err != nil { if err := s.ReleaseModule.Create(r, req, s.env); err != nil {
msg := fmt.Sprintf("Release %q failed: %s", r.Name, err) msg := fmt.Sprintf("Release %q failed: %s", r.Name, err)
s.Logger.Printf("warning: %s", msg) s.Log("warning: %s", msg)
r.Info.Status.Code = release.Status_FAILED r.Info.Status.Code = release.Status_FAILED
r.Info.Description = msg r.Info.Description = msg
s.recordRelease(r, false) s.recordRelease(r, false)
@ -929,7 +928,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
if !req.DisableHooks { if !req.DisableHooks {
if err := s.execHook(r.Hooks, r.Name, r.Namespace, hooks.PostInstall, req.Timeout); err != nil { if err := s.execHook(r.Hooks, r.Name, r.Namespace, hooks.PostInstall, req.Timeout); err != nil {
msg := fmt.Sprintf("Release %q failed post-install: %s", r.Name, err) msg := fmt.Sprintf("Release %q failed post-install: %s", r.Name, err)
s.Logger.Printf("warning: %s", msg) s.Log("warning: %s", msg)
r.Info.Status.Code = release.Status_FAILED r.Info.Status.Code = release.Status_FAILED
r.Info.Description = msg r.Info.Description = msg
s.recordRelease(r, false) s.recordRelease(r, false)
@ -958,7 +957,7 @@ func (s *ReleaseServer) execHook(hs []*release.Hook, name, namespace, hook strin
return fmt.Errorf("unknown hook %q", hook) return fmt.Errorf("unknown hook %q", hook)
} }
s.Logger.Printf("Executing %s hooks for %s", hook, name) s.Log("Executing %s hooks for %s", hook, name)
executingHooks := []*release.Hook{} executingHooks := []*release.Hook{}
for _, h := range hs { for _, h := range hs {
for _, e := range h.Events { for _, e := range h.Events {
@ -974,20 +973,20 @@ func (s *ReleaseServer) execHook(hs []*release.Hook, name, namespace, hook strin
b := bytes.NewBufferString(h.Manifest) b := bytes.NewBufferString(h.Manifest)
if err := kubeCli.Create(namespace, b, timeout, false); err != nil { if err := kubeCli.Create(namespace, b, timeout, false); err != nil {
s.Logger.Printf("warning: Release %q %s %s failed: %s", name, hook, h.Path, err) s.Log("warning: Release %q %s %s failed: %s", name, hook, h.Path, err)
return err return err
} }
// No way to rewind a bytes.Buffer()? // No way to rewind a bytes.Buffer()?
b.Reset() b.Reset()
b.WriteString(h.Manifest) b.WriteString(h.Manifest)
if err := kubeCli.WatchUntilReady(namespace, b, timeout, false); err != nil { if err := kubeCli.WatchUntilReady(namespace, b, timeout, false); err != nil {
s.Logger.Printf("warning: Release %q %s %s could not complete: %s", name, hook, h.Path, err) s.Log("warning: Release %q %s %s could not complete: %s", name, hook, h.Path, err)
return err return err
} }
h.LastRun = timeconv.Now() h.LastRun = timeconv.Now()
} }
s.Logger.Printf("Hooks complete for %s %s", hook, name) s.Log("Hooks complete for %s %s", hook, name)
return nil return nil
} }
@ -1009,7 +1008,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
defer s.env.Releases.UnlockRelease(req.Name) defer s.env.Releases.UnlockRelease(req.Name)
if !ValidName.MatchString(req.Name) { if !ValidName.MatchString(req.Name) {
s.Logger.Printf("uninstall: Release not found: %s", req.Name) s.Log("uninstall: Release not found: %s", req.Name)
return nil, errMissingRelease return nil, errMissingRelease
} }
@ -1019,7 +1018,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
rels, err := s.env.Releases.History(req.Name) rels, err := s.env.Releases.History(req.Name)
if err != nil { if err != nil {
s.Logger.Printf("uninstall: Release not loaded: %s", req.Name) s.Log("uninstall: Release not loaded: %s", req.Name)
return nil, err return nil, err
} }
if len(rels) < 1 { if len(rels) < 1 {
@ -1034,7 +1033,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
if rel.Info.Status.Code == release.Status_DELETED { if rel.Info.Status.Code == release.Status_DELETED {
if req.Purge { if req.Purge {
if err := s.purgeReleases(rels...); err != nil { if err := s.purgeReleases(rels...); err != nil {
s.Logger.Printf("uninstall: Failed to purge the release: %s", err) s.Log("uninstall: Failed to purge the release: %s", err)
return nil, err return nil, err
} }
return &services.UninstallReleaseResponse{Release: rel}, nil return &services.UninstallReleaseResponse{Release: rel}, nil
@ -1042,7 +1041,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
return nil, fmt.Errorf("the release named %q is already deleted", req.Name) return nil, fmt.Errorf("the release named %q is already deleted", req.Name)
} }
s.Logger.Printf("uninstall: Deleting %s", req.Name) s.Log("uninstall: Deleting %s", req.Name)
rel.Info.Status.Code = release.Status_DELETING rel.Info.Status.Code = release.Status_DELETING
rel.Info.Deleted = timeconv.Now() rel.Info.Deleted = timeconv.Now()
rel.Info.Description = "Deletion in progress (or silently failed)" rel.Info.Description = "Deletion in progress (or silently failed)"
@ -1057,7 +1056,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
// From here on out, the release is currently considered to be in Status_DELETING // From here on out, the release is currently considered to be in Status_DELETING
// state. // state.
if err := s.env.Releases.Update(rel); err != nil { if err := s.env.Releases.Update(rel); err != nil {
s.Logger.Printf("uninstall: Failed to store updated release: %s", err) s.Log("uninstall: Failed to store updated release: %s", err)
} }
kept, errs := s.ReleaseModule.Delete(rel, req, s.env) kept, errs := s.ReleaseModule.Delete(rel, req, s.env)
@ -1065,7 +1064,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
es := make([]string, 0, len(errs)) es := make([]string, 0, len(errs))
for _, e := range errs { for _, e := range errs {
s.Logger.Printf("error: %v", e) s.Log("error: %v", e)
es = append(es, e.Error()) es = append(es, e.Error())
} }
@ -1081,13 +1080,13 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
if req.Purge { if req.Purge {
err := s.purgeReleases(rels...) err := s.purgeReleases(rels...)
if err != nil { if err != nil {
s.Logger.Printf("uninstall: Failed to purge the release: %s", err) s.Log("uninstall: Failed to purge the release: %s", err)
} }
return res, err return res, err
} }
if err := s.env.Releases.Update(rel); err != nil { if err := s.env.Releases.Update(rel); err != nil {
s.Logger.Printf("uninstall: Failed to store updated release: %s", err) s.Log("uninstall: Failed to store updated release: %s", err)
} }
if len(es) > 0 { if len(es) > 0 {
@ -1124,12 +1123,12 @@ func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream
tSuite, err := reltesting.NewTestSuite(rel) tSuite, err := reltesting.NewTestSuite(rel)
if err != nil { if err != nil {
s.Logger.Printf("Error creating test suite for %s", rel.Name) s.Log("Error creating test suite for %s", rel.Name)
return err return err
} }
if err := tSuite.Run(testEnv); err != nil { if err := tSuite.Run(testEnv); err != nil {
s.Logger.Printf("Error running test suite for %s", rel.Name) s.Log("Error running test suite for %s", rel.Name)
return err return err
} }
@ -1144,7 +1143,7 @@ func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream
} }
if err := s.env.Releases.Update(rel); err != nil { if err := s.env.Releases.Update(rel); err != nil {
log.Printf("test: Failed to store updated release: %s", err) s.Log("test: Failed to store updated release: %s", err)
} }
return nil return nil

3
pkg/tiller/release_server_test.go
Unescape View File

@ -32,7 +32,6 @@ import (
"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake"
"k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm"
"k8s.io/helm/pkg/logger"
"k8s.io/helm/pkg/proto/hapi/chart" "k8s.io/helm/pkg/proto/hapi/chart"
"k8s.io/helm/pkg/proto/hapi/release" "k8s.io/helm/pkg/proto/hapi/release"
"k8s.io/helm/pkg/proto/hapi/services" "k8s.io/helm/pkg/proto/hapi/services"
@ -106,7 +105,7 @@ func rsFixture() *ReleaseServer {
}, },
env: MockEnvironment(), env: MockEnvironment(),
clientset: clientset, clientset: clientset,
Logger: logger.NewNopLogger(), Log: func(_ string, _ ...interface{}) {},
} }
} }

Write Preview
Loading…
Cancel
Save