Merge remote-tracking branch 'upstream/master' into feat/list-namespaces

Makefile

 DOCKER_REGISTRY ?= gcr.io
 IMAGE_PREFIX    ?= kubernetes-helm
 SHORT_NAME      ?= tiller
-TARGETS         = darwin/amd64 linux/amd64 linux/386 linux/arm linux/arm64 windows/amd64
+TARGETS         = darwin/amd64 linux/amd64 linux/386 linux/arm linux/arm64 linux/ppc64le windows/amd64
 DIST_DIRS       = find * -type d -exec
 APP             = helm
 

_proto/hapi/release/release.proto

@@ -18,7 +18,6 @@ package hapi.release;
 
 import "hapi/release/hook.proto";
 import "hapi/release/info.proto";
-import "hapi/release/test_suite.proto";
 import "hapi/chart/config.proto";
 import "hapi/chart/chart.proto";
 
@@ -51,7 +50,4 @@ message Release {
 
 	// Namespace is the kubernetes namespace of the release.
 	string namespace = 8;
-
-	// LastTestSuiteRun provides results on the last test run on a release
-	hapi.release.TestSuite last_test_suite_run = 9;
 }

_proto/hapi/release/status.proto

@@ -16,6 +16,8 @@ syntax = "proto3";
 
 package hapi.release;
 
+import "hapi/release/test_suite.proto";
+
 import "google/protobuf/any.proto";
 
 option go_package = "release";
@@ -47,4 +49,7 @@ message Status {
 
         // Contains the rendered templates/NOTES.txt if available
         string notes = 4;
+
+        // LastTestSuiteRun provides results on the last test run on a release
+        hapi.release.TestSuite last_test_suite_run = 5;
 }

cmd/helm/dependency_update.go

@@ -28,10 +28,15 @@ const dependencyUpDesc = `
 Update the on-disk dependencies to mirror the requirements.yaml file.
 
 This command verifies that the required charts, as expressed in 'requirements.yaml',
-are present in 'charts/' and are at an acceptable version.
+are present in 'charts/' and are at an acceptable version. It will pull down
+the latest charts that satisfy the dependencies, and clean up old dependencies.
 
 On successful update, this will generate a lock file that can be used to
 rebuild the requirements to an exact version.
+
+Dependencies are not required to be represented in 'requirements.yaml'. For that
+reason, an update command will not remove charts unless they are (a) present
+in the requirements.yaml file, but (b) at the wrong version.
 `
 
 // dependencyUpdateCmd describes a 'helm dependency update'

cmd/helm/dependency_update_test.go

@@ -98,7 +98,34 @@ func TestDependencyUpdateCmd(t *testing.T) {
 		t.Errorf("Failed hash match: expected %s, got %s", hash, h)
 	}
 
-	t.Logf("Results: %s", out.String())
+	// Now change the dependencies and update. This verifies that on update,
+	// old dependencies are cleansed and new dependencies are added.
+	reqfile := &chartutil.Requirements{
+		Dependencies: []*chartutil.Dependency{
+			{Name: "reqtest", Version: "0.1.0", Repository: srv.URL()},
+			{Name: "compressedchart", Version: "0.3.0", Repository: srv.URL()},
+		},
+	}
+	dir := filepath.Join(hh, chartname)
+	if err := writeRequirements(dir, reqfile); err != nil {
+		t.Fatal(err)
+	}
+	if err := duc.run(); err != nil {
+		output := out.String()
+		t.Logf("Output: %s", output)
+		t.Fatal(err)
+	}
+
+	// In this second run, we should see compressedchart-0.3.0.tgz, and not
+	// the 0.1.0 version.
+	expect = filepath.Join(hh, chartname, "charts/compressedchart-0.3.0.tgz")
+	if _, err := os.Stat(expect); err != nil {
+		t.Fatalf("Expected %q: %s", expect, err)
+	}
+	dontExpect := filepath.Join(hh, chartname, "charts/compressedchart-0.1.0.tgz")
+	if _, err := os.Stat(dontExpect); err == nil {
+		t.Fatalf("Unexpected %q", dontExpect)
+	}
 }
 
 // createTestingChart creates a basic chart that depends on reqtest-0.1.0
@@ -117,8 +144,13 @@ func createTestingChart(dest, name, baseURL string) error {
 	req := &chartutil.Requirements{
 		Dependencies: []*chartutil.Dependency{
 			{Name: "reqtest", Version: "0.1.0", Repository: baseURL},
+			{Name: "compressedchart", Version: "0.1.0", Repository: baseURL},
 		},
 	}
+	return writeRequirements(dir, req)
+}
+
+func writeRequirements(dir string, req *chartutil.Requirements) error {
 	data, err := yaml.Marshal(req)
 	if err != nil {
 		return err

cmd/helm/downloader/manager.go

@@ -169,6 +169,9 @@ func (m *Manager) resolve(req *chartutil.Requirements, repoNames map[string]stri
 }
 
 // downloadAll takes a list of dependencies and downloads them into charts/
+//
+// It will delete versions of the chart that exist on disk and might cause
+// a conflict.
 func (m *Manager) downloadAll(deps []*chartutil.Dependency) error {
 	repos, err := m.loadChartRepositories()
 	if err != nil {
@@ -195,6 +198,9 @@ func (m *Manager) downloadAll(deps []*chartutil.Dependency) error {
 
 	fmt.Fprintf(m.Out, "Saving %d charts\n", len(deps))
 	for _, dep := range deps {
+		if err := m.safeDeleteDep(dep.Name, destPath); err != nil {
+			return err
+		}
 		fmt.Fprintf(m.Out, "Downloading %s from repo %s\n", dep.Name, dep.Repository)
 
 		// Any failure to resolve/download a chart should fail:
@@ -211,6 +217,39 @@ func (m *Manager) downloadAll(deps []*chartutil.Dependency) error {
 	return nil
 }
 
+// safeDeleteDep deletes any versions of the given dependency in the given directory.
+//
+// It does this by first matching the file name to an expected pattern, then loading
+// the file to verify that it is a chart with the same name as the given name.
+//
+// Because it requires tar file introspection, it is more intensive than a basic delete.
+//
+// This will only return errors that should stop processing entirely. Other errors
+// will emit log messages or be ignored.
+func (m *Manager) safeDeleteDep(name, dir string) error {
+	files, err := filepath.Glob(filepath.Join(dir, name+"-*.tgz"))
+	if err != nil {
+		// Only for ErrBadPattern
+		return err
+	}
+	for _, fname := range files {
+		ch, err := chartutil.LoadFile(fname)
+		if err != nil {
+			fmt.Fprintf(m.Out, "Could not verify %s for deletion: %s (Skipping)", fname, err)
+			continue
+		}
+		if ch.Metadata.Name != name {
+			// This is not the file you are looking for.
+			continue
+		}
+		if err := os.Remove(fname); err != nil {
+			fmt.Fprintf(m.Out, "Could not delete %s: %s (Skipping)", fname, err)
+			continue
+		}
+	}
+	return nil
+}
+
 // hasAllRepos ensures that all of the referenced deps are in the local repo cache.
 func (m *Manager) hasAllRepos(deps []*chartutil.Dependency) error {
 	rf, err := repo.LoadRepositoriesFile(m.HelmHome.RepositoryFile())

cmd/helm/helm.go

@@ -33,6 +33,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/restclient"
 
 	"k8s.io/helm/cmd/helm/helmpath"
+	"k8s.io/helm/pkg/helm/portforwarder"
 	"k8s.io/helm/pkg/kube"
 	"k8s.io/helm/pkg/tiller/environment"
 )
@@ -49,6 +50,8 @@ var (
 	tillerHost      string
 	tillerNamespace string
 	kubeContext     string
+	// TODO refactor out this global var
+	tillerTunnel *kube.Tunnel
 )
 
 // flagDebug is a signal that the user wants additional output.
@@ -156,7 +159,12 @@ func markDeprecated(cmd *cobra.Command, notice string) *cobra.Command {
 
 func setupConnection(c *cobra.Command, args []string) error {
 	if tillerHost == "" {
-		tunnel, err := newTillerPortForwarder(tillerNamespace, kubeContext)
+		config, client, err := getKubeClient(kubeContext)
+		if err != nil {
+			return err
+		}
+
+		tunnel, err := portforwarder.New(tillerNamespace, client, config)
 		if err != nil {
 			return err
 		}

cmd/helm/status.go

@@ -22,9 +22,12 @@ import (
 	"regexp"
 	"text/tabwriter"
 
+	"github.com/gosuri/uitable"
+	"github.com/gosuri/uitable/util/strutil"
 	"github.com/spf13/cobra"
 
 	"k8s.io/helm/pkg/helm"
+	"k8s.io/helm/pkg/proto/hapi/release"
 	"k8s.io/helm/pkg/proto/hapi/services"
 	"k8s.io/helm/pkg/timeconv"
 )
@@ -36,6 +39,7 @@ The status consists of:
 - k8s namespace in which the release lives
 - state of the release (can be: UNKNOWN, DEPLOYED, DELETED, SUPERSEDED, FAILED or DELETING)
 - list of resources that this release consists of, sorted by kind
+- details on last test suite run, if applicable
 - additional notes provided by the chart
 `
 
@@ -100,8 +104,31 @@ func PrintStatus(out io.Writer, res *services.GetReleaseStatusResponse) {
 		fmt.Fprintf(w, "RESOURCES:\n%s\n", re.ReplaceAllString(res.Info.Status.Resources, "\t"))
 		w.Flush()
 	}
+	if res.Info.Status.LastTestSuiteRun != nil {
+		lastRun := res.Info.Status.LastTestSuiteRun
+		fmt.Fprintf(out, "TEST SUITE:\n%s\n%s\n\n%s\n",
+			fmt.Sprintf("Last Started: %s", timeconv.String(lastRun.StartedAt)),
+			fmt.Sprintf("Last Completed: %s", timeconv.String(lastRun.CompletedAt)),
+			formatTestResults(lastRun.Results))
+	}
 
 	if len(res.Info.Status.Notes) > 0 {
 		fmt.Fprintf(out, "NOTES:\n%s\n", res.Info.Status.Notes)
 	}
 }
+
+func formatTestResults(results []*release.TestRun) string {
+	tbl := uitable.New()
+	tbl.MaxColWidth = 50
+	tbl.AddRow("TEST", "STATUS", "INFO", "STARTED", "COMPLETED")
+	for i := 0; i < len(results); i++ {
+		r := results[i]
+		n := r.Name
+		s := strutil.PadRight(r.Status.String(), 10, ' ')
+		i := r.Info
+		ts := timeconv.String(r.StartedAt)
+		tc := timeconv.String(r.CompletedAt)
+		tbl.AddRow(n, s, i, ts, tc)
+	}
+	return tbl.String()
+}

cmd/helm/status_test.go

+/*
+Copyright 2017 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 main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/golang/protobuf/ptypes/timestamp"
+	"github.com/spf13/cobra"
+
+	"k8s.io/helm/pkg/proto/hapi/release"
+	"k8s.io/helm/pkg/timeconv"
+)
+
+var (
+	date       = timestamp.Timestamp{Seconds: 242085845, Nanos: 0}
+	dateString = timeconv.String(&date)
+)
+
+// statusCase describes a test case dealing with the status of a release
+type statusCase struct {
+	name     string
+	args     []string
+	flags    []string
+	expected string
+	err      bool
+	rel      *release.Release
+}
+
+func TestStatusCmd(t *testing.T) {
+	tests := []statusCase{
+		{
+			name:     "get status of a deployed release",
+			args:     []string{"flummoxed-chickadee"},
+			expected: outputWithStatus("DEPLOYED\n\n"),
+			rel: releaseMockWithStatus(&release.Status{
+				Code: release.Status_DEPLOYED,
+			}),
+		},
+		{
+			name:     "get status of a deployed release with notes",
+			args:     []string{"flummoxed-chickadee"},
+			expected: outputWithStatus("DEPLOYED\n\nNOTES:\nrelease notes\n"),
+			rel: releaseMockWithStatus(&release.Status{
+				Code:  release.Status_DEPLOYED,
+				Notes: "release notes",
+			}),
+		},
+		{
+			name:     "get status of a deployed release with resources",
+			args:     []string{"flummoxed-chickadee"},
+			expected: outputWithStatus("DEPLOYED\n\nRESOURCES:\nresource A\nresource B\n\n"),
+			rel: releaseMockWithStatus(&release.Status{
+				Code:      release.Status_DEPLOYED,
+				Resources: "resource A\nresource B\n",
+			}),
+		},
+		{
+			name: "get status of a deployed release with test suite",
+			args: []string{"flummoxed-chickadee"},
+			expected: outputWithStatus(
+				fmt.Sprintf("DEPLOYED\n\nTEST SUITE:\nLast Started: %s\nLast Completed: %s\n\n", dateString, dateString) +
+					fmt.Sprint("TEST \tSTATUS \tINFO \tSTARTED \tCOMPLETED \n") +
+					fmt.Sprintf("test run 1\tSUCCESS \textra info\t%s\t%s\n", dateString, dateString) +
+					fmt.Sprintf("test run 2\tFAILURE \t \t%s\t%s\n", dateString, dateString)),
+			rel: releaseMockWithStatus(&release.Status{
+				Code: release.Status_DEPLOYED,
+				LastTestSuiteRun: &release.TestSuite{
+					StartedAt:   &date,
+					CompletedAt: &date,
+					Results: []*release.TestRun{
+						{
+							Name:        "test run 1",
+							Status:      release.TestRun_SUCCESS,
+							Info:        "extra info",
+							StartedAt:   &date,
+							CompletedAt: &date,
+						},
+						{
+							Name:        "test run 2",
+							Status:      release.TestRun_FAILURE,
+							StartedAt:   &date,
+							CompletedAt: &date,
+						},
+					},
+				},
+			}),
+		},
+	}
+
+	scmd := func(c *fakeReleaseClient, out io.Writer) *cobra.Command {
+		return newStatusCmd(c, out)
+	}
+
+	var buf bytes.Buffer
+	for _, tt := range tests {
+		c := &fakeReleaseClient{
+			rels: []*release.Release{tt.rel},
+		}
+		cmd := scmd(c, &buf)
+		cmd.ParseFlags(tt.flags)
+		err := cmd.RunE(cmd, tt.args)
+		if (err != nil) != tt.err {
+			t.Errorf("%q. expected error, got '%v'", tt.name, err)
+		}
+
+		expected := strings.Replace(tt.expected, " ", "", -1)
+		got := strings.Replace(buf.String(), " ", "", -1)
+		if expected != got {
+			t.Errorf("%q. expected\n%q\ngot\n%q", tt.name, expected, got)
+		}
+		buf.Reset()
+	}
+}
+
+func outputWithStatus(status string) string {
+	return fmt.Sprintf("LAST DEPLOYED: %s\nNAMESPACE: \nSTATUS: %s",
+		dateString,
+		status)
+}
+
+func releaseMockWithStatus(status *release.Status) *release.Release {
+	return &release.Release{
+		Name: "flummoxed-chickadee",
+		Info: &release.Info{
+			FirstDeployed: &date,
+			LastDeployed:  &date,
+			Status:        status,
+		},
+	}
+}

cmd/helm/tunnel.go → pkg/helm/portforwarder/portforwarder.go

@@ -14,27 +14,21 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package main
+package portforwarder
 
 import (
 	"fmt"
 
 	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
+	"k8s.io/kubernetes/pkg/client/restclient"
 	"k8s.io/kubernetes/pkg/labels"
 
 	"k8s.io/helm/pkg/kube"
 )
 
-// TODO refactor out this global var
-var tillerTunnel *kube.Tunnel
-
-func newTillerPortForwarder(namespace, context string) (*kube.Tunnel, error) {
-	config, client, err := getKubeClient(context)
-	if err != nil {
-		return nil, err
-	}
-
+func New(namespace string, client *internalclientset.Clientset, config *restclient.Config) (*kube.Tunnel, error) {
 	podName, err := getTillerPodName(client.Core(), namespace)
 	if err != nil {
 		return nil, err

cmd/helm/tunnel_test.go → pkg/helm/portforwarder/portforwarder_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package main
+package portforwarder
 
 import (
 	"testing"

pkg/proto/hapi/chart/chart.pb.go

@@ -100,21 +100,20 @@ func init() {
 func init() { proto.RegisterFile("hapi/chart/chart.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 242 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0xc3, 0x30,
-	0x10, 0x86, 0x15, 0x4a, 0x0a, 0x1c, 0x2c, 0x58, 0x08, 0x4c, 0xa7, 0x8a, 0x09, 0x75, 0x70, 0x50,
-	0x11, 0x0f, 0x00, 0xcc, 0x2c, 0x16, 0x13, 0xdb, 0xb5, 0xb9, 0xa4, 0x91, 0x52, 0x3b, 0xaa, 0x5d,
-	0xa4, 0xbe, 0x3b, 0x03, 0xea, 0xd9, 0xa6, 0x09, 0xea, 0x12, 0x29, 0xf7, 0x7d, 0xff, 0xe5, 0xbf,
-	0xc0, 0xed, 0x0a, 0xbb, 0xa6, 0x58, 0xae, 0x70, 0xe3, 0xc3, 0x53, 0x75, 0x1b, 0xeb, 0xad, 0x80,
-	0xfd, 0x5c, 0xf1, 0x64, 0x72, 0xd7, 0x77, 0xac, 0xa9, 0x9a, 0x3a, 0x48, 0x93, 0xfb, 0x1e, 0x58,
-	0x93, 0xc7, 0x12, 0x3d, 0x1e, 0x41, 0x9e, 0xd6, 0x5d, 0x8b, 0x9e, 0x12, 0xaa, 0xad, 0xad, 0x5b,
-	0x2a, 0xf8, 0x6d, 0xb1, 0xad, 0x0a, 0x34, 0xbb, 0x80, 0x1e, 0x7e, 0x32, 0xc8, 0xdf, 0xf7, 0x19,
-	0xf1, 0x04, 0xe7, 0x69, 0xa3, 0xcc, 0xa6, 0xd9, 0xe3, 0xe5, 0xfc, 0x46, 0x1d, 0x2a, 0xa9, 0x8f,
-	0xc8, 0xf4, 0x9f, 0x25, 0xe6, 0x70, 0x91, 0x3e, 0xe4, 0xe4, 0xc9, 0x74, 0xf4, 0x3f, 0xf2, 0x19,
-	0xa1, 0x3e, 0x68, 0xe2, 0x05, 0xae, 0x4a, 0xea, 0xc8, 0x94, 0x64, 0x96, 0x0d, 0x39, 0x39, 0xe2,
-	0xd8, 0x75, 0x3f, 0xc6, 0x75, 0xf4, 0x40, 0x13, 0x33, 0x18, 0x7f, 0x63, 0xbb, 0x25, 0x27, 0x4f,
-	0xb9, 0x9a, 0x18, 0x04, 0xf8, 0x0f, 0xe9, 0x68, 0x88, 0x19, 0xe4, 0x55, 0xd3, 0x92, 0x93, 0x79,
-	0xac, 0x14, 0xae, 0x57, 0xe9, 0x7a, 0xf5, 0x6a, 0x76, 0x3a, 0x28, 0x6f, 0x67, 0x5f, 0x39, 0xef,
-	0x58, 0x8c, 0x99, 0x3e, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xe9, 0x70, 0x34, 0x75, 0x9e, 0x01,
-	0x00, 0x00,
+	// 239 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0xcb, 0x48, 0x2c, 0xc8,
+	0xd4, 0x4f, 0xce, 0x48, 0x2c, 0x2a, 0x81, 0x90, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x5c,
+	0x20, 0x71, 0x3d, 0xb0, 0x88, 0x94, 0x38, 0xb2, 0x9a, 0xfc, 0xbc, 0xb4, 0xcc, 0x74, 0x88, 0x22,
+	0x29, 0x49, 0x24, 0x89, 0xdc, 0xd4, 0x92, 0xc4, 0x94, 0xc4, 0x92, 0x44, 0x2c, 0x52, 0x25, 0xa9,
+	0xb9, 0x05, 0x39, 0x89, 0x25, 0xa9, 0x30, 0xa9, 0xf4, 0xfc, 0xfc, 0xf4, 0x9c, 0x54, 0x7d, 0x30,
+	0x2f, 0xa9, 0x34, 0x4d, 0x3f, 0x31, 0xaf, 0x12, 0x22, 0xa5, 0xf4, 0x87, 0x91, 0x8b, 0xd5, 0x19,
+	0xa4, 0x47, 0xc8, 0x80, 0x8b, 0x03, 0x66, 0xa2, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xb7, 0x91, 0x88,
+	0x1e, 0xc2, 0x49, 0x7a, 0xbe, 0x50, 0xb9, 0x20, 0xb8, 0x2a, 0x21, 0x23, 0x2e, 0x4e, 0x98, 0x45,
+	0xc5, 0x12, 0x4c, 0x0a, 0xcc, 0xe8, 0x5a, 0x42, 0xa0, 0x92, 0x41, 0x08, 0x65, 0x42, 0xa6, 0x5c,
+	0x3c, 0x29, 0xa9, 0x05, 0xa9, 0x79, 0x29, 0xa9, 0x79, 0xc9, 0x99, 0x40, 0x6d, 0xcc, 0x60, 0x6d,
+	0x82, 0xc8, 0xda, 0xc0, 0xce, 0x09, 0x42, 0x51, 0x26, 0xa4, 0xc5, 0xc5, 0x56, 0x96, 0x98, 0x53,
+	0x0a, 0xd4, 0xc0, 0x02, 0x76, 0x9a, 0x10, 0x8a, 0x06, 0x70, 0x08, 0x05, 0x41, 0x55, 0x00, 0xd5,
+	0xb2, 0xa6, 0x65, 0xe6, 0x00, 0x95, 0xb2, 0x42, 0x9d, 0x04, 0xf1, 0xbd, 0x1e, 0xcc, 0xf7, 0x7a,
+	0x8e, 0x79, 0x95, 0x41, 0x10, 0x25, 0x4e, 0xec, 0x51, 0xac, 0x60, 0x33, 0x92, 0xd8, 0xc0, 0xb2,
+	0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe9, 0x70, 0x34, 0x75, 0x9e, 0x01, 0x00, 0x00,
 }

pkg/proto/hapi/chart/config.pb.go

@@ -49,7 +49,7 @@ func init() {
 func init() { proto.RegisterFile("hapi/chart/config.proto", fileDescriptor1) }
 
 var fileDescriptor1 = []byte{
-	// 182 bytes of a gzipped FileDescriptorProto
+	// 179 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0xc8,
 	0xd4, 0x4f, 0xce, 0x48, 0x2c, 0x2a, 0xd1, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2b, 0x28,
 	0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x02, 0x49, 0xe8, 0x81, 0x25, 0x94, 0x16, 0x30, 0x72, 0xb1, 0x39,
@@ -57,9 +57,9 @@ var fileDescriptor1 = []byte{
 	0x40, 0x4c, 0x21, 0x33, 0x2e, 0xb6, 0xb2, 0xc4, 0x9c, 0xd2, 0xd4, 0x62, 0x09, 0x26, 0x05, 0x66,
 	0x0d, 0x6e, 0x23, 0x39, 0x3d, 0x84, 0x4e, 0x3d, 0x88, 0x2e, 0xbd, 0x30, 0xb0, 0x02, 0xd7, 0xbc,
 	0x92, 0xa2, 0xca, 0x20, 0xa8, 0x6a, 0x29, 0x1f, 0x2e, 0x6e, 0x24, 0x61, 0x90, 0xc1, 0xd9, 0xa9,
-	0x95, 0x30, 0x83, 0xb3, 0x53, 0x2b, 0x85, 0xd4, 0xb9, 0x58, 0xc1, 0x4a, 0x25, 0x98, 0x14, 0x18,
-	0x35, 0xb8, 0x8d, 0x04, 0x91, 0xcd, 0x05, 0xeb, 0x0c, 0x82, 0xc8, 0x5b, 0x31, 0x59, 0x30, 0x2a,
-	0xc9, 0x72, 0xb1, 0x82, 0xc5, 0x84, 0x44, 0x60, 0xba, 0x20, 0x26, 0x41, 0x38, 0x4e, 0xec, 0x51,
-	0xac, 0x60, 0x8d, 0x49, 0x6c, 0x60, 0xdf, 0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x12,
-	0x60, 0xda, 0xf8, 0x00, 0x00, 0x00,
+	0x95, 0x30, 0x83, 0x81, 0x4c, 0x21, 0x75, 0x2e, 0x56, 0xb0, 0x52, 0xa0, 0xb9, 0x8c, 0x40, 0x73,
+	0x05, 0x91, 0xcd, 0x05, 0xeb, 0x0c, 0x82, 0xc8, 0x5b, 0x31, 0x59, 0x30, 0x2a, 0xc9, 0x72, 0xb1,
+	0x82, 0xc5, 0x84, 0x44, 0x60, 0xba, 0x20, 0x26, 0x41, 0x38, 0x4e, 0xec, 0x51, 0xac, 0x60, 0x8d,
+	0x49, 0x6c, 0x60, 0xdf, 0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x12, 0x60, 0xda, 0xf8,
+	0x00, 0x00, 0x00,
 }

pkg/proto/hapi/chart/metadata.pb.go

@@ -94,24 +94,23 @@ func init() {
 func init() { proto.RegisterFile("hapi/chart/metadata.proto", fileDescriptor2) }
 
 var fileDescriptor2 = []byte{
-	// 290 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x91, 0x4d, 0x4b, 0xf4, 0x30,
-	0x14, 0x85, 0xdf, 0x4e, 0xbf, 0x6f, 0x37, 0xc3, 0xe5, 0x65, 0x88, 0x2e, 0xa4, 0x74, 0xd5, 0x55,
-	0x07, 0x14, 0xc4, 0xb5, 0x20, 0x2e, 0x74, 0x3a, 0x52, 0xfc, 0x00, 0x77, 0xb1, 0x0d, 0x36, 0x68,
-	0x93, 0x92, 0x44, 0xc5, 0xff, 0xe8, 0x8f, 0x92, 0xa6, 0x9d, 0x99, 0x2e, 0xdc, 0xdd, 0x73, 0x9e,
-	0x9e, 0xdb, 0x9c, 0x04, 0x8e, 0x5a, 0xda, 0xf3, 0x75, 0xdd, 0x52, 0x65, 0xd6, 0x1d, 0x33, 0xb4,
-	0xa1, 0x86, 0x16, 0xbd, 0x92, 0x46, 0x22, 0x0c, 0xa8, 0xb0, 0x28, 0x3b, 0x07, 0xd8, 0x50, 0x2e,
-	0x0c, 0xe5, 0x82, 0x29, 0x44, 0xf0, 0x04, 0xed, 0x18, 0x71, 0x52, 0x27, 0x8f, 0x2b, 0x3b, 0xe3,
-	0x7f, 0xf0, 0x59, 0x47, 0xf9, 0x3b, 0x59, 0x58, 0x73, 0x14, 0xd9, 0xcf, 0x02, 0xa2, 0xcd, 0xb4,
-	0xf6, 0xcf, 0x18, 0x82, 0xd7, 0xca, 0x8e, 0x4d, 0x29, 0x3b, 0x23, 0x81, 0x50, 0xcb, 0x0f, 0x55,
-	0x33, 0x4d, 0xdc, 0xd4, 0xcd, 0xe3, 0x6a, 0x27, 0x07, 0xf2, 0xc9, 0x94, 0xe6, 0x52, 0x10, 0xcf,
-	0x06, 0x76, 0x12, 0x53, 0x48, 0x1a, 0xa6, 0x6b, 0xc5, 0x7b, 0x33, 0x50, 0xdf, 0xd2, 0xb9, 0x85,
-	0xc7, 0x10, 0xbd, 0xb1, 0xef, 0x2f, 0xa9, 0x1a, 0x4d, 0x02, 0xbb, 0x76, 0xaf, 0xf1, 0x02, 0x92,
-	0x6e, 0x5f, 0x4f, 0x93, 0x30, 0x75, 0xf3, 0xe4, 0x74, 0x55, 0x1c, 0x2e, 0xa0, 0x38, 0xb4, 0xaf,
-	0xe6, 0x9f, 0xe2, 0x0a, 0x02, 0x26, 0x5e, 0xb9, 0x60, 0x24, 0xb2, 0xbf, 0x9c, 0xd4, 0xd0, 0x8b,
-	0xd7, 0x52, 0x90, 0x78, 0xec, 0x35, 0xcc, 0x78, 0x02, 0x40, 0x7b, 0xfe, 0x38, 0x15, 0x00, 0x4b,
-	0x66, 0x4e, 0x96, 0x42, 0x70, 0x35, 0xa6, 0x13, 0x08, 0x1f, 0xca, 0x9b, 0x72, 0xfb, 0x54, 0x2e,
-	0xff, 0x61, 0x0c, 0xfe, 0xf5, 0xf6, 0xfe, 0xee, 0x76, 0xe9, 0x5c, 0x86, 0xcf, 0xbe, 0x3d, 0xce,
-	0x4b, 0x60, 0x9f, 0xe8, 0xec, 0x37, 0x00, 0x00, 0xff, 0xff, 0x65, 0x86, 0x8b, 0xda, 0xbf, 0x01,
-	0x00, 0x00,
+	// 287 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x51, 0x4b, 0x4b, 0xc4, 0x30,
+	0x10, 0x76, 0x1f, 0x6d, 0xb7, 0xd3, 0xcb, 0x32, 0xc8, 0x12, 0x3d, 0x48, 0xe9, 0xc9, 0x53, 0x17,
+	0x14, 0xc4, 0xb3, 0x20, 0x1e, 0x74, 0xbb, 0xb2, 0xf8, 0x00, 0x6f, 0xb1, 0x0d, 0x36, 0x68, 0x9b,
+	0x92, 0x44, 0xc5, 0xff, 0xe8, 0x8f, 0x32, 0x9d, 0x76, 0x77, 0x7b, 0xf0, 0x50, 0xf8, 0x1e, 0xfd,
+	0x26, 0xf3, 0x25, 0x70, 0x54, 0xf2, 0x46, 0x2e, 0xf3, 0x92, 0x6b, 0xbb, 0xac, 0x84, 0xe5, 0x05,
+	0xb7, 0x3c, 0x6d, 0xb4, 0xb2, 0x0a, 0xa1, 0xb5, 0x52, 0xb2, 0x92, 0x0b, 0x80, 0x15, 0x97, 0xb5,
+	0x75, 0x9f, 0xd0, 0x88, 0x30, 0xad, 0x79, 0x25, 0xd8, 0x28, 0x1e, 0x9d, 0x86, 0x1b, 0xc2, 0x78,
+	0x08, 0x9e, 0xa8, 0xb8, 0xfc, 0x60, 0x63, 0x12, 0x3b, 0x92, 0xfc, 0x8e, 0x61, 0xb6, 0xea, 0xc7,
+	0xfe, 0x1b, 0x73, 0x5a, 0xa9, 0x9c, 0xd6, 0xa5, 0x08, 0x23, 0x83, 0xc0, 0xa8, 0x4f, 0x9d, 0x0b,
+	0xc3, 0x26, 0xf1, 0xc4, 0xc9, 0x5b, 0xda, 0x3a, 0x5f, 0x42, 0x1b, 0xa9, 0x6a, 0x36, 0xa5, 0xc0,
+	0x96, 0x62, 0x0c, 0x51, 0x21, 0x4c, 0xae, 0x65, 0x63, 0x5b, 0xd7, 0x23, 0x77, 0x28, 0xe1, 0x31,
+	0xcc, 0xde, 0xc5, 0xcf, 0xb7, 0xd2, 0x85, 0x61, 0x3e, 0x8d, 0xdd, 0x71, 0xbc, 0x84, 0xa8, 0xda,
+	0xd5, 0x33, 0x2c, 0x70, 0x76, 0x74, 0xb6, 0x48, 0xf7, 0x17, 0x90, 0xee, 0xdb, 0x6f, 0x86, 0xbf,
+	0xe2, 0x02, 0x7c, 0x51, 0xbf, 0x39, 0xcc, 0x66, 0x74, 0x64, 0xcf, 0xda, 0x5e, 0x32, 0x77, 0x8b,
+	0x84, 0x5d, 0xaf, 0x16, 0xe3, 0x09, 0x80, 0x1b, 0xf8, 0xd4, 0x17, 0x00, 0x72, 0x06, 0x4a, 0x12,
+	0x83, 0x7f, 0xdd, 0xa5, 0x23, 0x08, 0x1e, 0xb3, 0xdb, 0x6c, 0xfd, 0x9c, 0xcd, 0x0f, 0x30, 0x04,
+	0xef, 0x66, 0xfd, 0x70, 0x7f, 0x37, 0x1f, 0x5d, 0x05, 0x2f, 0x1e, 0xad, 0xf3, 0xea, 0xd3, 0x13,
+	0x9d, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x65, 0x86, 0x8b, 0xda, 0xbf, 0x01, 0x00, 0x00,
 }

pkg/proto/hapi/chart/template.pb.go

@@ -36,12 +36,12 @@ func init() {
 func init() { proto.RegisterFile("hapi/chart/template.proto", fileDescriptor3) }
 
 var fileDescriptor3 = []byte{
-	// 107 bytes of a gzipped FileDescriptorProto
+	// 106 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0x48, 0x2c, 0xc8,
 	0xd4, 0x4f, 0xce, 0x48, 0x2c, 0x2a, 0xd1, 0x2f, 0x49, 0xcd, 0x2d, 0xc8, 0x49, 0x2c, 0x49, 0xd5,
 	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x02, 0x49, 0xe9, 0x81, 0xa5, 0x94, 0x8c, 0xb8, 0x38,
 	0x42, 0xa0, 0xb2, 0x42, 0x42, 0x5c, 0x2c, 0x79, 0x89, 0xb9, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a,
-	0x9c, 0x41, 0x60, 0x36, 0x48, 0x2c, 0x25, 0xb1, 0x24, 0x51, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27,
-	0x08, 0xcc, 0x76, 0x62, 0x8f, 0x62, 0x05, 0x6b, 0x4e, 0x62, 0x03, 0x9b, 0x67, 0x0c, 0x08, 0x00,
-	0x00, 0xff, 0xff, 0x53, 0xee, 0x0e, 0x67, 0x6c, 0x00, 0x00, 0x00,
+	0x9c, 0x41, 0x60, 0x36, 0x48, 0x2c, 0x25, 0xb1, 0x24, 0x51, 0x82, 0x09, 0x28, 0xc6, 0x13, 0x04,
+	0x66, 0x3b, 0xb1, 0x47, 0xb1, 0x82, 0x35, 0x27, 0xb1, 0x81, 0xcd, 0x33, 0x06, 0x04, 0x00, 0x00,
+	0xff, 0xff, 0x53, 0xee, 0x0e, 0x67, 0x6c, 0x00, 0x00, 0x00,
 }

pkg/proto/hapi/release/hook.pb.go

@@ -119,27 +119,27 @@ func init() {
 func init() { proto.RegisterFile("hapi/release/hook.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 343 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x4c, 0x90, 0xdf, 0x6e, 0xa2, 0x40,
-	0x14, 0xc6, 0x17, 0x41, 0xd0, 0xa3, 0xeb, 0xb2, 0x93, 0x4d, 0x76, 0xe2, 0x4d, 0x8d, 0x57, 0x5e,
-	0x0d, 0x8d, 0x4d, 0x1f, 0x00, 0x75, 0xd2, 0x36, 0x12, 0x34, 0x03, 0xa6, 0x49, 0x6f, 0x08, 0xa6,
-	0xa3, 0x12, 0x85, 0x21, 0x82, 0x7d, 0x82, 0x3e, 0x55, 0x9f, 0xae, 0x99, 0xe1, 0x4f, 0x7a, 0x77,
-	0xf8, 0x9d, 0x1f, 0xdf, 0xcc, 0x37, 0xf0, 0xff, 0x14, 0xe7, 0x89, 0x73, 0xe5, 0x17, 0x1e, 0x17,
-	0xdc, 0x39, 0x09, 0x71, 0x26, 0xf9, 0x55, 0x94, 0x02, 0x0d, 0xe5, 0x82, 0xd4, 0x8b, 0xf1, 0xdd,
-	0x51, 0x88, 0xe3, 0x85, 0x3b, 0x6a, 0xb7, 0xbf, 0x1d, 0x9c, 0x32, 0x49, 0x79, 0x51, 0xc6, 0x69,
-	0x5e, 0xe9, 0xd3, 0x4f, 0x1d, 0x8c, 0x67, 0x21, 0xce, 0x08, 0x81, 0x91, 0xc5, 0x29, 0xc7, 0xda,
-	0x44, 0x9b, 0xf5, 0x99, 0x9a, 0x25, 0x3b, 0x27, 0xd9, 0x3b, 0xee, 0x54, 0x4c, 0xce, 0x92, 0xe5,
-	0x71, 0x79, 0xc2, 0x7a, 0xc5, 0xe4, 0x8c, 0xc6, 0xd0, 0x4b, 0xe3, 0x2c, 0x39, 0xf0, 0xa2, 0xc4,
-	0x86, 0xe2, 0xed, 0x37, 0xba, 0x07, 0x93, 0x7f, 0xf0, 0xac, 0x2c, 0x70, 0x77, 0xa2, 0xcf, 0x46,
-	0x73, 0x4c, 0x7e, 0x5e, 0x90, 0xc8, 0xb3, 0x09, 0x95, 0x02, 0xab, 0x3d, 0xf4, 0x08, 0xbd, 0x4b,
-	0x5c, 0x94, 0xd1, 0xf5, 0x96, 0x61, 0x73, 0xa2, 0xcd, 0x06, 0xf3, 0x31, 0xa9, 0x6a, 0x90, 0xa6,
-	0x06, 0x09, 0x9b, 0x1a, 0xcc, 0x92, 0x2e, 0xbb, 0x65, 0xd3, 0x2f, 0x0d, 0xba, 0x2a, 0x08, 0x0d,
-	0xc0, 0xda, 0xf9, 0x6b, 0x7f, 0xf3, 0xea, 0xdb, 0xbf, 0xd0, 0x1f, 0x18, 0x6c, 0x19, 0x8d, 0x5e,
-	0xfc, 0x20, 0x74, 0x3d, 0xcf, 0xd6, 0x90, 0x0d, 0xc3, 0xed, 0x26, 0x08, 0x5b, 0xd2, 0x41, 0x23,
-	0x00, 0xa9, 0xac, 0xa8, 0x47, 0x43, 0x6a, 0xeb, 0xea, 0x17, 0x69, 0xd4, 0xc0, 0x68, 0x32, 0x76,
-	0xdb, 0x27, 0xe6, 0xae, 0xa8, 0xdd, 0x6d, 0x33, 0x1a, 0x62, 0x2a, 0xc2, 0x68, 0xc4, 0x36, 0x9e,
-	0xb7, 0x70, 0x97, 0x6b, 0xdb, 0x42, 0x7f, 0xe1, 0xb7, 0x72, 0x5a, 0xd4, 0x43, 0x18, 0xfe, 0x31,
-	0xea, 0x51, 0x37, 0xa0, 0x51, 0x48, 0x83, 0x30, 0x0a, 0x76, 0xcb, 0x25, 0x0d, 0x02, 0xbb, 0xbf,
-	0xe8, 0xbf, 0x59, 0xf5, 0x8b, 0xec, 0x4d, 0x55, 0xf2, 0xe1, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xdf,
-	0xef, 0x1c, 0xfd, 0xe2, 0x01, 0x00, 0x00,
+	// 340 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x4c, 0x90, 0xcd, 0x6e, 0xb2, 0x40,
+	0x14, 0x86, 0x3f, 0x04, 0x41, 0x8f, 0x7e, 0x96, 0x4e, 0x9a, 0x74, 0xe2, 0xa6, 0xc6, 0x95, 0xab,
+	0xa1, 0xb1, 0xe9, 0x05, 0xa0, 0x4e, 0xda, 0x46, 0x82, 0x66, 0xc0, 0x34, 0xe9, 0xc6, 0x60, 0x3a,
+	0x2a, 0x51, 0x7e, 0x22, 0xd8, 0x2b, 0xe8, 0x55, 0xf5, 0xea, 0xca, 0x0c, 0x3f, 0xe9, 0xee, 0xf0,
+	0x9c, 0xe7, 0xbc, 0xf0, 0x02, 0xf7, 0xc7, 0x20, 0x0d, 0xad, 0x0b, 0x3f, 0xf3, 0x20, 0xe3, 0xd6,
+	0x31, 0x49, 0x4e, 0x24, 0xbd, 0x24, 0x79, 0x82, 0xfa, 0x62, 0x41, 0xaa, 0xc5, 0xf0, 0xe1, 0x90,
+	0x24, 0x87, 0x33, 0xb7, 0xe4, 0x6e, 0x77, 0xdd, 0x5b, 0x79, 0x18, 0xf1, 0x2c, 0x0f, 0xa2, 0xb4,
+	0xd4, 0xc7, 0xdf, 0x2a, 0x68, 0xaf, 0xc5, 0x35, 0x42, 0xa0, 0xc5, 0x41, 0xc4, 0xb1, 0x32, 0x52,
+	0x26, 0x5d, 0x26, 0x67, 0xc1, 0x4e, 0x61, 0xfc, 0x89, 0x5b, 0x25, 0x13, 0xb3, 0x60, 0x69, 0x90,
+	0x1f, 0xb1, 0x5a, 0x32, 0x31, 0xa3, 0x21, 0x74, 0xa2, 0x20, 0x0e, 0xf7, 0x45, 0x32, 0xd6, 0x24,
+	0x6f, 0x9e, 0xd1, 0x23, 0xe8, 0xfc, 0x8b, 0xc7, 0x79, 0x86, 0xdb, 0x23, 0x75, 0x32, 0x98, 0x62,
+	0xf2, 0xf7, 0x03, 0x89, 0x78, 0x37, 0xa1, 0x42, 0x60, 0x95, 0x87, 0x9e, 0xa1, 0x73, 0x0e, 0xb2,
+	0x7c, 0x7b, 0xb9, 0xc6, 0x58, 0x2f, 0xd2, 0x7a, 0xd3, 0x21, 0x29, 0x6b, 0x90, 0xba, 0x06, 0xf1,
+	0xeb, 0x1a, 0xcc, 0x10, 0x2e, 0xbb, 0xc6, 0xe3, 0x1f, 0x05, 0xda, 0x32, 0x08, 0xf5, 0xc0, 0xd8,
+	0xb8, 0x4b, 0x77, 0xf5, 0xee, 0x9a, 0xff, 0xd0, 0x0d, 0xf4, 0xd6, 0x8c, 0x6e, 0xdf, 0x5c, 0xcf,
+	0xb7, 0x1d, 0xc7, 0x54, 0x90, 0x09, 0xfd, 0xf5, 0xca, 0xf3, 0x1b, 0xd2, 0x42, 0x03, 0x00, 0xa1,
+	0x2c, 0xa8, 0x43, 0x7d, 0x6a, 0xaa, 0xf2, 0x44, 0x18, 0x15, 0xd0, 0xea, 0x8c, 0xcd, 0xfa, 0x85,
+	0xd9, 0x0b, 0x6a, 0xb6, 0x9b, 0x8c, 0x9a, 0xe8, 0x92, 0x14, 0x0a, 0x5b, 0x39, 0xce, 0xcc, 0x9e,
+	0x2f, 0x4d, 0x03, 0xdd, 0xc2, 0x7f, 0xe9, 0x34, 0xa8, 0x83, 0x30, 0xdc, 0xb1, 0x22, 0xd3, 0xf6,
+	0xe8, 0xd6, 0xa7, 0xc5, 0xca, 0xdb, 0xcc, 0xe7, 0xd4, 0xf3, 0xcc, 0xee, 0xac, 0xfb, 0x61, 0x54,
+	0x7f, 0x64, 0xa7, 0xcb, 0x92, 0x4f, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xdf, 0xef, 0x1c, 0xfd,
+	0xe2, 0x01, 0x00, 0x00,
 }

pkg/proto/hapi/release/info.pb.go

@@ -22,7 +22,7 @@ type Info struct {
 	// Deleted tracks when this object was deleted.
 	Deleted *google_protobuf.Timestamp `protobuf:"bytes,4,opt,name=deleted" json:"deleted,omitempty"`
 	// Description is human-friendly "log entry" about this release.
-	Description string `protobuf:"bytes,5,opt,name=Description,json=description" json:"Description,omitempty"`
+	Description string `protobuf:"bytes,5,opt,name=Description" json:"Description,omitempty"`
 }
 
 func (m *Info) Reset()                    { *m = Info{} }
@@ -65,20 +65,20 @@ func init() {
 func init() { proto.RegisterFile("hapi/release/info.proto", fileDescriptor1) }
 
 var fileDescriptor1 = []byte{
-	// 236 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0x31, 0x4f, 0xc3, 0x30,
-	0x10, 0x85, 0x95, 0x52, 0x5a, 0xd5, 0x69, 0x19, 0x2c, 0x24, 0x42, 0x16, 0x22, 0xa6, 0x0e, 0xc8,
-	0x91, 0x80, 0x1d, 0x81, 0xba, 0xb0, 0x06, 0x26, 0x16, 0xe4, 0xe2, 0x73, 0xb1, 0xe4, 0xe6, 0x2c,
-	0xfb, 0x3a, 0xf0, 0x2f, 0xf8, 0xc9, 0xa8, 0xb6, 0x03, 0x65, 0xea, 0xea, 0xef, 0xbd, 0xcf, 0xef,
-	0xd8, 0xc5, 0xa7, 0x74, 0xa6, 0xf5, 0x60, 0x41, 0x06, 0x68, 0x4d, 0xaf, 0x51, 0x38, 0x8f, 0x84,
-	0x7c, 0xbe, 0x07, 0x22, 0x83, 0xfa, 0x6a, 0x83, 0xb8, 0xb1, 0xd0, 0x46, 0xb6, 0xde, 0xe9, 0x96,
-	0xcc, 0x16, 0x02, 0xc9, 0xad, 0x4b, 0xf1, 0xfa, 0xf2, 0x9f, 0x27, 0x90, 0xa4, 0x5d, 0x48, 0xe8,
-	0xfa, 0x7b, 0xc4, 0xc6, 0xcf, 0xbd, 0x46, 0x7e, 0xc3, 0x26, 0x09, 0x54, 0x45, 0x53, 0x2c, 0xcb,
-	0xdb, 0x73, 0x71, 0xf8, 0x87, 0x78, 0x89, 0xac, 0xcb, 0x19, 0xfe, 0xc8, 0xce, 0xb4, 0xf1, 0x81,
-	0xde, 0x15, 0x38, 0x8b, 0x5f, 0xa0, 0xaa, 0x51, 0x6c, 0xd5, 0x22, 0x6d, 0x11, 0xc3, 0x16, 0xf1,
-	0x3a, 0x6c, 0xe9, 0x16, 0xb1, 0xb1, 0xca, 0x05, 0xfe, 0xc0, 0x16, 0x56, 0x1e, 0x1a, 0x4e, 0x8e,
-	0x1a, 0xe6, 0xfb, 0xc2, 0xaf, 0xe0, 0x9e, 0x4d, 0x15, 0x58, 0x20, 0x50, 0xd5, 0xf8, 0x68, 0x75,
-	0x88, 0xf2, 0x86, 0x95, 0x2b, 0x08, 0x1f, 0xde, 0x38, 0x32, 0xd8, 0x57, 0xa7, 0x4d, 0xb1, 0x9c,
-	0x75, 0xa5, 0xfa, 0x7b, 0x7a, 0x9a, 0xbd, 0x4d, 0xf3, 0xd5, 0xeb, 0x49, 0x34, 0xdd, 0xfd, 0x04,
-	0x00, 0x00, 0xff, 0xff, 0x1e, 0x2a, 0x57, 0x7d, 0x89, 0x01, 0x00, 0x00,
+	// 231 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0xc8,
+	0xd4, 0x2f, 0x4a, 0xcd, 0x49, 0x4d, 0x2c, 0x4e, 0xd5, 0xcf, 0xcc, 0x4b, 0xcb, 0xd7, 0x2b, 0x28,
+	0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x01, 0x49, 0xe8, 0x41, 0x25, 0xa4, 0xe4, 0xd3, 0xf3, 0xf3, 0xd3,
+	0x73, 0x52, 0xf5, 0xc1, 0x72, 0x49, 0xa5, 0x69, 0xfa, 0x25, 0x99, 0xb9, 0xa9, 0xc5, 0x25, 0x89,
+	0xb9, 0x05, 0x10, 0xe5, 0x52, 0x92, 0x28, 0xe6, 0x00, 0x65, 0x4a, 0x4a, 0x8b, 0x21, 0x52, 0x4a,
+	0x13, 0x98, 0xb8, 0x58, 0x3c, 0x81, 0x06, 0x0b, 0xe9, 0x70, 0xb1, 0x41, 0x24, 0x24, 0x18, 0x15,
+	0x18, 0x35, 0xb8, 0x8d, 0x44, 0xf4, 0x90, 0xed, 0xd0, 0x0b, 0x06, 0xcb, 0x05, 0x41, 0xd5, 0x08,
+	0x39, 0x72, 0xf1, 0xa5, 0x65, 0x16, 0x15, 0x97, 0xc4, 0xa7, 0xa4, 0x16, 0xe4, 0xe4, 0x57, 0xa6,
+	0xa6, 0x48, 0x30, 0x81, 0x75, 0x49, 0xe9, 0x41, 0xdc, 0xa2, 0x07, 0x73, 0x8b, 0x5e, 0x08, 0xcc,
+	0x2d, 0x41, 0xbc, 0x60, 0x1d, 0x2e, 0x50, 0x0d, 0x42, 0xf6, 0x5c, 0xbc, 0x39, 0x89, 0xc8, 0x26,
+	0x30, 0x13, 0x34, 0x81, 0x07, 0xa4, 0x01, 0x6e, 0x80, 0x09, 0x17, 0x7b, 0x0a, 0xd0, 0x75, 0x25,
+	0x40, 0xad, 0x2c, 0x04, 0xb5, 0xc2, 0x94, 0x0a, 0x29, 0x70, 0x71, 0xbb, 0xa4, 0x16, 0x27, 0x17,
+	0x65, 0x16, 0x94, 0x64, 0xe6, 0xe7, 0x49, 0xb0, 0x02, 0x75, 0x72, 0x06, 0x21, 0x0b, 0x39, 0x71,
+	0x46, 0xb1, 0x43, 0x7d, 0x9d, 0xc4, 0x06, 0x36, 0xc9, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x1a,
+	0x52, 0x8f, 0x9c, 0x89, 0x01, 0x00, 0x00,
 }

pkg/proto/hapi/release/release.pb.go

@@ -35,8 +35,6 @@ type Release struct {
 	Version int32 `protobuf:"varint,7,opt,name=version" json:"version,omitempty"`
 	// Namespace is the kubernetes namespace of the release.
 	Namespace string `protobuf:"bytes,8,opt,name=namespace" json:"namespace,omitempty"`
-	// LastTestSuiteRun provides results on the last test run on a release
-	LastTestSuiteRun *TestSuite `protobuf:"bytes,9,opt,name=last_test_suite_run,json=lastTestSuiteRun" json:"last_test_suite_run,omitempty"`
 }
 
 func (m *Release) Reset()                    { *m = Release{} }
@@ -72,13 +70,6 @@ func (m *Release) GetHooks() []*Hook {
 	return nil
 }
 
-func (m *Release) GetLastTestSuiteRun() *TestSuite {
-	if m != nil {
-		return m.LastTestSuiteRun
-	}
-	return nil
-}
-
 func init() {
 	proto.RegisterType((*Release)(nil), "hapi.release.Release")
 }
@@ -86,24 +77,21 @@ func init() {
 func init() { proto.RegisterFile("hapi/release/release.proto", fileDescriptor2) }
 
 var fileDescriptor2 = []byte{
-	// 300 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x90, 0xcd, 0x4e, 0x84, 0x30,
-	0x10, 0x80, 0xc3, 0x2e, 0x3f, 0x4b, 0xf5, 0xa0, 0x63, 0xe2, 0x36, 0x44, 0x13, 0xe2, 0x41, 0x89,
-	0x07, 0x36, 0xd1, 0x37, 0xd0, 0xc4, 0xe8, 0xb5, 0x7a, 0xf2, 0x42, 0x2a, 0x29, 0xd2, 0xec, 0x6e,
-	0x4b, 0x68, 0xf1, 0x79, 0x7d, 0x14, 0xd3, 0x9f, 0x15, 0xd0, 0x4b, 0x61, 0xe6, 0xfb, 0x3a, 0x33,
-	0x1d, 0x94, 0xb5, 0xb4, 0xe3, 0x9b, 0x9e, 0xed, 0x18, 0x55, 0xec, 0xf0, 0x2d, 0xbb, 0x5e, 0x6a,
-	0x09, 0xc7, 0x86, 0x95, 0x3e, 0x97, 0xad, 0x67, 0x66, 0x2b, 0xe5, 0xd6, 0x69, 0x7f, 0x00, 0x17,
-	0x8d, 0xf4, 0xe0, 0x72, 0x06, 0x34, 0x53, 0xba, 0x52, 0x03, 0xd7, 0x6c, 0x76, 0xaf, 0x6e, 0x69,
-	0xaf, 0x37, 0xb5, 0x14, 0x0d, 0xff, 0xf4, 0xe0, 0x7c, 0x0a, 0xcc, 0xe9, 0xf2, 0x57, 0xdf, 0x0b,
-	0x94, 0x10, 0x57, 0x0d, 0x00, 0x85, 0x82, 0xee, 0x19, 0x0e, 0xf2, 0xa0, 0x48, 0x89, 0xfd, 0x87,
-	0x6b, 0x14, 0x9a, 0xee, 0x78, 0x91, 0x07, 0xc5, 0xd1, 0x1d, 0x94, 0xd3, 0xf1, 0xcb, 0x17, 0xd1,
-	0x48, 0x62, 0x39, 0xdc, 0xa0, 0xc8, 0x96, 0xc5, 0x4b, 0x2b, 0x9e, 0x3a, 0xd1, 0x75, 0x7a, 0x34,
-	0x27, 0x71, 0x1c, 0x6e, 0x51, 0xec, 0x06, 0xc3, 0xe1, 0xb4, 0xa4, 0x37, 0x2d, 0x21, 0xde, 0x80,
-	0x0c, 0xad, 0xf6, 0x54, 0xf0, 0x86, 0x29, 0x8d, 0x23, 0x3b, 0xd4, 0x6f, 0x0c, 0x05, 0x8a, 0xcc,
-	0xbe, 0x14, 0x8e, 0xf3, 0xe5, 0xff, 0xc9, 0x9e, 0xa5, 0xdc, 0x12, 0x27, 0x00, 0x46, 0xc9, 0x17,
-	0xeb, 0x15, 0x97, 0x02, 0x27, 0x79, 0x50, 0x44, 0xe4, 0x10, 0xc2, 0x05, 0x4a, 0xcd, 0x23, 0x55,
-	0x47, 0x6b, 0x86, 0x57, 0xb6, 0xc1, 0x98, 0x80, 0x27, 0x74, 0xb6, 0xa3, 0x4a, 0x57, 0xe3, 0x92,
-	0xab, 0x7e, 0x10, 0x38, 0xb5, 0x63, 0xaf, 0xe7, 0xfd, 0xde, 0x98, 0xd2, 0xaf, 0x46, 0x21, 0x27,
-	0xe6, 0xce, 0x18, 0x0e, 0xe2, 0x21, 0x7d, 0x4f, 0xbc, 0xf6, 0x11, 0xdb, 0xa5, 0xdf, 0xff, 0x04,
-	0x00, 0x00, 0xff, 0xff, 0x85, 0x06, 0x87, 0x2b, 0x22, 0x02, 0x00, 0x00,
+	// 254 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x90, 0x3f, 0x4f, 0xc3, 0x30,
+	0x10, 0xc5, 0xd5, 0x36, 0x7f, 0x9a, 0x83, 0x85, 0x1b, 0xe0, 0x14, 0x31, 0x54, 0x0c, 0x50, 0x31,
+	0xa4, 0x12, 0x7c, 0x03, 0x58, 0x60, 0xf5, 0xc8, 0x66, 0x22, 0x87, 0x58, 0x50, 0x3b, 0x8a, 0x23,
+	0x3e, 0x0b, 0x1f, 0x17, 0xdb, 0xe7, 0x42, 0x0a, 0x8b, 0x13, 0xbf, 0xdf, 0xd3, 0xbb, 0xe7, 0x83,
+	0xba, 0x97, 0x83, 0xde, 0x8d, 0xea, 0x43, 0x49, 0xa7, 0x0e, 0xdf, 0x66, 0x18, 0xed, 0x64, 0xf1,
+	0x34, 0xb0, 0x26, 0x69, 0xf5, 0xc5, 0x91, 0xb3, 0xb7, 0xf6, 0x9d, 0x6d, 0x7f, 0x80, 0x36, 0x9d,
+	0x3d, 0x02, 0x6d, 0x2f, 0xc7, 0x69, 0xd7, 0x5a, 0xd3, 0xe9, 0xb7, 0x04, 0xce, 0xe7, 0x20, 0x9c,
+	0xac, 0x5f, 0x7d, 0x2d, 0xa1, 0x14, 0x9c, 0x83, 0x08, 0x99, 0x91, 0x7b, 0x45, 0x8b, 0xcd, 0x62,
+	0x5b, 0x89, 0xf8, 0x8f, 0xd7, 0x90, 0x85, 0x78, 0x5a, 0x7a, 0xed, 0xe4, 0x0e, 0x9b, 0x79, 0xbf,
+	0xe6, 0xd9, 0x13, 0x11, 0x39, 0xde, 0x40, 0x1e, 0x63, 0x69, 0x15, 0x8d, 0x67, 0x6c, 0xe4, 0x49,
+	0x8f, 0xe1, 0x14, 0xcc, 0xf1, 0x16, 0x0a, 0x2e, 0x46, 0xd9, 0x3c, 0x32, 0x39, 0x23, 0x11, 0xc9,
+	0x81, 0x35, 0xac, 0xf7, 0xd2, 0xe8, 0x4e, 0xb9, 0x89, 0xf2, 0x58, 0xea, 0xe7, 0x8e, 0x5b, 0xc8,
+	0xc3, 0x42, 0x1c, 0x15, 0x9b, 0xd5, 0xff, 0x66, 0x4f, 0x1e, 0x09, 0x36, 0x20, 0x41, 0xf9, 0xa9,
+	0x46, 0xa7, 0xad, 0xa1, 0xd2, 0x87, 0xe4, 0xe2, 0x70, 0xc5, 0x4b, 0xa8, 0xc2, 0x23, 0xdd, 0x20,
+	0x5b, 0x45, 0xeb, 0x38, 0xe0, 0x57, 0x78, 0xa8, 0x5e, 0xca, 0x14, 0xf7, 0x5a, 0xc4, 0x65, 0xdd,
+	0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x8f, 0xec, 0x97, 0xbb, 0x01, 0x00, 0x00,
 }

pkg/proto/hapi/release/status.pb.go

@@ -60,6 +60,8 @@ type Status struct {
 	Resources string `protobuf:"bytes,3,opt,name=resources" json:"resources,omitempty"`
 	// Contains the rendered templates/NOTES.txt if available
 	Notes string `protobuf:"bytes,4,opt,name=notes" json:"notes,omitempty"`
+	// LastTestSuiteRun provides results on the last test run on a release
+	LastTestSuiteRun *TestSuite `protobuf:"bytes,5,opt,name=last_test_suite_run,json=lastTestSuiteRun" json:"last_test_suite_run,omitempty"`
 }
 
 func (m *Status) Reset()                    { *m = Status{} }
@@ -67,6 +69,13 @@ func (m *Status) String() string            { return proto.CompactTextString(m)
 func (*Status) ProtoMessage()               {}
 func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
 
+func (m *Status) GetLastTestSuiteRun() *TestSuite {
+	if m != nil {
+		return m.LastTestSuiteRun
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*Status)(nil), "hapi.release.Status")
 	proto.RegisterEnum("hapi.release.Status_Code", Status_Code_name, Status_Code_value)
@@ -75,21 +84,23 @@ func init() {
 func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor3) }
 
 var fileDescriptor3 = []byte{
-	// 244 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x4c, 0x8f, 0xcf, 0x4a, 0xc3, 0x40,
-	0x10, 0xc6, 0x5d, 0x9b, 0xa6, 0x66, 0x2c, 0x65, 0x59, 0x3c, 0x24, 0xe2, 0xa1, 0xf4, 0xd4, 0x8b,
-	0x1b, 0xd0, 0x27, 0x50, 0x77, 0x94, 0x62, 0x48, 0x4b, 0xd2, 0xe2, 0x9f, 0x5b, 0xda, 0x8e, 0x55,
-	0x28, 0x9d, 0x92, 0x4d, 0x0e, 0x3e, 0xa0, 0xef, 0x25, 0xd9, 0x04, 0xf4, 0x38, 0xf3, 0xfb, 0x7d,
-	0x1f, 0x33, 0x10, 0x7d, 0x16, 0xc7, 0xaf, 0xb8, 0xa4, 0x3d, 0x15, 0x96, 0x62, 0x5b, 0x15, 0x55,
-	0x6d, 0xf5, 0xb1, 0xe4, 0x8a, 0xd5, 0xb0, 0x41, 0xba, 0x43, 0x97, 0xd1, 0x8e, 0x79, 0xb7, 0xa7,
-	0xd8, 0xb1, 0x75, 0xfd, 0x11, 0x17, 0x87, 0xef, 0x56, 0x9c, 0xfc, 0x08, 0xf0, 0x73, 0x97, 0x54,
-	0xd7, 0xe0, 0x6d, 0x78, 0x4b, 0xa1, 0x18, 0x8b, 0xe9, 0xe8, 0x26, 0xd2, 0xff, 0x2b, 0x74, 0xeb,
-	0xe8, 0x07, 0xde, 0x52, 0xe6, 0x34, 0x75, 0x05, 0x41, 0x49, 0x96, 0xeb, 0x72, 0x43, 0x36, 0xec,
-	0x8d, 0xc5, 0x34, 0xc8, 0xfe, 0x16, 0xea, 0x02, 0xfa, 0x07, 0xae, 0xc8, 0x86, 0x9e, 0x23, 0xed,
-	0x30, 0x79, 0x05, 0xaf, 0x69, 0x50, 0xe7, 0x30, 0x58, 0xa5, 0xcf, 0xe9, 0xfc, 0x25, 0x95, 0x27,
-	0x6a, 0x08, 0x67, 0x06, 0x17, 0xc9, 0xfc, 0x0d, 0x8d, 0x14, 0x0d, 0x32, 0x98, 0xe0, 0x12, 0x8d,
-	0x3c, 0x55, 0x23, 0x80, 0x7c, 0xb5, 0xc0, 0x2c, 0x47, 0x83, 0x46, 0xf6, 0x14, 0x80, 0xff, 0x78,
-	0x37, 0x4b, 0xd0, 0x48, 0xaf, 0x8d, 0x25, 0xb8, 0x9c, 0xa5, 0x4f, 0xb2, 0x7f, 0x1f, 0xbc, 0x0f,
-	0xba, 0x53, 0xd7, 0xbe, 0xfb, 0xec, 0xf6, 0x37, 0x00, 0x00, 0xff, 0xff, 0x1b, 0xab, 0xfe, 0xbf,
-	0x1f, 0x01, 0x00, 0x00,
+	// 288 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x54, 0x90, 0x5f, 0x6b, 0xf2, 0x30,
+	0x14, 0xc6, 0xdf, 0x6a, 0x5b, 0xdf, 0x1e, 0x45, 0x4a, 0x36, 0x58, 0x2b, 0x1b, 0x0c, 0xaf, 0x76,
+	0xb3, 0x16, 0xdc, 0x27, 0xd8, 0xd6, 0x38, 0x64, 0xa5, 0x4a, 0xab, 0xec, 0xcf, 0x8d, 0x54, 0x97,
+	0x39, 0xa1, 0x34, 0xd2, 0x24, 0x17, 0xfb, 0x10, 0xfb, 0xce, 0x3b, 0x6d, 0x84, 0xce, 0xbb, 0x3c,
+	0x79, 0x7e, 0x27, 0xe7, 0x47, 0xc0, 0xff, 0xca, 0x0f, 0xfb, 0xb0, 0x62, 0x05, 0xcb, 0x05, 0x0b,
+	0x85, 0xcc, 0xa5, 0x12, 0xc1, 0xa1, 0xe2, 0x92, 0x93, 0x41, 0x5d, 0x05, 0xc7, 0x6a, 0x74, 0x75,
+	0x02, 0x4a, 0x26, 0xe4, 0x5a, 0xa8, 0xbd, 0x64, 0x1a, 0x1e, 0xf9, 0x3b, 0xce, 0x77, 0x05, 0x0b,
+	0x9b, 0xb4, 0x51, 0x9f, 0x61, 0x5e, 0x7e, 0xeb, 0x6a, 0xfc, 0xd3, 0x01, 0x3b, 0x6b, 0x1e, 0x26,
+	0xb7, 0x60, 0x6e, 0xf9, 0x07, 0xf3, 0x8c, 0x6b, 0xe3, 0x66, 0x38, 0xf1, 0x83, 0xbf, 0x1b, 0x02,
+	0xcd, 0x04, 0x8f, 0x08, 0xa4, 0x0d, 0x46, 0x2e, 0xc1, 0xa9, 0x98, 0xe0, 0xaa, 0xda, 0x32, 0xe1,
+	0x75, 0x71, 0xc6, 0x49, 0xdb, 0x0b, 0x72, 0x0e, 0x56, 0xc9, 0x51, 0xc4, 0x33, 0x9b, 0x46, 0x07,
+	0x32, 0x85, 0xb3, 0x22, 0x47, 0xb9, 0xd6, 0x70, 0x5d, 0xa9, 0xd2, 0xb3, 0x90, 0xe9, 0x4f, 0x2e,
+	0x4e, 0x37, 0x2e, 0x91, 0xc9, 0x6a, 0x24, 0x75, 0xeb, 0x99, 0x36, 0xaa, 0x72, 0xfc, 0x0a, 0x66,
+	0x6d, 0x42, 0xfa, 0xd0, 0x5b, 0x25, 0xcf, 0xc9, 0xfc, 0x25, 0x71, 0xff, 0x91, 0x01, 0xfc, 0x8f,
+	0xe8, 0x22, 0x9e, 0xbf, 0xd1, 0xc8, 0x35, 0xea, 0x2a, 0xa2, 0x31, 0x5d, 0x62, 0xe8, 0x90, 0x21,
+	0x40, 0xb6, 0x5a, 0xd0, 0x34, 0xa3, 0x11, 0xe6, 0x2e, 0x01, 0xb0, 0xa7, 0xf7, 0xb3, 0x18, 0xcf,
+	0xa6, 0x1e, 0x43, 0x70, 0x96, 0x3c, 0xb9, 0xd6, 0x83, 0xf3, 0xde, 0x3b, 0x0a, 0x6c, 0xec, 0xe6,
+	0x87, 0xee, 0x7e, 0x03, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x11, 0x21, 0x30, 0x86, 0x01, 0x00, 0x00,
 }

pkg/proto/hapi/release/test_run.pb.go

@@ -73,22 +73,22 @@ func init() {
 func init() { proto.RegisterFile("hapi/release/test_run.proto", fileDescriptor4) }
 
 var fileDescriptor4 = []byte{
-	// 265 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0x41, 0x4b, 0xfb, 0x40,
-	0x14, 0xc4, 0xff, 0xc9, 0xbf, 0x26, 0x64, 0x53, 0x24, 0xec, 0x29, 0x54, 0xc1, 0xd0, 0x53, 0x4e,
-	0xbb, 0x50, 0xbd, 0x78, 0xf0, 0x10, 0x4b, 0x05, 0x51, 0x22, 0x6c, 0x1a, 0x04, 0x2f, 0x65, 0xab,
-	0xaf, 0x35, 0x90, 0x64, 0x43, 0xf6, 0xe5, 0x8b, 0xf8, 0x89, 0x65, 0x93, 0xad, 0x78, 0xf3, 0xf6,
-	0x86, 0xf9, 0xcd, 0x30, 0x8f, 0x5c, 0x7c, 0xca, 0xae, 0xe2, 0x3d, 0xd4, 0x20, 0x35, 0x70, 0x04,
-	0x8d, 0xbb, 0x7e, 0x68, 0x59, 0xd7, 0x2b, 0x54, 0x74, 0x6e, 0x4c, 0x66, 0xcd, 0xc5, 0xd5, 0x51,
-	0xa9, 0x63, 0x0d, 0x7c, 0xf4, 0xf6, 0xc3, 0x81, 0x63, 0xd5, 0x80, 0x46, 0xd9, 0x74, 0x13, 0xbe,
-	0xfc, 0x72, 0x89, 0xbf, 0x05, 0x8d, 0x62, 0x68, 0x29, 0x25, 0xb3, 0x56, 0x36, 0x10, 0x3b, 0x89,
-	0x93, 0x06, 0x62, 0xbc, 0xe9, 0x0d, 0xf1, 0x34, 0x4a, 0x1c, 0x74, 0xec, 0x26, 0x4e, 0x7a, 0xbe,
-	0xba, 0x64, 0xbf, 0xfb, 0x99, 0x8d, 0xb2, 0x62, 0x64, 0x84, 0x65, 0x4d, 0x53, 0xd5, 0x1e, 0x54,
-	0xfc, 0x7f, 0x6a, 0x32, 0x37, 0xbd, 0x25, 0x44, 0xa3, 0xec, 0x11, 0x3e, 0x76, 0x12, 0xe3, 0x59,
-	0xe2, 0xa4, 0xe1, 0x6a, 0xc1, 0xa6, 0x7d, 0xec, 0xb4, 0x8f, 0x6d, 0x4f, 0xfb, 0x44, 0x60, 0xe9,
-	0x0c, 0xe9, 0x1d, 0x99, 0xbf, 0xab, 0xa6, 0xab, 0xc1, 0x86, 0xcf, 0xfe, 0x0c, 0x87, 0x3f, 0x7c,
-	0x86, 0x4b, 0x4e, 0xbc, 0x69, 0x1f, 0x0d, 0x89, 0x5f, 0xe6, 0x4f, 0xf9, 0xcb, 0x6b, 0x1e, 0xfd,
-	0x33, 0xa2, 0x28, 0xd7, 0xeb, 0x4d, 0x51, 0x44, 0x8e, 0x11, 0x0f, 0xd9, 0xe3, 0x73, 0x29, 0x36,
-	0x91, 0x7b, 0x1f, 0xbc, 0xf9, 0xf6, 0xc1, 0xbd, 0x37, 0x96, 0x5f, 0x7f, 0x07, 0x00, 0x00, 0xff,
-	0xff, 0x8d, 0xb9, 0xce, 0x57, 0x74, 0x01, 0x00, 0x00,
+	// 262 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0x41, 0x4b, 0xc3, 0x40,
+	0x10, 0x85, 0x4d, 0xac, 0x09, 0x99, 0x14, 0x09, 0x7b, 0x0a, 0x55, 0x50, 0x7a, 0xf2, 0xb4, 0x0b,
+	0xd5, 0x8b, 0x07, 0x0f, 0xb1, 0x54, 0x10, 0x25, 0xc2, 0xa6, 0x41, 0xf0, 0x52, 0xb6, 0xba, 0xad,
+	0x81, 0x24, 0x1b, 0x92, 0xc9, 0x1f, 0xf1, 0x17, 0xbb, 0x9b, 0x6c, 0xc5, 0x5b, 0x6f, 0x33, 0xf3,
+	0xbe, 0xf7, 0x78, 0x03, 0x17, 0xdf, 0xa2, 0x29, 0x58, 0x2b, 0x4b, 0x29, 0x3a, 0xc9, 0x50, 0x76,
+	0xb8, 0x69, 0xfb, 0x9a, 0x36, 0xad, 0x42, 0x45, 0xa6, 0x46, 0xa4, 0x56, 0x9c, 0x5d, 0xed, 0x95,
+	0xda, 0x97, 0x92, 0x0d, 0xda, 0xb6, 0xdf, 0x31, 0x2c, 0x2a, 0xcd, 0x8b, 0xaa, 0x19, 0xf1, 0xf9,
+	0x8f, 0x0b, 0xfe, 0x5a, 0x5f, 0x78, 0x5f, 0x13, 0x02, 0x93, 0x5a, 0x54, 0x32, 0x76, 0xae, 0x9d,
+	0x9b, 0x80, 0x0f, 0x33, 0xb9, 0x03, 0x4f, 0xe3, 0xd8, 0x77, 0xb1, 0xab, 0xaf, 0xe7, 0x8b, 0x4b,
+	0xfa, 0x3f, 0x9f, 0x5a, 0x2b, 0xcd, 0x06, 0x86, 0x5b, 0xd6, 0x24, 0x15, 0xf5, 0x4e, 0xc5, 0xa7,
+	0x63, 0x92, 0x99, 0xc9, 0x3d, 0x80, 0x56, 0x5b, 0x94, 0x5f, 0x1b, 0x81, 0xf1, 0x44, 0x2b, 0xe1,
+	0x62, 0x46, 0xc7, 0x7e, 0xf4, 0xd0, 0x8f, 0xae, 0x0f, 0xfd, 0x78, 0x60, 0xe9, 0x04, 0xc9, 0x03,
+	0x4c, 0x3f, 0x55, 0xd5, 0x94, 0xd2, 0x9a, 0xcf, 0x8e, 0x9a, 0xc3, 0x3f, 0x3e, 0xc1, 0x39, 0x03,
+	0x6f, 0xec, 0x47, 0x42, 0xf0, 0xf3, 0xf4, 0x25, 0x7d, 0x7b, 0x4f, 0xa3, 0x13, 0xb3, 0x64, 0xf9,
+	0x72, 0xb9, 0xca, 0xb2, 0xc8, 0x31, 0xcb, 0x53, 0xf2, 0xfc, 0x9a, 0xf3, 0x55, 0xe4, 0x3e, 0x06,
+	0x1f, 0xbe, 0x7d, 0x70, 0xeb, 0x0d, 0xe1, 0xb7, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x8d, 0xb9,
+	0xce, 0x57, 0x74, 0x01, 0x00, 0x00,
 }

pkg/proto/hapi/release/test_suite.pb.go

@@ -57,18 +57,18 @@ func init() {
 func init() { proto.RegisterFile("hapi/release/test_suite.proto", fileDescriptor5) }
 
 var fileDescriptor5 = []byte{
-	// 207 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0xc1, 0x4a, 0x86, 0x40,
-	0x14, 0x85, 0x31, 0x21, 0x71, 0x74, 0x35, 0x10, 0x88, 0x11, 0x49, 0x2b, 0x57, 0x33, 0x60, 0xab,
-	0x16, 0x2d, 0xec, 0x11, 0xcc, 0x55, 0x1b, 0x19, 0xeb, 0x66, 0xc2, 0xe8, 0x0c, 0x73, 0xef, 0xbc,
-	0x5a, 0xcf, 0x17, 0xea, 0x18, 0x41, 0x8b, 0x7f, 0xfd, 0x7d, 0xe7, 0x9c, 0x7b, 0xd9, 0xdd, 0x97,
-	0xb2, 0xb3, 0x74, 0xa0, 0x41, 0x21, 0x48, 0x02, 0xa4, 0x01, 0xfd, 0x4c, 0x20, 0xac, 0x33, 0x64,
-	0x78, 0xbe, 0x61, 0x11, 0x70, 0x79, 0x3f, 0x19, 0x33, 0x69, 0x90, 0x3b, 0x1b, 0xfd, 0xa7, 0xa4,
-	0x79, 0x01, 0x24, 0xb5, 0xd8, 0x43, 0x2f, 0x6f, 0xff, 0xb7, 0x39, 0xbf, 0x1e, 0xf0, 0xe1, 0x3b,
-	0x62, 0x69, 0x0f, 0x48, 0xaf, 0x5b, 0x3f, 0x7f, 0x62, 0x0c, 0x49, 0x39, 0x82, 0x8f, 0x41, 0x51,
-	0x11, 0x55, 0x51, 0x9d, 0x35, 0xa5, 0x38, 0x06, 0xc4, 0x39, 0x20, 0xfa, 0x73, 0xa0, 0x4b, 0x83,
-	0xdd, 0x12, 0x7f, 0x66, 0xf9, 0xbb, 0x59, 0xac, 0x86, 0x10, 0xbe, 0xba, 0x18, 0xce, 0x7e, 0xfd,
-	0x96, 0xb8, 0x64, 0x89, 0x03, 0xf4, 0x9a, 0xb0, 0x88, 0xab, 0xb8, 0xce, 0x9a, 0x1b, 0xf1, 0xf7,
-	0x4b, 0xb1, 0xdd, 0xd8, 0xf9, 0xb5, 0x3b, 0xad, 0x97, 0xf4, 0x2d, 0x09, 0x6c, 0xbc, 0xde, 0xcb,
-	0x1f, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x59, 0x65, 0x4f, 0x37, 0x01, 0x00, 0x00,
+	// 205 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xcd, 0x48, 0x2c, 0xc8,
+	0xd4, 0x2f, 0x4a, 0xcd, 0x49, 0x4d, 0x2c, 0x4e, 0xd5, 0x2f, 0x49, 0x2d, 0x2e, 0x89, 0x2f, 0x2e,
+	0xcd, 0x2c, 0x49, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x01, 0x49, 0xeb, 0x41, 0xa5,
+	0xa5, 0xe4, 0xd3, 0xf3, 0xf3, 0xd3, 0x73, 0x52, 0xf5, 0xc1, 0x72, 0x49, 0xa5, 0x69, 0xfa, 0x25,
+	0x99, 0xb9, 0x40, 0x1d, 0x89, 0xb9, 0x05, 0x10, 0xe5, 0x52, 0xd2, 0x98, 0xa6, 0x15, 0x95, 0xe6,
+	0x41, 0x24, 0x95, 0xb6, 0x31, 0x72, 0x71, 0x86, 0x00, 0x85, 0x82, 0x41, 0xe6, 0x0b, 0x59, 0x72,
+	0x71, 0x01, 0x75, 0x16, 0x95, 0xa4, 0xa6, 0xc4, 0x27, 0x96, 0x48, 0x30, 0x2a, 0x30, 0x6a, 0x70,
+	0x1b, 0x49, 0xe9, 0x41, 0x2c, 0xd0, 0x83, 0x59, 0xa0, 0x17, 0x02, 0xb3, 0x20, 0x88, 0x13, 0xaa,
+	0xda, 0xb1, 0x44, 0xc8, 0x96, 0x8b, 0x27, 0x39, 0x3f, 0xb7, 0x20, 0x27, 0x15, 0xaa, 0x99, 0x89,
+	0xa0, 0x66, 0x6e, 0xb8, 0x7a, 0xa0, 0x76, 0x7d, 0x2e, 0xf6, 0xa2, 0xd4, 0xe2, 0xd2, 0x9c, 0x92,
+	0x62, 0x09, 0x66, 0x05, 0x66, 0xa0, 0x4e, 0x51, 0x3d, 0x64, 0x5f, 0xea, 0x81, 0xdc, 0x18, 0x54,
+	0x9a, 0x17, 0x04, 0x53, 0xe5, 0xc4, 0x19, 0xc5, 0x0e, 0x95, 0x4b, 0x62, 0x03, 0x1b, 0x6e, 0x0c,
+	0x08, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x59, 0x65, 0x4f, 0x37, 0x01, 0x00, 0x00,
 }

pkg/proto/hapi/version/version.pb.go

@@ -47,15 +47,14 @@ func init() {
 func init() { proto.RegisterFile("hapi/version/version.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 151 bytes of a gzipped FileDescriptorProto
+	// 144 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xca, 0x48, 0x2c, 0xc8,
 	0xd4, 0x2f, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0x83, 0xd1, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9,
 	0x42, 0x3c, 0x20, 0x39, 0x3d, 0xa8, 0x98, 0x52, 0x3a, 0x17, 0x7b, 0x18, 0x84, 0x29, 0x24, 0xce,
-	0xc5, 0x5e, 0x9c, 0x9a, 0x1b, 0x5f, 0x96, 0x5a, 0x24, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0xc4,
-	0x56, 0x9c, 0x9a, 0x1b, 0x96, 0x5a, 0x24, 0x24, 0xcb, 0xc5, 0x95, 0x9e, 0x59, 0x12, 0x9f, 0x9c,
-	0x9f, 0x9b, 0x9b, 0x59, 0x22, 0xc1, 0x04, 0x96, 0xe3, 0x4c, 0xcf, 0x2c, 0x71, 0x06, 0x0b, 0x08,
-	0xa9, 0x70, 0xf1, 0x81, 0xa4, 0x4b, 0x8a, 0x52, 0x53, 0xe3, 0x8b, 0x4b, 0x12, 0x4b, 0x52, 0x25,
-	0x98, 0xc1, 0x4a, 0x78, 0xd2, 0x33, 0x4b, 0x42, 0x8a, 0x52, 0x53, 0x83, 0x41, 0x62, 0x4e, 0x9c,
-	0x51, 0xec, 0x50, 0x3b, 0x93, 0xd8, 0xc0, 0x0e, 0x31, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x20,
-	0xcc, 0x0e, 0x1b, 0xa6, 0x00, 0x00, 0x00,
+	0xc5, 0x5e, 0x9c, 0x9a, 0x1b, 0x0f, 0x94, 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x62, 0x03,
+	0x72, 0x81, 0x92, 0x42, 0xb2, 0x5c, 0x5c, 0xe9, 0x99, 0x25, 0xf1, 0xc9, 0xf9, 0xb9, 0xb9, 0x99,
+	0x25, 0x12, 0x4c, 0x60, 0x39, 0x4e, 0xa0, 0x88, 0x33, 0x58, 0x40, 0x48, 0x85, 0x8b, 0x0f, 0x24,
+	0x5d, 0x52, 0x94, 0x9a, 0x1a, 0x5f, 0x5c, 0x92, 0x58, 0x92, 0x2a, 0xc1, 0x0c, 0x56, 0xc2, 0x03,
+	0x14, 0x0d, 0x01, 0x0a, 0x06, 0x83, 0xc4, 0x9c, 0x38, 0xa3, 0xd8, 0xa1, 0x76, 0x26, 0xb1, 0x81,
+	0x1d, 0x62, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x20, 0xcc, 0x0e, 0x1b, 0xa6, 0x00, 0x00, 0x00,
 }

pkg/tiller/release_server.go

@@ -1099,11 +1099,11 @@ func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream
 		return err
 	}
 
-	rel.LastTestSuiteRun = &release.TestSuite{
+	rel.Info.Status.LastTestSuiteRun = &release.TestSuite{
 		StartedAt:   tSuite.StartedAt,
 		CompletedAt: tSuite.CompletedAt,
 		Results:     tSuite.Results,
 	}
 
-	return nil
+	return s.env.Releases.Update(rel)
 }