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.
var env = environment.New()
var logger *log.Logger
var (
grpcAddr = ":44134"
probeAddr = ":44135"
@ -111,6 +113,7 @@ func initLog() {
if enableTracing {
log.SetFlags(log.Lshortfile)
}
logger = newLogger("main")
}
func main() {
@ -126,7 +129,7 @@ func main() {
addFlags(root.Flags())
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) {
clientset, err := kube.New(nil).ClientSet()
if err != nil {
log.Fatalf("Cannot initialize Kubernetes connection: %s", err)
logger.Fatalf("Cannot initialize Kubernetes connection: %s", err)
}
switch store {
@ -148,14 +151,14 @@ func start(c *cobra.Command, args []string) {
env.Releases = storage.Init(driver.NewMemory())
case storageConfigMap:
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.Logger = newLogger("storage")
env.Releases.Log = newLogger("storage").Printf
}
kubeClient := kube.New(nil)
kubeClient.Logger = newLogger("kube")
kubeClient.Log = newLogger("kube").Printf
env.KubeClient = kubeClient
if tlsEnable || tlsVerify {
@ -169,7 +172,7 @@ func start(c *cobra.Command, args []string) {
if tlsEnable || tlsVerify {
cfg, err := tlsutil.ServerConfig(tlsOptions())
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)))
}
@ -178,13 +181,13 @@ func start(c *cobra.Command, args []string) {
lstn, err := net.Listen("tcp", grpcAddr)
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)
log.Printf("GRPC listening on %s", grpcAddr)
log.Printf("Probes listening on %s", probeAddr)
log.Printf("Storage driver is %s", env.Releases.Name())
logger.Printf("Starting Tiller %s (tls=%t)", version.GetVersion(), tlsEnable || tlsVerify)
logger.Printf("GRPC listening on %s", grpcAddr)
logger.Printf("Probes listening on %s", probeAddr)
logger.Printf("Storage driver is %s", env.Releases.Name())
if enableTracing {
startTracing(traceAddr)
@ -194,7 +197,7 @@ func start(c *cobra.Command, args []string) {
probeErrCh := make(chan error)
go func() {
svc := tiller.NewReleaseServer(env, clientset, remoteReleaseModules)
svc.Logger = newLogger("tiller")
svc.Log = newLogger("tiller").Printf
services.RegisterReleaseServiceServer(rootServer, svc)
if err := rootServer.Serve(lstn); err != nil {
srvErrCh <- err
@ -215,9 +218,9 @@ func start(c *cobra.Command, args []string) {
select {
case err := <-srvErrCh:
log.Fatalf("Server died: %s", err)
logger.Fatalf("Server died: %s", err)
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"
import (
"log"
"net/http"
_ "net/http/pprof"
@ -26,7 +25,7 @@ import (
)
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
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
@ -40,7 +39,7 @@ func startTracing(addr string) {
go func() {
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"
"k8s.io/kubernetes/pkg/kubectl/resource"
"k8s.io/kubernetes/pkg/printers"
"k8s.io/helm/pkg/logger"
)
// 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 string
Logger logger.Logger
Log func(string, ...interface{})
}
// New create a new Client
@ -70,7 +68,7 @@ func New(config clientcmd.ClientConfig) *Client {
return &Client{
Factory: cmdutil.NewFactory(config),
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 {
schema, err := c.Validator(true, c.SchemaCacheDir)
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().
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) {
schema, err := c.Validator(true, c.SchemaCacheDir)
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()
if err != nil {
c.Logger.Printf("failed to load mapper: %s", err)
c.Log("failed to load mapper: %s", err)
return nil, err
}
var result Result
@ -160,9 +158,9 @@ func (c *Client) Get(namespace string, reader io.Reader) (string, error) {
}
missing := []string{}
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 {
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))
return nil
}
@ -190,7 +188,7 @@ func (c *Client) Get(namespace string, reader io.Reader) (string, error) {
}
for _, o := range ot {
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
}
}
@ -243,7 +241,7 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader
}
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
}
@ -253,7 +251,7 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader
}
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())
}
@ -268,9 +266,9 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader
}
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 {
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 {
@ -288,7 +286,7 @@ func (c *Client) Delete(namespace string, reader io.Reader) error {
return err
}
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)
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 {
if errors.IsNotFound(err) {
c.Logger.Printf("%v", err)
c.Log("%v", err)
return nil
}
return err
@ -360,7 +358,7 @@ func deleteResource(c *Client, info *resource.Info) error {
}
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)
}
@ -400,7 +398,7 @@ func updateResource(c *Client, target *resource.Info, currentObj runtime.Object,
return fmt.Errorf("failed to create patch: %s", err)
}
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
// Otherwise there will be no labels and other functions that use labels will panic
if err := target.Get(); err != nil {
@ -450,7 +448,7 @@ func updateResource(c *Client, target *resource.Info, currentObj runtime.Object,
// Restart pods
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.
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
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.
// - 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
// the status go into a good state. For other types, like ReplicaSet
// 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" {
return c.waitForJob(e, info.Name)
}
return true, nil
case watch.Deleted:
c.Logger.Printf("Deleted event for %s", info.Name)
c.Log("Deleted event for %s", info.Name)
return true, nil
case watch.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)
default:
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
}
@ -597,7 +595,7 @@ func (c *Client) watchPodUntilComplete(timeout time.Duration, info *resource.Inf
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) {
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/printers"
watchjson "k8s.io/kubernetes/pkg/watch/json"
"k8s.io/helm/pkg/logger"
)
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 {
return &Client{
Factory: f,
Logger: logger.NewNopLogger(),
}
c := New(nil)
c.Factory = f
return c
}
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/client/clientset_generated/internalclientset/typed/core/internalversion"
"k8s.io/helm/pkg/logger"
rspb "k8s.io/helm/pkg/proto/hapi/release"
)
@ -51,13 +50,16 @@ var magicGzip = []byte{0x1f, 0x8b, 0x08}
// ConfigMapsInterface.
type ConfigMaps struct {
impl internalversion.ConfigMapInterface
Logger logger.Logger
Log func(string, ...interface{})
}
// NewConfigMaps initializes a new ConfigMaps wrapping an implmenetation of
// the kubernetes ConfigMapsInterface.
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.
@ -75,13 +77,13 @@ func (cfgmaps *ConfigMaps) Get(key string) (*rspb.Release, error) {
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
}
// found the configmap, decode the base64 data string
r, err := decodeRelease(obj.Data["release"])
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 the release object
@ -97,7 +99,7 @@ func (cfgmaps *ConfigMaps) List(filter func(*rspb.Release) bool) ([]*rspb.Releas
list, err := cfgmaps.impl.List(opts)
if err != nil {
cfgmaps.Logger.Printf("list: failed to list: %s", err)
cfgmaps.Log("list: failed to list: %s", err)
return nil, err
}
@ -108,7 +110,7 @@ func (cfgmaps *ConfigMaps) List(filter func(*rspb.Release) bool) ([]*rspb.Releas
for _, item := range list.Items {
rls, err := decodeRelease(item.Data["release"])
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
}
if filter(rls) {
@ -133,7 +135,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
list, err := cfgmaps.impl.List(opts)
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
}
@ -145,7 +147,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
for _, item := range list.Items {
rls, err := decodeRelease(item.Data["release"])
if err != nil {
cfgmaps.Logger.Printf("query: failed to decode release: %s", err)
cfgmaps.Log("query: failed to decode release: %s", err)
continue
}
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
obj, err := newConfigMapsObject(key, rls, lbs)
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
}
// 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)
}
cfgmaps.Logger.Printf("create: failed to create: %s", err)
cfgmaps.Log("create: failed to create: %s", err)
return err
}
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
obj, err := newConfigMapsObject(key, rls, lbs)
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
}
// push the configmap object out into the kubiverse
_, err = cfgmaps.impl.Update(obj)
if err != nil {
cfgmaps.Logger.Printf("update: failed to update: %s", err)
cfgmaps.Log("update: failed to update: %s", err)
return err
}
return nil
@ -212,7 +214,7 @@ func (cfgmaps *ConfigMaps) Delete(key string) (rls *rspb.Release, err error) {
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
}
// delete the release

29
pkg/storage/storage.go
Unescape View File

@ -20,7 +20,6 @@ import (
"fmt"
"sync"
"k8s.io/helm/pkg/logger"
rspb "k8s.io/helm/pkg/proto/hapi/release"
relutil "k8s.io/helm/pkg/releaseutil"
"k8s.io/helm/pkg/storage/driver"
@ -35,14 +34,14 @@ type Storage struct {
// releaseLocksLock is a mutex for accessing releaseLocks
releaseLocksLock *sync.Mutex
Logger logger.Logger
Log func(string, ...interface{})
}
// Get retrieves the release from storage. An error is returned
// if the storage driver failed to fetch the release, or the
// release identified by the key, version pair does not exist.
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))
}
@ -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
// release, or a release with identical an key already exists.
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)
}
@ -58,7 +57,7 @@ func (s *Storage) Create(rls *rspb.Release) error {
// storage backend fails to update the release or if the release
// does not exist.
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)
}
@ -66,21 +65,21 @@ func (s *Storage) Update(rls *rspb.Release) error {
// the storage backend fails to delete the release or if the release
// does not exist.
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))
}
// ListReleases returns all releases from storage. An error is returned if the
// storage backend fails to retrieve the releases.
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 })
}
// ListDeleted returns all releases with Status == DELETED. An error is returned
// if the storage backend fails to retrieve the releases.
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 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
// if the storage backend fails to retrieve the releases.
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 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
// if and only if all filters return true.
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 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
// if at least one of the filters returns true.
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 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
// returns ErrReleaseNotFound if not found.
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{
"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
// returns ErrReleaseNotFound if no such release name exists.
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"})
}
// Last fetches the last revision of the named release.
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)
if err != nil {
return nil, err
@ -221,6 +220,6 @@ func Init(d driver.Driver) *Storage {
Driver: d,
releaseLocks: make(map[string]*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/hooks"
"k8s.io/helm/pkg/logger"
"k8s.io/helm/pkg/proto/hapi/chart"
"k8s.io/helm/pkg/proto/hapi/release"
"k8s.io/helm/pkg/proto/hapi/services"
@ -84,7 +83,7 @@ type ReleaseServer struct {
ReleaseModule
env *environment.Environment
clientset internalclientset.Interface
Logger logger.Logger
Log func(string, ...interface{})
}
// NewReleaseServer creates a new release server.
@ -102,7 +101,7 @@ func NewReleaseServer(env *environment.Environment, clientset internalclientset.
env: env,
clientset: clientset,
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.
return statusResp, 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
}
rel.Info.Status.Resources = resp
@ -323,7 +322,7 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
res := &services.UpdateReleaseResponse{Release: updatedRelease}
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"
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 {
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
updatedRelease.Info.Status.Code = release.Status_FAILED
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 {
if req.ResetValues {
// 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
}
// If the ReuseValues flag is set, we always copy the old values over the new config's values.
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:
oldVals, err := chartutil.CoalesceValues(current.Chart, current.Config)
if err != nil {
err := fmt.Errorf("failed to rebuild old values: %s", err)
s.Logger.Printf("%s", err)
s.Log("%s", err)
return err
}
nv, err := oldVals.YAML()
@ -401,7 +400,7 @@ func (s *ReleaseServer) reuseValues(req *services.UpdateReleaseRequest, current
current.Config != nil &&
current.Config.Raw != "" &&
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
}
return nil
@ -510,7 +509,7 @@ func (s *ReleaseServer) performRollback(currentRelease, targetRelease *release.R
res := &services.RollbackReleaseResponse{Release: targetRelease}
if req.DryRun {
s.Logger.Printf("Dry run for %s", targetRelease.Name)
s.Log("Dry run for %s", targetRelease.Name)
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 {
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
targetRelease.Info.Status.Code = release.Status_FAILED
targetRelease.Info.Description = msg
@ -567,7 +566,7 @@ func (s *ReleaseServer) prepareRollback(req *services.RollbackReleaseRequest) (*
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)
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) {
// 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
} else if reuse {
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") {
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")
}
@ -650,7 +649,7 @@ func (s *ReleaseServer) engine(ch *chart.Chart) environment.Engine {
if r, ok := s.env.EngineYard.Get(ch.Metadata.Engine); ok {
renderer = r
} 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
@ -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) {
rel, err := s.prepareRelease(req)
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}
// 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)
if err != nil {
s.Logger.Printf("Failed install perform step: %s", err)
s.Log("Failed install perform step: %s", 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) {
if reuse {
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 {
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}
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"
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 {
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
r.Info.Status.Code = release.Status_FAILED
r.Info.Description = msg
@ -917,7 +916,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
// regular manifests
if err := s.ReleaseModule.Create(r, req, s.env); err != nil {
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.Description = msg
s.recordRelease(r, false)
@ -929,7 +928,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
if !req.DisableHooks {
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)
s.Logger.Printf("warning: %s", msg)
s.Log("warning: %s", msg)
r.Info.Status.Code = release.Status_FAILED
r.Info.Description = msg
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)
}
s.Logger.Printf("Executing %s hooks for %s", hook, name)
s.Log("Executing %s hooks for %s", hook, name)
executingHooks := []*release.Hook{}
for _, h := range hs {
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)
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
}
// No way to rewind a bytes.Buffer()?
b.Reset()
b.WriteString(h.Manifest)
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
}
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
}
@ -1009,7 +1008,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
defer s.env.Releases.UnlockRelease(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
}
@ -1019,7 +1018,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
rels, err := s.env.Releases.History(req.Name)
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
}
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 req.Purge {
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 &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)
}
s.Logger.Printf("uninstall: Deleting %s", req.Name)
s.Log("uninstall: Deleting %s", req.Name)
rel.Info.Status.Code = release.Status_DELETING
rel.Info.Deleted = timeconv.Now()
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
// state.
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)
@ -1065,7 +1064,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
es := make([]string, 0, len(errs))
for _, e := range errs {
s.Logger.Printf("error: %v", e)
s.Log("error: %v", e)
es = append(es, e.Error())
}
@ -1081,13 +1080,13 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
if req.Purge {
err := s.purgeReleases(rels...)
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
}
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 {
@ -1124,12 +1123,12 @@ func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream
tSuite, err := reltesting.NewTestSuite(rel)
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
}
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
}
@ -1144,7 +1143,7 @@ func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream
}
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

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/helm/pkg/helm"
"k8s.io/helm/pkg/logger"
"k8s.io/helm/pkg/proto/hapi/chart"
"k8s.io/helm/pkg/proto/hapi/release"
"k8s.io/helm/pkg/proto/hapi/services"
@ -106,7 +105,7 @@ func rsFixture() *ReleaseServer {
},
env: MockEnvironment(),
clientset: clientset,
Logger: logger.NewNopLogger(),
Log: func(_ string, _ ...interface{}) {},
}
}

Write Preview
Loading…
Cancel
Save