Merge b3e05f94b2 into c31246467c

_proto/hapi/chart/metadata.proto

@@ -88,6 +88,6 @@ message Metadata {
 	// made available for inspection by other applications.
 	map<string,string> annotations = 16;
 
-	// KubeVersion is a SemVer constraint specifying the version of Kubernetes required.
+	// KubeVersion is a SemVer constraints on what version of Kubernetes is required.
 	string kubeVersion = 17;
 }

_proto/hapi/services/tiller.proto

@@ -83,6 +83,10 @@ service ReleaseService {
     // RunReleaseTest executes the tests defined of a named release
     rpc RunReleaseTest(TestReleaseRequest) returns (stream TestReleaseResponse) {
     }
+
+    // PingTiller sends a test/pingTiller signal to Tiller to ensure that it's up
+    rpc PingTiller(PingTillerRequest) returns (PingTillerResponse) {
+    }
 }
 
 // ListReleasesRequest requests a list of releases.
@@ -335,3 +339,9 @@ message TestReleaseResponse {
 	hapi.release.TestRun.Status status = 2;
 
 }
+
+message PingTillerRequest {
+}
+
+message PingTillerResponse {
+}

cmd/helm/delete.go

@@ -57,7 +57,7 @@ func newDeleteCmd(c helm.Interface, out io.Writer) *cobra.Command {
 		SuggestFor: []string{"remove", "rm"},
 		Short:      "given a release name, delete the release from Kubernetes",
 		Long:       deleteDesc,
-		PreRunE:    setupConnection,
+		PreRunE:    setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return errors.New("command 'delete' requires a release name")

cmd/helm/get.go

@@ -57,7 +57,7 @@ func newGetCmd(client helm.Interface, out io.Writer) *cobra.Command {
 		Use:     "get [flags] RELEASE_NAME",
 		Short:   "download a named release",
 		Long:    getHelp,
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return errReleaseRequired

cmd/helm/get_hooks.go

@@ -47,7 +47,7 @@ func newGetHooksCmd(client helm.Interface, out io.Writer) *cobra.Command {
 		Use:     "hooks [flags] RELEASE_NAME",
 		Short:   "download all hooks for a named release",
 		Long:    getHooksHelp,
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return errReleaseRequired

cmd/helm/get_manifest.go

@@ -49,7 +49,7 @@ func newGetManifestCmd(client helm.Interface, out io.Writer) *cobra.Command {
 		Use:     "manifest [flags] RELEASE_NAME",
 		Short:   "download the manifest for a named release",
 		Long:    getManifestHelp,
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return errReleaseRequired

cmd/helm/get_values.go

@@ -47,7 +47,7 @@ func newGetValuesCmd(client helm.Interface, out io.Writer) *cobra.Command {
 		Use:     "values [flags] RELEASE_NAME",
 		Short:   "download the values file for a named release",
 		Long:    getValuesHelp,
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return errReleaseRequired

cmd/helm/helm.go

@@ -165,14 +165,34 @@ func markDeprecated(cmd *cobra.Command, notice string) *cobra.Command {
 	return cmd
 }
 
-func setupConnection(c *cobra.Command, args []string) error {
-	if settings.TillerHost == "" {
-		config, client, err := getKubeClient(settings.KubeContext)
+func waitTillerPodAndSetupConnection(waitTimeout int) error {
+	kubeConfig, kubeClient, err := getKubeClient(settings.KubeContext)
+	if err != nil {
+		return err
+	}
+
+	if portforwarder.WaitTillerPod(kubeClient.CoreV1(), settings.TillerNamespace, waitTimeout) {
+		if err = setupConnection(kubeClient, kubeConfig); err != nil {
+			return err
+		}
+	} else {
+		return fmt.Errorf("tiller pod not found, polling deadline exceeded")
+	}
+
+	return nil
+}
+
+func setupConnectionCobraPreRunHook(_ *cobra.Command, _ []string) error {
+	kubeConfig, kubeClient, err := getKubeClient(settings.KubeContext)
 	if err != nil {
 		return err
 	}
+	return setupConnection(kubeClient, kubeConfig)
+}
 
-		tunnel, err := portforwarder.New(settings.TillerNamespace, client, config)
+func setupConnection(kubeClient kubernetes.Interface, kubeConfig *rest.Config) error {
+	if settings.TillerHost == "" {
+		tunnel, err := portforwarder.New(settings.TillerNamespace, kubeClient, kubeConfig)
 		if err != nil {
 			return err
 		}
@@ -181,7 +201,7 @@ func setupConnection(c *cobra.Command, args []string) error {
 		debug("Created tunnel using local port: '%d'\n", tunnel.Local)
 	}
 
-	// Set up the gRPC config.
+	// Set up the gRPC kubeConfig.
 	debug("SERVER: %q\n", settings.TillerHost)
 
 	// Plugin support.

cmd/helm/history.go

@@ -61,7 +61,7 @@ func newHistoryCmd(c helm.Interface, w io.Writer) *cobra.Command {
 		Long:    historyHelp,
 		Short:   "fetch release history",
 		Aliases: []string{"hist"},
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			switch {
 			case len(args) == 0:

cmd/helm/init.go

@@ -31,7 +31,6 @@ import (
 	"k8s.io/apimachinery/pkg/util/yaml"
 	"k8s.io/helm/cmd/helm/installer"
 	"k8s.io/helm/pkg/getter"
-	"k8s.io/helm/pkg/helm"
 	"k8s.io/helm/pkg/helm/helmpath"
 	"k8s.io/helm/pkg/repo"
 )
@@ -80,7 +79,6 @@ type initCmd struct {
 	forceUpgrade   bool
 	skipRefresh    bool
 	out            io.Writer
-	client         helm.Interface
 	home           helmpath.Home
 	opts           installer.Options
 	kubeClient     kubernetes.Interface
@@ -88,6 +86,7 @@ type initCmd struct {
 	maxHistory     int
 	replicas       int
 	wait           bool
+	waitTimeout    int
 }
 
 func newInitCmd(out io.Writer) *cobra.Command {
@@ -103,7 +102,6 @@ func newInitCmd(out io.Writer) *cobra.Command {
 			}
 			i.namespace = settings.TillerNamespace
 			i.home = settings.Home
-			i.client = ensureHelmClient(i.client)
 
 			return i.run()
 		},
@@ -118,6 +116,7 @@ func newInitCmd(out io.Writer) *cobra.Command {
 	f.BoolVar(&i.dryRun, "dry-run", false, "do not install local or remote")
 	f.BoolVar(&i.skipRefresh, "skip-refresh", false, "do not refresh (download) the local repository cache")
 	f.BoolVar(&i.wait, "wait", false, "block until Tiller is running and ready to receive requests")
+	f.IntVar(&i.waitTimeout, "wait-timeout", 300, "time in seconds to wait for tiller pod readiness")
 
 	f.BoolVar(&tlsEnable, "tiller-tls", false, "install Tiller with TLS enabled")
 	f.BoolVar(&tlsVerify, "tiller-tls-verify", false, "install Tiller with TLS enabled and to verify remote certificates")
@@ -301,7 +300,7 @@ func (i *initCmd) run() error {
 				if err := installer.Upgrade(i.kubeClient, &i.opts); err != nil {
 					return fmt.Errorf("error when upgrading: %s", err)
 				}
-				if err := i.ping(); err != nil {
+				if err := i.ensureTillerReady(); err != nil {
 					return err
 				}
 				fmt.Fprintln(i.out, "\nTiller (the Helm server-side component) has been upgraded to the current version.")
@@ -310,7 +309,7 @@ func (i *initCmd) run() error {
 					"(Use --client-only to suppress this message, or --upgrade to upgrade Tiller to the current version.)")
 			}
 		} else {
-			if err := i.ping(); err != nil {
+			if err := i.ensureTillerReady(); err != nil {
 				return err
 			}
 			fmt.Fprintln(i.out, "\nTiller (the Helm server-side component) has been installed into your Kubernetes Cluster.\n\n"+
@@ -325,9 +324,14 @@ func (i *initCmd) run() error {
 	return nil
 }
 
-func (i *initCmd) ping() error {
+func (i *initCmd) ensureTillerReady() error {
 	if i.wait {
-		if err := i.client.PingTiller(); err != nil {
+		if err := waitTillerPodAndSetupConnection(i.waitTimeout); err != nil {
+			return err
+		}
+
+		client := newClient()
+		if err := client.PingTiller(); err != nil {
 			return fmt.Errorf("could not ping Tiller: %s", err)
 		}
 	}

cmd/helm/install.go

@@ -153,7 +153,7 @@ func newInstallCmd(c helm.Interface, out io.Writer) *cobra.Command {
 		Use:     "install [CHART]",
 		Short:   "install a chart archive",
 		Long:    installDesc,
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if err := checkArgsLength(len(args), "chart name"); err != nil {
 				return err

cmd/helm/list.go

@@ -88,7 +88,7 @@ func newListCmd(client helm.Interface, out io.Writer) *cobra.Command {
 		Short:   "list releases",
 		Long:    listHelp,
 		Aliases: []string{"ls"},
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) > 0 {
 				list.filter = strings.Join(args, " ")

cmd/helm/load_plugins.go

@@ -103,7 +103,7 @@ func loadPlugins(baseCmd *cobra.Command, out io.Writer) {
 				if _, err := processParent(cmd, args); err != nil {
 					return err
 				}
-				return setupConnection(cmd, args)
+				return setupConnectionCobraPreRunHook(cmd, args)
 			}
 		}
 

cmd/helm/release_testing.go

@@ -51,7 +51,7 @@ func newReleaseTestCmd(c helm.Interface, out io.Writer) *cobra.Command {
 		Use:     "test [RELEASE]",
 		Short:   "test a release",
 		Long:    releaseTestDesc,
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if err := checkArgsLength(len(args), "release name"); err != nil {
 				return err

cmd/helm/reset.go

@@ -58,7 +58,7 @@ func newResetCmd(client helm.Interface, out io.Writer) *cobra.Command {
 		Short: "uninstalls Tiller from a cluster",
 		Long:  resetDesc,
 		PreRunE: func(cmd *cobra.Command, args []string) error {
-			if err := setupConnection(cmd, args); !d.force && err != nil {
+			if err := setupConnectionCobraPreRunHook(cmd, args); !d.force && err != nil {
 				return err
 			}
 			return nil

cmd/helm/rollback.go

@@ -57,7 +57,7 @@ func newRollbackCmd(c helm.Interface, out io.Writer) *cobra.Command {
 		Use:     "rollback [flags] [RELEASE] [REVISION]",
 		Short:   "roll back a release to a previous revision",
 		Long:    rollbackDesc,
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if err := checkArgsLength(len(args), "release name", "revision number"); err != nil {
 				return err

cmd/helm/status.go

@@ -63,7 +63,7 @@ func newStatusCmd(client helm.Interface, out io.Writer) *cobra.Command {
 		Use:     "status [flags] RELEASE_NAME",
 		Short:   "displays the status of the named release",
 		Long:    statusHelp,
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return errReleaseRequired

cmd/helm/upgrade.go

@@ -91,7 +91,7 @@ func newUpgradeCmd(client helm.Interface, out io.Writer) *cobra.Command {
 		Use:     "upgrade [RELEASE] [CHART]",
 		Short:   "upgrade a release",
 		Long:    upgradeDesc,
-		PreRunE: setupConnection,
+		PreRunE: setupConnectionCobraPreRunHook,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if err := checkArgsLength(len(args), "release name", "chart path"); err != nil {
 				return err

cmd/helm/version.go

@@ -76,7 +76,7 @@ func newVersionCmd(c helm.Interface, out io.Writer) *cobra.Command {
 			if version.showServer {
 				// We do this manually instead of in PreRun because we only
 				// need a tunnel if server version is requested.
-				setupConnection(cmd, args)
+				setupConnectionCobraPreRunHook(cmd, args)
 			}
 			version.client = ensureHelmClient(version.client)
 			return version.run()

docs/helm/helm_init.md

@@ -55,6 +55,7 @@ helm init
       --tls-ca-cert string       path to CA root certificate
       --upgrade                  upgrade if Tiller is already installed
       --wait                     block until Tiller is running and ready to receive requests
+      --wait-timeout int         time in seconds to wait for tiller pod readiness (default 300)
 ```
 
 ### Options inherited from parent commands

glide.lock

@@ -1,5 +1,5 @@
-hash: c4a1f6e380baf38d371d428fa5c8f7b2363663d811c728e982300692287a58e4
-updated: 2018-02-02T20:15:49.706602Z
+hash: 25363f0ffcd3b6cb1a290ea1622dc6c9d3dff200e37445504e9aaed61c8a6df1
+updated: 2018-02-14T15:00:51.765139371+03:00
 imports:
 - name: cloud.google.com/go
   version: 3b1ae45394a234c385be014e9a488f2bb6eef821
@@ -168,7 +168,7 @@ imports:
   subpackages:
   - lru
 - name: github.com/golang/protobuf
-  version: 4bd1920723d7b7c925de087aa32e2187708897f7
+  version: 47eb67eaf5cab63c58956d4d4ce86b03ad5eaa03
   subpackages:
   - proto
   - ptypes

glide.yaml

@@ -19,7 +19,7 @@ import:
   version: ~1.3.1
 - package: github.com/technosophos/moniker
 - package: github.com/golang/protobuf
-  version: 4bd1920723d7b7c925de087aa32e2187708897f7
+  version: 47eb67eaf5cab63c58956d4d4ce86b03ad5eaa03
   subpackages:
   - proto
   - ptypes/any

pkg/helm/client.go

@@ -300,7 +300,7 @@ func (h *Client) RunReleaseTest(rlsName string, opts ...ReleaseTestOption) (<-ch
 // PingTiller pings the Tiller pod and ensure's that it is up and running
 func (h *Client) PingTiller() error {
 	ctx := NewContext()
-	return h.ping(ctx)
+	return h.pingTiller(ctx)
 }
 
 // connect returns a gRPC connection to Tiller or error. The gRPC dial options
@@ -480,8 +480,8 @@ func (h *Client) test(ctx context.Context, req *rls.TestReleaseRequest) (<-chan
 	return ch, errc
 }
 
-// Executes tiller.Ping RPC.
-func (h *Client) ping(ctx context.Context) error {
+// Executes tiller.PingTiller RPC.
+func (h *Client) pingTiller(ctx context.Context) error {
 	c, err := h.connect(ctx)
 	if err != nil {
 		return err
@@ -489,5 +489,7 @@ func (h *Client) ping(ctx context.Context) error {
 	defer c.Close()
 
 	rlc := rls.NewReleaseServiceClient(c)
-	return rlc.PingTiller(ctx)
+	_, err = rlc.PingTiller(ctx, &rls.PingTillerRequest{})
+
+	return err
 }

pkg/helm/portforwarder/portforwarder.go

@@ -27,6 +27,7 @@ import (
 	"k8s.io/client-go/rest"
 
 	"k8s.io/helm/pkg/kube"
+	"time"
 )
 
 var (
@@ -53,6 +54,38 @@ func getTillerPodName(client corev1.PodsGetter, namespace string) (string, error
 	return pod.ObjectMeta.GetName(), nil
 }
 
+func WaitTillerPod(client corev1.PodsGetter, namespace string, waitTimeout int) bool {
+	deadlinePollingChan := time.NewTimer(time.Duration(waitTimeout) * time.Second).C
+	checkTillerPodTicker := time.NewTicker(500 * time.Millisecond)
+	doneChan := make(chan bool)
+
+	go func() {
+		for range checkTillerPodTicker.C {
+			_, err := getTillerPodName(client, namespace)
+			if err == nil {
+				doneChan <- true
+				break
+			}
+		}
+	}()
+
+	podExists := false
+loop:
+	for {
+		select {
+		case <-deadlinePollingChan:
+			break loop
+		case <-doneChan:
+			podExists = true
+			break loop
+		}
+	}
+
+	checkTillerPodTicker.Stop()
+
+	return podExists
+}
+
 func getFirstRunningPod(client corev1.PodsGetter, namespace string, selector labels.Selector) (*v1.Pod, error) {
 	options := metav1.ListOptions{LabelSelector: selector.String()}
 	pods, err := client.Pods(namespace).List(options)

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

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

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

@@ -6,9 +6,19 @@ Package release is a generated protocol buffer package.
 
 It is generated from these files:
 	hapi/release/hook.proto
+	hapi/release/info.proto
+	hapi/release/release.proto
+	hapi/release/status.proto
+	hapi/release/test_run.proto
+	hapi/release/test_suite.proto
 
 It has these top-level messages:
 	Hook
+	Info
+	Release
+	Status
+	TestRun
+	TestSuite
 */
 package release
 

pkg/proto/hapi/services/tiller.pb.go

@@ -29,6 +29,8 @@ It has these top-level messages:
 	GetHistoryResponse
 	TestReleaseRequest
 	TestReleaseResponse
+	PingTillerRequest
+	PingTillerResponse
 */
 package services
 
@@ -889,6 +891,22 @@ func (m *TestReleaseResponse) GetStatus() hapi_release1.TestRun_Status {
 	return hapi_release1.TestRun_UNKNOWN
 }
 
+type PingTillerRequest struct {
+}
+
+func (m *PingTillerRequest) Reset()                    { *m = PingTillerRequest{} }
+func (m *PingTillerRequest) String() string            { return proto.CompactTextString(m) }
+func (*PingTillerRequest) ProtoMessage()               {}
+func (*PingTillerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
+
+type PingTillerResponse struct {
+}
+
+func (m *PingTillerResponse) Reset()                    { *m = PingTillerResponse{} }
+func (m *PingTillerResponse) String() string            { return proto.CompactTextString(m) }
+func (*PingTillerResponse) ProtoMessage()               {}
+func (*PingTillerResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
+
 func init() {
 	proto.RegisterType((*ListReleasesRequest)(nil), "hapi.services.tiller.ListReleasesRequest")
 	proto.RegisterType((*ListSort)(nil), "hapi.services.tiller.ListSort")
@@ -911,6 +929,8 @@ func init() {
 	proto.RegisterType((*GetHistoryResponse)(nil), "hapi.services.tiller.GetHistoryResponse")
 	proto.RegisterType((*TestReleaseRequest)(nil), "hapi.services.tiller.TestReleaseRequest")
 	proto.RegisterType((*TestReleaseResponse)(nil), "hapi.services.tiller.TestReleaseResponse")
+	proto.RegisterType((*PingTillerRequest)(nil), "hapi.services.tiller.PingTillerRequest")
+	proto.RegisterType((*PingTillerResponse)(nil), "hapi.services.tiller.PingTillerResponse")
 	proto.RegisterEnum("hapi.services.tiller.ListSort_SortBy", ListSort_SortBy_name, ListSort_SortBy_value)
 	proto.RegisterEnum("hapi.services.tiller.ListSort_SortOrder", ListSort_SortOrder_name, ListSort_SortOrder_value)
 }
@@ -949,8 +969,8 @@ type ReleaseServiceClient interface {
 	GetHistory(ctx context.Context, in *GetHistoryRequest, opts ...grpc.CallOption) (*GetHistoryResponse, error)
 	// RunReleaseTest executes the tests defined of a named release
 	RunReleaseTest(ctx context.Context, in *TestReleaseRequest, opts ...grpc.CallOption) (ReleaseService_RunReleaseTestClient, error)
-	// PingTiller sends a test/ping signal to Tiller to ensure that it's up
-	PingTiller(ctx context.Context) error
+	// PingTiller sends a test/pingTiller signal to Tiller to ensure that it's up
+	PingTiller(ctx context.Context, in *PingTillerRequest, opts ...grpc.CallOption) (*PingTillerResponse, error)
 }
 
 type releaseServiceClient struct {
@@ -1080,14 +1100,6 @@ func (c *releaseServiceClient) RunReleaseTest(ctx context.Context, in *TestRelea
 	return x, nil
 }
 
-func (c *releaseServiceClient) PingTiller(ctx context.Context) error {
-	err := grpc.Invoke(ctx, "/hapi.services.tiller.ReleaseService/PingTiller", "Ping", nil, c.cc, grpc.FailFast(false))
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
 type ReleaseService_RunReleaseTestClient interface {
 	Recv() (*TestReleaseResponse, error)
 	grpc.ClientStream
@@ -1105,6 +1117,15 @@ func (x *releaseServiceRunReleaseTestClient) Recv() (*TestReleaseResponse, error
 	return m, nil
 }
 
+func (c *releaseServiceClient) PingTiller(ctx context.Context, in *PingTillerRequest, opts ...grpc.CallOption) (*PingTillerResponse, error) {
+	out := new(PingTillerResponse)
+	err := grpc.Invoke(ctx, "/hapi.services.tiller.ReleaseService/PingTiller", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for ReleaseService service
 
 type ReleaseServiceServer interface {
@@ -1131,6 +1152,8 @@ type ReleaseServiceServer interface {
 	GetHistory(context.Context, *GetHistoryRequest) (*GetHistoryResponse, error)
 	// RunReleaseTest executes the tests defined of a named release
 	RunReleaseTest(*TestReleaseRequest, ReleaseService_RunReleaseTestServer) error
+	// PingTiller sends a test/pingTiller signal to Tiller to ensure that it's up
+	PingTiller(context.Context, *PingTillerRequest) (*PingTillerResponse, error)
 }
 
 func RegisterReleaseServiceServer(s *grpc.Server, srv ReleaseServiceServer) {
@@ -1310,10 +1333,6 @@ func _ReleaseService_RunReleaseTest_Handler(srv interface{}, stream grpc.ServerS
 	return srv.(ReleaseServiceServer).RunReleaseTest(m, &releaseServiceRunReleaseTestServer{stream})
 }
 
-func _ReleaseService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	return "Pong", nil
-}
-
 type ReleaseService_RunReleaseTestServer interface {
 	Send(*TestReleaseResponse) error
 	grpc.ServerStream
@@ -1327,6 +1346,24 @@ func (x *releaseServiceRunReleaseTestServer) Send(m *TestReleaseResponse) error
 	return x.ServerStream.SendMsg(m)
 }
 
+func _ReleaseService_PingTiller_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PingTillerRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ReleaseServiceServer).PingTiller(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/hapi.services.tiller.ReleaseService/PingTiller",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ReleaseServiceServer).PingTiller(ctx, req.(*PingTillerRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _ReleaseService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "hapi.services.tiller.ReleaseService",
 	HandlerType: (*ReleaseServiceServer)(nil),
@@ -1365,7 +1402,7 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{
 		},
 		{
 			MethodName: "PingTiller",
-			Handler:    _ReleaseService_Ping_Handler,
+			Handler:    _ReleaseService_PingTiller_Handler,
 		},
 	},
 	Streams: []grpc.StreamDesc{
@@ -1386,82 +1423,83 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("hapi/services/tiller.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 1217 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xdd, 0x6e, 0xe3, 0xc4,
-	0x17, 0xaf, 0xf3, 0x9d, 0x93, 0x36, 0xff, 0x74, 0x9a, 0xb6, 0xae, 0xff, 0x0b, 0x2a, 0x46, 0xb0,
-	0xd9, 0x85, 0x4d, 0x21, 0x70, 0x83, 0x84, 0x90, 0xba, 0xdd, 0xa8, 0x2d, 0x94, 0xae, 0xe4, 0x6c,
-	0x17, 0x09, 0x01, 0x91, 0x9b, 0x4c, 0x5a, 0xb3, 0x8e, 0x27, 0x78, 0xc6, 0x65, 0x7b, 0xcb, 0x1d,
-	0x8f, 0xc2, 0x5b, 0xf0, 0x1e, 0x5c, 0xc2, 0x83, 0x20, 0xcf, 0x87, 0xeb, 0x49, 0xed, 0xd6, 0xf4,
-	0x26, 0x9e, 0x99, 0xf3, 0xfd, 0x3b, 0x67, 0xce, 0x9c, 0x80, 0x75, 0xe9, 0x2e, 0xbc, 0x3d, 0x8a,
-	0xc3, 0x2b, 0x6f, 0x82, 0xe9, 0x1e, 0xf3, 0x7c, 0x1f, 0x87, 0xfd, 0x45, 0x48, 0x18, 0x41, 0xdd,
-	0x98, 0xd6, 0x57, 0xb4, 0xbe, 0xa0, 0x59, 0x5b, 0x5c, 0x62, 0x72, 0xe9, 0x86, 0x4c, 0xfc, 0x0a,
-	0x6e, 0x6b, 0x3b, 0x7d, 0x4e, 0x82, 0x99, 0x77, 0x21, 0x09, 0xc2, 0x44, 0x88, 0x7d, 0xec, 0x52,
-	0xac, 0xbe, 0x9a, 0x90, 0xa2, 0x79, 0xc1, 0x8c, 0x48, 0xc2, 0xff, 0x35, 0x02, 0xc3, 0x94, 0x8d,
-	0xc3, 0x28, 0x90, 0xc4, 0x1d, 0x8d, 0x48, 0x99, 0xcb, 0x22, 0xaa, 0x19, 0xbb, 0xc2, 0x21, 0xf5,
-	0x48, 0xa0, 0xbe, 0x82, 0x66, 0xff, 0x59, 0x82, 0x8d, 0x13, 0x8f, 0x32, 0x47, 0x08, 0x52, 0x07,
-	0xff, 0x12, 0x61, 0xca, 0x50, 0x17, 0xaa, 0xbe, 0x37, 0xf7, 0x98, 0x69, 0xec, 0x1a, 0xbd, 0xb2,
-	0x23, 0x36, 0x68, 0x0b, 0x6a, 0x64, 0x36, 0xa3, 0x98, 0x99, 0xa5, 0x5d, 0xa3, 0xd7, 0x74, 0xe4,
-	0x0e, 0x7d, 0x05, 0x75, 0x4a, 0x42, 0x36, 0x3e, 0xbf, 0x36, 0xcb, 0xbb, 0x46, 0xaf, 0x3d, 0xf8,
-	0xa0, 0x9f, 0x85, 0x53, 0x3f, 0xb6, 0x34, 0x22, 0x21, 0xeb, 0xc7, 0x3f, 0xcf, 0xaf, 0x9d, 0x1a,
-	0xe5, 0xdf, 0x58, 0xef, 0xcc, 0xf3, 0x19, 0x0e, 0xcd, 0x8a, 0xd0, 0x2b, 0x76, 0xe8, 0x10, 0x80,
-	0xeb, 0x25, 0xe1, 0x14, 0x87, 0x66, 0x95, 0xab, 0xee, 0x15, 0x50, 0xfd, 0x32, 0xe6, 0x77, 0x9a,
-	0x54, 0x2d, 0xd1, 0x97, 0xb0, 0x2a, 0x20, 0x19, 0x4f, 0xc8, 0x14, 0x53, 0xb3, 0xb6, 0x5b, 0xee,
-	0xb5, 0x07, 0x3b, 0x42, 0x95, 0x82, 0x7f, 0x24, 0x40, 0x3b, 0x20, 0x53, 0xec, 0xb4, 0x04, 0x7b,
-	0xbc, 0xa6, 0xe8, 0x11, 0x34, 0x03, 0x77, 0x8e, 0xe9, 0xc2, 0x9d, 0x60, 0xb3, 0xce, 0x3d, 0xbc,
-	0x39, 0xb0, 0x7f, 0x82, 0x86, 0x32, 0x6e, 0x0f, 0xa0, 0x26, 0x42, 0x43, 0x2d, 0xa8, 0x9f, 0x9d,
-	0x7e, 0x73, 0xfa, 0xf2, 0xbb, 0xd3, 0xce, 0x0a, 0x6a, 0x40, 0xe5, 0x74, 0xff, 0xdb, 0x61, 0xc7,
-	0x40, 0xeb, 0xb0, 0x76, 0xb2, 0x3f, 0x7a, 0x35, 0x76, 0x86, 0x27, 0xc3, 0xfd, 0xd1, 0xf0, 0x45,
-	0xa7, 0x64, 0xbf, 0x0b, 0xcd, 0xc4, 0x67, 0x54, 0x87, 0xf2, 0xfe, 0xe8, 0x40, 0x88, 0xbc, 0x18,
-	0x8e, 0x0e, 0x3a, 0x86, 0xfd, 0xbb, 0x01, 0x5d, 0x3d, 0x45, 0x74, 0x41, 0x02, 0x8a, 0xe3, 0x1c,
-	0x4d, 0x48, 0x14, 0x24, 0x39, 0xe2, 0x1b, 0x84, 0xa0, 0x12, 0xe0, 0xb7, 0x2a, 0x43, 0x7c, 0x1d,
-	0x73, 0x32, 0xc2, 0x5c, 0x9f, 0x67, 0xa7, 0xec, 0x88, 0x0d, 0xfa, 0x14, 0x1a, 0x32, 0x74, 0x6a,
-	0x56, 0x76, 0xcb, 0xbd, 0xd6, 0x60, 0x53, 0x07, 0x44, 0x5a, 0x74, 0x12, 0x36, 0xfb, 0x10, 0xb6,
-	0x0f, 0xb1, 0xf2, 0x44, 0xe0, 0xa5, 0x2a, 0x26, 0xb6, 0xeb, 0xce, 0x31, 0x77, 0x26, 0xb6, 0xeb,
-	0xce, 0x31, 0x32, 0xa1, 0x2e, 0xcb, 0x8d, 0xbb, 0x53, 0x75, 0xd4, 0xd6, 0x66, 0x60, 0xde, 0x56,
-	0x24, 0xe3, 0xca, 0xd2, 0xf4, 0x21, 0x54, 0xe2, 0x9b, 0xc0, 0xd5, 0xb4, 0x06, 0x48, 0xf7, 0xf3,
-	0x38, 0x98, 0x11, 0x87, 0xd3, 0xf5, 0x54, 0x95, 0x97, 0x53, 0x75, 0x94, 0xb6, 0x7a, 0x40, 0x02,
-	0x86, 0x03, 0xf6, 0x30, 0xff, 0x4f, 0x60, 0x27, 0x43, 0x93, 0x0c, 0x60, 0x0f, 0xea, 0xd2, 0x35,
-	0xae, 0x2d, 0x17, 0x57, 0xc5, 0x65, 0xff, 0x5d, 0x82, 0xee, 0xd9, 0x62, 0xea, 0x32, 0xac, 0x48,
-	0x77, 0x38, 0xf5, 0x18, 0xaa, 0xbc, 0xa3, 0x48, 0x2c, 0xd6, 0x85, 0x6e, 0xd1, 0x76, 0x0e, 0xe2,
-	0x5f, 0x47, 0xd0, 0xd1, 0x53, 0xa8, 0x5d, 0xb9, 0x7e, 0x84, 0x29, 0x07, 0x22, 0x41, 0x4d, 0x72,
-	0xf2, 0x76, 0xe4, 0x48, 0x0e, 0xb4, 0x0d, 0xf5, 0x69, 0x78, 0x1d, 0xf7, 0x13, 0x7e, 0x05, 0x1b,
-	0x4e, 0x6d, 0x1a, 0x5e, 0x3b, 0x51, 0x80, 0xde, 0x87, 0xb5, 0xa9, 0x47, 0xdd, 0x73, 0x1f, 0x8f,
-	0x2f, 0x09, 0x79, 0x43, 0xf9, 0x2d, 0x6c, 0x38, 0xab, 0xf2, 0xf0, 0x28, 0x3e, 0x43, 0x56, 0x5c,
-	0x49, 0x93, 0x10, 0xbb, 0x0c, 0x9b, 0x35, 0x4e, 0x4f, 0xf6, 0x31, 0x86, 0xcc, 0x9b, 0x63, 0x12,
-	0x31, 0x7e, 0x75, 0xca, 0x8e, 0xda, 0xa2, 0xf7, 0x60, 0x35, 0xc4, 0x14, 0xb3, 0xb1, 0xf4, 0xb2,
-	0xc1, 0x25, 0x5b, 0xfc, 0xec, 0xb5, 0x70, 0x0b, 0x41, 0xe5, 0x57, 0xd7, 0x63, 0x66, 0x93, 0x93,
-	0xf8, 0x5a, 0x88, 0x45, 0x14, 0x2b, 0x31, 0x50, 0x62, 0x11, 0xc5, 0x52, 0xac, 0x0b, 0xd5, 0x19,
-	0x09, 0x27, 0xd8, 0x6c, 0x71, 0x9a, 0xd8, 0xd8, 0x47, 0xb0, 0xb9, 0x04, 0xf2, 0x43, 0xf3, 0xf5,
-	0x8f, 0x01, 0x5b, 0x0e, 0xf1, 0xfd, 0x73, 0x77, 0xf2, 0xa6, 0x40, 0xc6, 0x52, 0xe0, 0x96, 0xee,
-	0x06, 0xb7, 0x9c, 0x01, 0x6e, 0xaa, 0x08, 0x2b, 0x5a, 0x11, 0x6a, 0xb0, 0x57, 0xf3, 0x61, 0xaf,
-	0xe9, 0xb0, 0x2b, 0x4c, 0xeb, 0x29, 0x4c, 0x13, 0xc0, 0x1a, 0x69, 0xc0, 0xbe, 0x86, 0xed, 0x5b,
-	0x51, 0x3e, 0x14, 0xb2, 0x3f, 0x4a, 0xb0, 0x79, 0x1c, 0x50, 0xe6, 0xfa, 0xfe, 0x12, 0x62, 0x49,
-	0x3d, 0x1b, 0x85, 0xeb, 0xb9, 0xf4, 0x5f, 0xea, 0xb9, 0xac, 0x41, 0xae, 0xf2, 0x53, 0x49, 0xe5,
-	0xa7, 0x50, 0x8d, 0x6b, 0x9d, 0xa5, 0xb6, 0xd4, 0x59, 0xd0, 0x3b, 0x00, 0xa2, 0x28, 0xb9, 0x72,
-	0x01, 0x6d, 0x93, 0x9f, 0x9c, 0xca, 0x46, 0xa2, 0xb2, 0xd1, 0xc8, 0xce, 0x46, 0xaa, 0xc2, 0xed,
-	0x63, 0xd8, 0x5a, 0x86, 0xea, 0xa1, 0xb0, 0xff, 0x66, 0xc0, 0xf6, 0x59, 0xe0, 0x65, 0x02, 0x9f,
-	0x55, 0xaa, 0xb7, 0xa0, 0x28, 0x65, 0x40, 0xd1, 0x85, 0xea, 0x22, 0x0a, 0x2f, 0xb0, 0x84, 0x56,
-	0x6c, 0xd2, 0x31, 0x56, 0xb4, 0x18, 0xed, 0x31, 0x98, 0xb7, 0x7d, 0x78, 0x60, 0x44, 0xb1, 0xd7,
-	0xc9, 0x4b, 0xd0, 0x14, 0x5d, 0xdf, 0xde, 0x80, 0xf5, 0x43, 0xcc, 0x5e, 0x8b, 0x6b, 0x21, 0xc3,
-	0xb3, 0x87, 0x80, 0xd2, 0x87, 0x37, 0xf6, 0xe4, 0x91, 0x6e, 0x4f, 0x8d, 0x45, 0x8a, 0x5f, 0x71,
-	0xd9, 0x5f, 0x70, 0xdd, 0x47, 0x1e, 0x65, 0x24, 0xbc, 0xbe, 0x0b, 0xba, 0x0e, 0x94, 0xe7, 0xee,
-	0x5b, 0xf9, 0x50, 0xc4, 0x4b, 0xfb, 0x90, 0x7b, 0x90, 0x88, 0x4a, 0x0f, 0xd2, 0xcf, 0xae, 0x51,
-	0xec, 0xd9, 0xfd, 0x01, 0xd0, 0x2b, 0x9c, 0x4c, 0x00, 0xf7, 0xbc, 0x58, 0x2a, 0x09, 0x25, 0xbd,
-	0xd0, 0x4c, 0xa8, 0x4f, 0x7c, 0xec, 0x06, 0xd1, 0x42, 0xa6, 0x4d, 0x6d, 0xed, 0x1f, 0x61, 0x43,
-	0xd3, 0x2e, 0xfd, 0x8c, 0xe3, 0xa1, 0x17, 0x52, 0x7b, 0xbc, 0x44, 0x9f, 0x43, 0x4d, 0x8c, 0x45,
-	0x5c, 0x77, 0x7b, 0xf0, 0x48, 0xf7, 0x9b, 0x2b, 0x89, 0x02, 0x39, 0x47, 0x39, 0x92, 0x77, 0xf0,
-	0x57, 0x03, 0xda, 0xea, 0xa1, 0x17, 0x43, 0x1b, 0xf2, 0x60, 0x35, 0x3d, 0xd1, 0xa0, 0x27, 0xf9,
-	0x33, 0xdd, 0xd2, 0x60, 0x6a, 0x3d, 0x2d, 0xc2, 0x2a, 0x22, 0xb0, 0x57, 0x3e, 0x31, 0x10, 0x85,
-	0xce, 0xf2, 0xa0, 0x81, 0x9e, 0x65, 0xeb, 0xc8, 0x99, 0x6c, 0xac, 0x7e, 0x51, 0x76, 0x65, 0x16,
-	0x5d, 0xf1, 0x9a, 0xd1, 0xa7, 0x03, 0x74, 0xaf, 0x1a, 0x7d, 0x20, 0xb1, 0xf6, 0x0a, 0xf3, 0x27,
-	0x76, 0x7f, 0x86, 0x35, 0xed, 0x85, 0x43, 0x39, 0x68, 0x65, 0xcd, 0x1a, 0xd6, 0x47, 0x85, 0x78,
-	0x13, 0x5b, 0x73, 0x68, 0xeb, 0x4d, 0x0a, 0xe5, 0x28, 0xc8, 0xec, 0xfa, 0xd6, 0xc7, 0xc5, 0x98,
-	0x13, 0x73, 0x14, 0x3a, 0xcb, 0x3d, 0x24, 0x2f, 0x8f, 0x39, 0xfd, 0x2e, 0x2f, 0x8f, 0x79, 0xad,
-	0xc9, 0x5e, 0x41, 0x2e, 0xc0, 0x4d, 0x0b, 0x41, 0x8f, 0x73, 0x13, 0xa2, 0x77, 0x1e, 0xab, 0x77,
-	0x3f, 0x63, 0x62, 0x62, 0x01, 0xff, 0x5b, 0x7a, 0x63, 0x51, 0x0e, 0x34, 0xd9, 0x03, 0x87, 0xf5,
-	0xac, 0x20, 0xf7, 0x52, 0x50, 0xb2, 0x2b, 0xdd, 0x11, 0x94, 0xde, 0xf2, 0xee, 0x08, 0x6a, 0xa9,
-	0xc1, 0xd9, 0x2b, 0xc8, 0x83, 0xb6, 0x13, 0x05, 0xd2, 0x74, 0xdc, 0x16, 0x50, 0x8e, 0xf4, 0xed,
-	0xae, 0x66, 0x3d, 0x29, 0xc0, 0x79, 0x73, 0xbf, 0x9f, 0xc3, 0xf7, 0x0d, 0xc5, 0x7a, 0x5e, 0xe3,
-	0xff, 0x69, 0x3f, 0xfb, 0x37, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x7c, 0x9c, 0x49, 0xc1, 0x0f, 0x00,
-	0x00,
+	// 1248 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xdd, 0x6e, 0xe3, 0x44,
+	0x14, 0xae, 0xf3, 0x9f, 0x93, 0x36, 0xa4, 0xd3, 0xb4, 0x75, 0xcd, 0x82, 0x8a, 0x11, 0x6c, 0x76,
+	0x61, 0x53, 0x08, 0xdc, 0x20, 0x21, 0xa4, 0x6e, 0x37, 0x6a, 0x0b, 0xa5, 0x8b, 0x9c, 0x76, 0x91,
+	0x10, 0x10, 0xb9, 0xc9, 0xa4, 0x35, 0xeb, 0xd8, 0xc1, 0x33, 0x2e, 0xdb, 0x5b, 0xee, 0x78, 0x14,
+	0x5e, 0x02, 0xf1, 0x2e, 0xf0, 0x20, 0xc8, 0xf3, 0xe3, 0x7a, 0x1c, 0xbb, 0x35, 0xbd, 0x89, 0x67,
+	0xe6, 0xfc, 0x7f, 0xe7, 0xcc, 0x99, 0x13, 0x30, 0xae, 0xec, 0x85, 0xb3, 0x47, 0x70, 0x70, 0xed,
+	0x4c, 0x30, 0xd9, 0xa3, 0x8e, 0xeb, 0xe2, 0xa0, 0xbf, 0x08, 0x7c, 0xea, 0xa3, 0x6e, 0x44, 0xeb,
+	0x4b, 0x5a, 0x9f, 0xd3, 0x8c, 0x2d, 0x26, 0x31, 0xb9, 0xb2, 0x03, 0xca, 0x7f, 0x39, 0xb7, 0xb1,
+	0x9d, 0x3c, 0xf7, 0xbd, 0x99, 0x73, 0x29, 0x08, 0xdc, 0x44, 0x80, 0x5d, 0x6c, 0x13, 0x2c, 0xbf,
+	0x8a, 0x90, 0xa4, 0x39, 0xde, 0xcc, 0x17, 0x84, 0xb7, 0x15, 0x02, 0xc5, 0x84, 0x8e, 0x83, 0xd0,
+	0x13, 0xc4, 0x1d, 0x85, 0x48, 0xa8, 0x4d, 0x43, 0xa2, 0x18, 0xbb, 0xc6, 0x01, 0x71, 0x7c, 0x4f,
+	0x7e, 0x39, 0xcd, 0xfc, 0xbb, 0x04, 0x1b, 0x27, 0x0e, 0xa1, 0x16, 0x17, 0x24, 0x16, 0xfe, 0x35,
+	0xc4, 0x84, 0xa2, 0x2e, 0x54, 0x5d, 0x67, 0xee, 0x50, 0x5d, 0xdb, 0xd5, 0x7a, 0x65, 0x8b, 0x6f,
+	0xd0, 0x16, 0xd4, 0xfc, 0xd9, 0x8c, 0x60, 0xaa, 0x97, 0x76, 0xb5, 0x5e, 0xd3, 0x12, 0x3b, 0xf4,
+	0x15, 0xd4, 0x89, 0x1f, 0xd0, 0xf1, 0xc5, 0x8d, 0x5e, 0xde, 0xd5, 0x7a, 0xed, 0xc1, 0x07, 0xfd,
+	0x2c, 0x9c, 0xfa, 0x91, 0xa5, 0x91, 0x1f, 0xd0, 0x7e, 0xf4, 0xf3, 0xfc, 0xc6, 0xaa, 0x11, 0xf6,
+	0x8d, 0xf4, 0xce, 0x1c, 0x97, 0xe2, 0x40, 0xaf, 0x70, 0xbd, 0x7c, 0x87, 0x0e, 0x01, 0x98, 0x5e,
+	0x3f, 0x98, 0xe2, 0x40, 0xaf, 0x32, 0xd5, 0xbd, 0x02, 0xaa, 0x5f, 0x46, 0xfc, 0x56, 0x93, 0xc8,
+	0x25, 0xfa, 0x12, 0x56, 0x39, 0x24, 0xe3, 0x89, 0x3f, 0xc5, 0x44, 0xaf, 0xed, 0x96, 0x7b, 0xed,
+	0xc1, 0x0e, 0x57, 0x25, 0xe1, 0x1f, 0x71, 0xd0, 0x0e, 0xfc, 0x29, 0xb6, 0x5a, 0x9c, 0x3d, 0x5a,
+	0x13, 0xf4, 0x08, 0x9a, 0x9e, 0x3d, 0xc7, 0x64, 0x61, 0x4f, 0xb0, 0x5e, 0x67, 0x1e, 0xde, 0x1e,
+	0x98, 0x3f, 0x43, 0x43, 0x1a, 0x37, 0x07, 0x50, 0xe3, 0xa1, 0xa1, 0x16, 0xd4, 0xcf, 0x4f, 0xbf,
+	0x39, 0x7d, 0xf9, 0xfd, 0x69, 0x67, 0x05, 0x35, 0xa0, 0x72, 0xba, 0xff, 0xed, 0xb0, 0xa3, 0xa1,
+	0x75, 0x58, 0x3b, 0xd9, 0x1f, 0x9d, 0x8d, 0xad, 0xe1, 0xc9, 0x70, 0x7f, 0x34, 0x7c, 0xd1, 0x29,
+	0x99, 0xef, 0x42, 0x33, 0xf6, 0x19, 0xd5, 0xa1, 0xbc, 0x3f, 0x3a, 0xe0, 0x22, 0x2f, 0x86, 0xa3,
+	0x83, 0x8e, 0x66, 0xfe, 0xa1, 0x41, 0x57, 0x4d, 0x11, 0x59, 0xf8, 0x1e, 0xc1, 0x51, 0x8e, 0x26,
+	0x7e, 0xe8, 0xc5, 0x39, 0x62, 0x1b, 0x84, 0xa0, 0xe2, 0xe1, 0x37, 0x32, 0x43, 0x6c, 0x1d, 0x71,
+	0x52, 0x9f, 0xda, 0x2e, 0xcb, 0x4e, 0xd9, 0xe2, 0x1b, 0xf4, 0x29, 0x34, 0x44, 0xe8, 0x44, 0xaf,
+	0xec, 0x96, 0x7b, 0xad, 0xc1, 0xa6, 0x0a, 0x88, 0xb0, 0x68, 0xc5, 0x6c, 0xe6, 0x21, 0x6c, 0x1f,
+	0x62, 0xe9, 0x09, 0xc7, 0x4b, 0x56, 0x4c, 0x64, 0xd7, 0x9e, 0x63, 0xe6, 0x4c, 0x64, 0xd7, 0x9e,
+	0x63, 0xa4, 0x43, 0x5d, 0x94, 0x1b, 0x73, 0xa7, 0x6a, 0xc9, 0xad, 0x49, 0x41, 0x5f, 0x56, 0x24,
+	0xe2, 0xca, 0xd2, 0xf4, 0x21, 0x54, 0xa2, 0x9b, 0xc0, 0xd4, 0xb4, 0x06, 0x48, 0xf5, 0xf3, 0xd8,
+	0x9b, 0xf9, 0x16, 0xa3, 0xab, 0xa9, 0x2a, 0xa7, 0x53, 0x75, 0x94, 0xb4, 0x7a, 0xe0, 0x7b, 0x14,
+	0x7b, 0xf4, 0x61, 0xfe, 0x9f, 0xc0, 0x4e, 0x86, 0x26, 0x11, 0xc0, 0x1e, 0xd4, 0x85, 0x6b, 0x4c,
+	0x5b, 0x2e, 0xae, 0x92, 0xcb, 0xfc, 0xa7, 0x04, 0xdd, 0xf3, 0xc5, 0xd4, 0xa6, 0x58, 0x92, 0xee,
+	0x70, 0xea, 0x31, 0x54, 0x59, 0x47, 0x11, 0x58, 0xac, 0x73, 0xdd, 0xbc, 0xed, 0x1c, 0x44, 0xbf,
+	0x16, 0xa7, 0xa3, 0xa7, 0x50, 0xbb, 0xb6, 0xdd, 0x10, 0x13, 0x06, 0x44, 0x8c, 0x9a, 0xe0, 0x64,
+	0xed, 0xc8, 0x12, 0x1c, 0x68, 0x1b, 0xea, 0xd3, 0xe0, 0x26, 0xea, 0x27, 0xec, 0x0a, 0x36, 0xac,
+	0xda, 0x34, 0xb8, 0xb1, 0x42, 0x0f, 0xbd, 0x0f, 0x6b, 0x53, 0x87, 0xd8, 0x17, 0x2e, 0x1e, 0x5f,
+	0xf9, 0xfe, 0x6b, 0xc2, 0x6e, 0x61, 0xc3, 0x5a, 0x15, 0x87, 0x47, 0xd1, 0x19, 0x32, 0xa2, 0x4a,
+	0x9a, 0x04, 0xd8, 0xa6, 0x58, 0xaf, 0x31, 0x7a, 0xbc, 0x8f, 0x30, 0xa4, 0xce, 0x1c, 0xfb, 0x21,
+	0x65, 0x57, 0xa7, 0x6c, 0xc9, 0x2d, 0x7a, 0x0f, 0x56, 0x03, 0x4c, 0x30, 0x1d, 0x0b, 0x2f, 0x1b,
+	0x4c, 0xb2, 0xc5, 0xce, 0x5e, 0x71, 0xb7, 0x10, 0x54, 0x7e, 0xb3, 0x1d, 0xaa, 0x37, 0x19, 0x89,
+	0xad, 0xb9, 0x58, 0x48, 0xb0, 0x14, 0x03, 0x29, 0x16, 0x12, 0x2c, 0xc4, 0xba, 0x50, 0x9d, 0xf9,
+	0xc1, 0x04, 0xeb, 0x2d, 0x46, 0xe3, 0x1b, 0xf3, 0x08, 0x36, 0x53, 0x20, 0x3f, 0x34, 0x5f, 0xff,
+	0x6a, 0xb0, 0x65, 0xf9, 0xae, 0x7b, 0x61, 0x4f, 0x5e, 0x17, 0xc8, 0x58, 0x02, 0xdc, 0xd2, 0xdd,
+	0xe0, 0x96, 0x33, 0xc0, 0x4d, 0x14, 0x61, 0x45, 0x29, 0x42, 0x05, 0xf6, 0x6a, 0x3e, 0xec, 0x35,
+	0x15, 0x76, 0x89, 0x69, 0x3d, 0x81, 0x69, 0x0c, 0x58, 0x23, 0x09, 0xd8, 0xd7, 0xb0, 0xbd, 0x14,
+	0xe5, 0x43, 0x21, 0xfb, 0xb3, 0x04, 0x9b, 0xc7, 0x1e, 0xa1, 0xb6, 0xeb, 0xa6, 0x10, 0x8b, 0xeb,
+	0x59, 0x2b, 0x5c, 0xcf, 0xa5, 0xff, 0x53, 0xcf, 0x65, 0x05, 0x72, 0x99, 0x9f, 0x4a, 0x22, 0x3f,
+	0x85, 0x6a, 0x5c, 0xe9, 0x2c, 0xb5, 0x54, 0x67, 0x41, 0xef, 0x00, 0xf0, 0xa2, 0x64, 0xca, 0x39,
+	0xb4, 0x4d, 0x76, 0x72, 0x2a, 0x1a, 0x89, 0xcc, 0x46, 0x23, 0x3b, 0x1b, 0x89, 0x0a, 0x37, 0x8f,
+	0x61, 0x2b, 0x0d, 0xd5, 0x43, 0x61, 0xff, 0x5d, 0x83, 0xed, 0x73, 0xcf, 0xc9, 0x04, 0x3e, 0xab,
+	0x54, 0x97, 0xa0, 0x28, 0x65, 0x40, 0xd1, 0x85, 0xea, 0x22, 0x0c, 0x2e, 0xb1, 0x80, 0x96, 0x6f,
+	0x92, 0x31, 0x56, 0x94, 0x18, 0xcd, 0x31, 0xe8, 0xcb, 0x3e, 0x3c, 0x30, 0xa2, 0xc8, 0xeb, 0xf8,
+	0x25, 0x68, 0xf2, 0xae, 0x6f, 0x6e, 0xc0, 0xfa, 0x21, 0xa6, 0xaf, 0xf8, 0xb5, 0x10, 0xe1, 0x99,
+	0x43, 0x40, 0xc9, 0xc3, 0x5b, 0x7b, 0xe2, 0x48, 0xb5, 0x27, 0xc7, 0x22, 0xc9, 0x2f, 0xb9, 0xcc,
+	0x2f, 0x98, 0xee, 0x23, 0x87, 0x50, 0x3f, 0xb8, 0xb9, 0x0b, 0xba, 0x0e, 0x94, 0xe7, 0xf6, 0x1b,
+	0xf1, 0x50, 0x44, 0x4b, 0xf3, 0x90, 0x79, 0x10, 0x8b, 0x0a, 0x0f, 0x92, 0xcf, 0xae, 0x56, 0xec,
+	0xd9, 0xfd, 0x11, 0xd0, 0x19, 0x8e, 0x27, 0x80, 0x7b, 0x5e, 0x2c, 0x99, 0x84, 0x92, 0x5a, 0x68,
+	0x3a, 0xd4, 0x27, 0x2e, 0xb6, 0xbd, 0x70, 0x21, 0xd2, 0x26, 0xb7, 0xe6, 0x4f, 0xb0, 0xa1, 0x68,
+	0x17, 0x7e, 0x46, 0xf1, 0x90, 0x4b, 0xa1, 0x3d, 0x5a, 0xa2, 0xcf, 0xa1, 0xc6, 0xc7, 0x22, 0xa6,
+	0xbb, 0x3d, 0x78, 0xa4, 0xfa, 0xcd, 0x94, 0x84, 0x9e, 0x98, 0xa3, 0x2c, 0xc1, 0x1b, 0x25, 0xe7,
+	0x3b, 0xc7, 0xbb, 0x3c, 0x63, 0x73, 0x9a, 0x4c, 0x4e, 0x17, 0x50, 0xf2, 0x90, 0x9b, 0x1c, 0xfc,
+	0xd5, 0x84, 0xb6, 0x9c, 0x09, 0xf8, 0x7c, 0x87, 0x1c, 0x58, 0x4d, 0x0e, 0x3f, 0xe8, 0x49, 0xfe,
+	0xf8, 0x97, 0x9a, 0x61, 0x8d, 0xa7, 0x45, 0x58, 0xb9, 0x65, 0x73, 0xe5, 0x13, 0x0d, 0x11, 0xe8,
+	0xa4, 0x67, 0x12, 0xf4, 0x2c, 0x5b, 0x47, 0xce, 0x10, 0x64, 0xf4, 0x8b, 0xb2, 0x4b, 0xb3, 0xe8,
+	0x9a, 0x95, 0x97, 0x3a, 0x48, 0xa0, 0x7b, 0xd5, 0xa8, 0xb3, 0x8b, 0xb1, 0x57, 0x98, 0x3f, 0xb6,
+	0xfb, 0x0b, 0xac, 0x29, 0x8f, 0x21, 0xca, 0x41, 0x2b, 0x6b, 0x2c, 0x31, 0x3e, 0x2a, 0xc4, 0x1b,
+	0xdb, 0x9a, 0x43, 0x5b, 0xed, 0x67, 0x28, 0x47, 0x41, 0xe6, 0x03, 0x61, 0x7c, 0x5c, 0x8c, 0x39,
+	0x36, 0x47, 0xa0, 0x93, 0x6e, 0x37, 0x79, 0x79, 0xcc, 0x69, 0x8d, 0x79, 0x79, 0xcc, 0xeb, 0x62,
+	0xe6, 0x0a, 0xb2, 0x01, 0x6e, 0xbb, 0x0d, 0x7a, 0x9c, 0x9b, 0x10, 0xb5, 0x49, 0x19, 0xbd, 0xfb,
+	0x19, 0x63, 0x13, 0x0b, 0x78, 0x2b, 0xf5, 0x1c, 0xa3, 0x1c, 0x68, 0xb2, 0x67, 0x13, 0xe3, 0x59,
+	0x41, 0xee, 0x54, 0x50, 0xa2, 0x81, 0xdd, 0x11, 0x94, 0xda, 0x1d, 0xef, 0x08, 0x2a, 0xd5, 0x0b,
+	0xcd, 0x15, 0xe4, 0x40, 0xdb, 0x0a, 0x3d, 0x61, 0x3a, 0xea, 0x20, 0x28, 0x47, 0x7a, 0xb9, 0x01,
+	0x1a, 0x4f, 0x0a, 0x70, 0x26, 0xee, 0xb7, 0x0d, 0x70, 0xdb, 0x73, 0xf2, 0xa2, 0x59, 0x6a, 0x55,
+	0x79, 0xd1, 0x2c, 0xb7, 0x2f, 0x73, 0xe5, 0x39, 0xfc, 0xd0, 0x90, 0x7c, 0x17, 0x35, 0xf6, 0x0f,
+	0xfb, 0xb3, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xfc, 0xc3, 0x7f, 0xcd, 0x4f, 0x10, 0x00, 0x00,
 }

pkg/tiller/ping.go

@@ -0,0 +1,28 @@
+/*
+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 tiller
+
+import (
+	"golang.org/x/net/context"
+
+	"k8s.io/helm/pkg/proto/hapi/services"
+)
+
+// PingTiller echoes back to the client
+func (s *ReleaseServer) PingTiller(ctx context.Context, request *services.PingTillerRequest) (*services.PingTillerResponse, error) {
+	return &services.PingTillerResponse{}, nil
+}