diff --git a/_proto/hapi/services/tiller.proto b/_proto/hapi/services/tiller.proto
index f47a47f14..fcba8101b 100644
--- a/_proto/hapi/services/tiller.proto
+++ b/_proto/hapi/services/tiller.proto
@@ -55,8 +55,8 @@ service ReleaseService {
 	rpc GetReleaseContent(GetReleaseContentRequest) returns (GetReleaseContentResponse) {
 	}
 
-	// UpdateRelease updates release content.
-	rpc UpdateRelease(UpdateReleaseRequest) returns (UpdateReleaseResponse) {
+	// UpgradeRelease upgrades release content.
+	rpc UpgradeRelease(UpgradeReleaseRequest) returns (UpgradeReleaseResponse) {
 	}
 
 	// InstallRelease requests installation of a chart as a new release.
@@ -182,8 +182,8 @@ message GetReleaseContentResponse {
 	hapi.release.Release release = 1;
 }
 
-// UpdateReleaseRequest updates a release.
-message UpdateReleaseRequest {
+// UpgradeReleaseRequest upgrades a release.
+message UpgradeReleaseRequest {
 	// The name of the release
 	string name = 1;
 	// Chart is the protobuf representation of a chart.
@@ -205,8 +205,8 @@ message UpdateReleaseRequest {
 	bool wait = 9;
 }
 
-// UpdateReleaseResponse is the response to an update request.
-message UpdateReleaseResponse {
+// UpgradeReleaseResponse is the response to an upgrade request.
+message UpgradeReleaseResponse {
 	hapi.release.Release release = 1;
 }
 
@@ -228,7 +228,7 @@ message RollbackReleaseRequest {
 	bool wait = 7;
 }
 
-// RollbackReleaseResponse is the response to an update request.
+// RollbackReleaseResponse is the response to an upgrade request.
 message RollbackReleaseResponse {
 	hapi.release.Release release = 1;
 }
diff --git a/cmd/helm/helm_test.go b/cmd/helm/helm_test.go
index efc4fce39..6548e3e43 100644
--- a/cmd/helm/helm_test.go
+++ b/cmd/helm/helm_test.go
@@ -172,11 +172,11 @@ func (c *fakeReleaseClient) GetVersion(opts ...helm.VersionOption) (*rls.GetVers
 	}, nil
 }
 
-func (c *fakeReleaseClient) UpdateRelease(rlsName string, chStr string, opts ...helm.UpdateOption) (*rls.UpdateReleaseResponse, error) {
+func (c *fakeReleaseClient) UpgradeRelease(rlsName string, chStr string, opts ...helm.UpgradeOption) (*rls.UpgradeReleaseResponse, error) {
 	return nil, nil
 }
 
-func (c *fakeReleaseClient) UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts ...helm.UpdateOption) (*rls.UpdateReleaseResponse, error) {
+func (c *fakeReleaseClient) UpgradeReleaseFromChart(rlsName string, chart *chart.Chart, opts ...helm.UpgradeOption) (*rls.UpgradeReleaseResponse, error) {
 	return nil, nil
 }
 
diff --git a/cmd/helm/upgrade.go b/cmd/helm/upgrade.go
index 5261efb06..c028e6e6f 100644
--- a/cmd/helm/upgrade.go
+++ b/cmd/helm/upgrade.go
@@ -168,10 +168,10 @@ func (u *upgradeCmd) run() error {
 		}
 	}
 
-	resp, err := u.client.UpdateRelease(
+	resp, err := u.client.UpgradeRelease(
 		u.release,
 		chartPath,
-		helm.UpdateValueOverrides(rawVals),
+		helm.UpgradeValueOverrides(rawVals),
 		helm.UpgradeDryRun(u.dryRun),
 		helm.UpgradeRecreate(u.recreate),
 		helm.UpgradeDisableHooks(u.disableHooks),
diff --git a/pkg/helm/client.go b/pkg/helm/client.go
index 2e773cca7..6e7d893d2 100644
--- a/pkg/helm/client.go
+++ b/pkg/helm/client.go
@@ -130,25 +130,25 @@ func (h *Client) DeleteRelease(rlsName string, opts ...DeleteOption) (*rls.Unins
 	return h.delete(ctx, req)
 }
 
-// UpdateRelease loads a chart from chstr and updates a release to a new/different chart
-func (h *Client) UpdateRelease(rlsName string, chstr string, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) {
-	// load the chart to update
+// UpgradeRelease loads a chart from chstr and upgrades a release to a new/different chart
+func (h *Client) UpgradeRelease(rlsName string, chstr string, opts ...UpgradeOption) (*rls.UpgradeReleaseResponse, error) {
+	// load the chart to upgrade
 	chart, err := chartutil.Load(chstr)
 	if err != nil {
 		return nil, err
 	}
 
-	return h.UpdateReleaseFromChart(rlsName, chart, opts...)
+	return h.UpgradeReleaseFromChart(rlsName, chart, opts...)
 }
 
-// UpdateReleaseFromChart updates a release to a new/different chart
-func (h *Client) UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) {
+// UpgradeReleaseFromChart upgrades a release to a new/different chart
+func (h *Client) UpgradeReleaseFromChart(rlsName string, chart *chart.Chart, opts ...UpgradeOption) (*rls.UpgradeReleaseResponse, error) {
 
-	// apply the update options
+	// apply the upgrade options
 	for _, opt := range opts {
 		opt(&h.opts)
 	}
-	req := &h.opts.updateReq
+	req := &h.opts.upgradeReq
 	req.Chart = chart
 	req.DryRun = h.opts.dryRun
 	req.Name = rlsName
@@ -167,7 +167,7 @@ func (h *Client) UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts
 		return nil, err
 	}
 
-	return h.update(ctx, req)
+	return h.upgrade(ctx, req)
 }
 
 // GetVersion returns the server version
@@ -311,8 +311,8 @@ func (h *Client) delete(ctx context.Context, req *rls.UninstallReleaseRequest) (
 	return rlc.UninstallRelease(ctx, req)
 }
 
-// Executes tiller.UpdateRelease RPC.
-func (h *Client) update(ctx context.Context, req *rls.UpdateReleaseRequest) (*rls.UpdateReleaseResponse, error) {
+// Executes tiller.UpgradeRelease RPC.
+func (h *Client) upgrade(ctx context.Context, req *rls.UpgradeReleaseRequest) (*rls.UpgradeReleaseResponse, error) {
 	c, err := grpc.Dial(h.opts.host, grpc.WithInsecure())
 	if err != nil {
 		return nil, err
@@ -320,7 +320,7 @@ func (h *Client) update(ctx context.Context, req *rls.UpdateReleaseRequest) (*rl
 	defer c.Close()
 
 	rlc := rls.NewReleaseServiceClient(c)
-	return rlc.UpdateRelease(ctx, req)
+	return rlc.UpgradeRelease(ctx, req)
 }
 
 // Executes tiller.RollbackRelease RPC.
diff --git a/pkg/helm/helm_test.go b/pkg/helm/helm_test.go
index 00db8b4e8..4a0b90e0b 100644
--- a/pkg/helm/helm_test.go
+++ b/pkg/helm/helm_test.go
@@ -171,8 +171,8 @@ func TestDeleteRelease_VerifyOptions(t *testing.T) {
 	NewClient(b4c).DeleteRelease(releaseName, ops...)
 }
 
-// Verify UpdateOption's are applied to an UpdateReleaseRequest correctly.
-func TestUpdateRelease_VerifyOptions(t *testing.T) {
+// Verify UpgradeOption's are applied to an UpgradeReleaseRequest correctly.
+func TestUpgradeRelease_VerifyOptions(t *testing.T) {
 	// Options testdata
 	var chartName = "alpine"
 	var releaseName = "test"
@@ -180,8 +180,8 @@ func TestUpdateRelease_VerifyOptions(t *testing.T) {
 	var overrides = []byte("key1=value1,key2=value2")
 	var dryRun = false
 
-	// Expected UpdateReleaseRequest message
-	exp := &tpb.UpdateReleaseRequest{
+	// Expected UpgradeReleaseRequest message
+	exp := &tpb.UpgradeReleaseRequest{
 		Name:         releaseName,
 		Chart:        loadChart(t, chartName),
 		Values:       &cpb.Config{Raw: string(overrides)},
@@ -189,26 +189,26 @@ func TestUpdateRelease_VerifyOptions(t *testing.T) {
 		DisableHooks: disableHooks,
 	}
 
-	// Options used in UpdateRelease
-	ops := []UpdateOption{
+	// Options used in UpgradeRelease
+	ops := []UpgradeOption{
 		UpgradeDryRun(dryRun),
-		UpdateValueOverrides(overrides),
+		UpgradeValueOverrides(overrides),
 		UpgradeDisableHooks(disableHooks),
 	}
 
-	// BeforeCall option to intercept helm client UpdateReleaseRequest
+	// BeforeCall option to intercept helm client UpgradeReleaseRequest
 	b4c := BeforeCall(func(_ context.Context, msg proto.Message) error {
 		switch act := msg.(type) {
-		case *tpb.UpdateReleaseRequest:
-			t.Logf("UpdateReleaseRequest: %#+v\n", act)
+		case *tpb.UpgradeReleaseRequest:
+			t.Logf("UpgradeReleaseRequest: %#+v\n", act)
 			assert(t, exp, act)
 		default:
-			t.Fatalf("expected message of type UpdateReleaseRequest, got %T\n", act)
+			t.Fatalf("expected message of type UpgradeReleaseRequest, got %T\n", act)
 		}
 		return errSkip
 	})
 
-	NewClient(b4c).UpdateRelease(releaseName, chartName, ops...)
+	NewClient(b4c).UpgradeRelease(releaseName, chartName, ops...)
 }
 
 // Verify RollbackOption's are applied to a RollbackReleaseRequest correctly.
diff --git a/pkg/helm/interface.go b/pkg/helm/interface.go
index bff110b34..988348a29 100644
--- a/pkg/helm/interface.go
+++ b/pkg/helm/interface.go
@@ -28,8 +28,8 @@ type Interface interface {
 	InstallReleaseFromChart(chart *chart.Chart, namespace string, opts ...InstallOption) (*rls.InstallReleaseResponse, error)
 	DeleteRelease(rlsName string, opts ...DeleteOption) (*rls.UninstallReleaseResponse, error)
 	ReleaseStatus(rlsName string, opts ...StatusOption) (*rls.GetReleaseStatusResponse, error)
-	UpdateRelease(rlsName, chStr string, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error)
-	UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error)
+	UpgradeRelease(rlsName, chStr string, opts ...UpgradeOption) (*rls.UpgradeReleaseResponse, error)
+	UpgradeReleaseFromChart(rlsName string, chart *chart.Chart, opts ...UpgradeOption) (*rls.UpgradeReleaseResponse, error)
 	RollbackRelease(rlsName string, opts ...RollbackOption) (*rls.RollbackReleaseResponse, error)
 	ReleaseContent(rlsName string, opts ...ContentOption) (*rls.GetReleaseContentResponse, error)
 	ReleaseHistory(rlsName string, opts ...HistoryOption) (*rls.GetHistoryResponse, error)
diff --git a/pkg/helm/option.go b/pkg/helm/option.go
index 3853133ef..30d15c1c2 100644
--- a/pkg/helm/option.go
+++ b/pkg/helm/option.go
@@ -50,8 +50,8 @@ type options struct {
 	listReq rls.ListReleasesRequest
 	// release install options are applied directly to the install release request
 	instReq rls.InstallReleaseRequest
-	// release update options are applied directly to the update release request
-	updateReq rls.UpdateReleaseRequest
+	// release upgrade options are applied directly to the upgrade release request
+	upgradeReq rls.UpgradeReleaseRequest
 	// release uninstall options are applied directly to the uninstall release request
 	uninstallReq rls.UninstallReleaseRequest
 	// release get status options are applied directly to the get release status request
@@ -170,9 +170,9 @@ func InstallTimeout(timeout int64) InstallOption {
 }
 
 // UpgradeTimeout specifies the number of seconds before kubernetes calls timeout
-func UpgradeTimeout(timeout int64) UpdateOption {
+func UpgradeTimeout(timeout int64) UpgradeOption {
 	return func(opts *options) {
-		opts.updateReq.Timeout = timeout
+		opts.upgradeReq.Timeout = timeout
 	}
 }
 
@@ -212,9 +212,9 @@ func InstallWait(wait bool) InstallOption {
 }
 
 // UpgradeWait specifies whether or not to wait for all resources to be ready
-func UpgradeWait(wait bool) UpdateOption {
+func UpgradeWait(wait bool) UpgradeOption {
 	return func(opts *options) {
-		opts.updateReq.Wait = wait
+		opts.upgradeReq.Wait = wait
 	}
 }
 
@@ -225,10 +225,10 @@ func RollbackWait(wait bool) RollbackOption {
 	}
 }
 
-// UpdateValueOverrides specifies a list of values to include when upgrading
-func UpdateValueOverrides(raw []byte) UpdateOption {
+// UpgradeValueOverrides specifies a list of values to include when upgrading
+func UpgradeValueOverrides(raw []byte) UpgradeOption {
 	return func(opts *options) {
-		opts.updateReq.Values = &cpb.Config{Raw: string(raw)}
+		opts.upgradeReq.Values = &cpb.Config{Raw: string(raw)}
 	}
 }
 
@@ -303,28 +303,28 @@ func RollbackVersion(ver int32) RollbackOption {
 }
 
 // UpgradeDisableHooks will disable hooks for an upgrade operation.
-func UpgradeDisableHooks(disable bool) UpdateOption {
+func UpgradeDisableHooks(disable bool) UpgradeOption {
 	return func(opts *options) {
 		opts.disableHooks = disable
 	}
 }
 
 // UpgradeDryRun will (if true) execute an upgrade as a dry run.
-func UpgradeDryRun(dry bool) UpdateOption {
+func UpgradeDryRun(dry bool) UpgradeOption {
 	return func(opts *options) {
 		opts.dryRun = dry
 	}
 }
 
 // ResetValues will (if true) trigger resetting the values to their original state.
-func ResetValues(reset bool) UpdateOption {
+func ResetValues(reset bool) UpgradeOption {
 	return func(opts *options) {
 		opts.resetValues = reset
 	}
 }
 
 // UpgradeRecreate will (if true) recreate pods after upgrade.
-func UpgradeRecreate(recreate bool) UpdateOption {
+func UpgradeRecreate(recreate bool) UpgradeOption {
 	return func(opts *options) {
 		opts.recreate = recreate
 	}
@@ -361,10 +361,10 @@ type DeleteOption func(*options)
 // VersionOption -- TODO
 type VersionOption func(*options)
 
-// UpdateOption allows specifying various settings
+// UpgradeOption allows specifying various settings
 // configurable by the helm client user for overriding
 // the defaults used when running the `helm upgrade` command.
-type UpdateOption func(*options)
+type UpgradeOption func(*options)
 
 // RollbackOption allows specififying various settings configurable
 // by the helm client user for overriding the defaults used when
diff --git a/pkg/proto/hapi/chart/chart.pb.go b/pkg/proto/hapi/chart/chart.pb.go
index c3afc3f44..dbb188e91 100644
--- a/pkg/proto/hapi/chart/chart.pb.go
+++ b/pkg/proto/hapi/chart/chart.pb.go
@@ -101,7 +101,7 @@ 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,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
diff --git a/pkg/proto/hapi/chart/config.pb.go b/pkg/proto/hapi/chart/config.pb.go
index a7b61885a..73ab3ec47 100644
--- a/pkg/proto/hapi/chart/config.pb.go
+++ b/pkg/proto/hapi/chart/config.pb.go
@@ -50,7 +50,7 @@ func init() { proto.RegisterFile("hapi/chart/config.proto", fileDescriptor1) }
 
 var fileDescriptor1 = []byte{
 	// 182 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0xc8,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
 	0x83, 0x25, 0x85, 0x04, 0xb8, 0x98, 0x8b, 0x12, 0xcb, 0x25, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83,
diff --git a/pkg/proto/hapi/chart/metadata.pb.go b/pkg/proto/hapi/chart/metadata.pb.go
index 5feee0bf4..28a9668fa 100644
--- a/pkg/proto/hapi/chart/metadata.pb.go
+++ b/pkg/proto/hapi/chart/metadata.pb.go
@@ -103,7 +103,7 @@ func init() { proto.RegisterFile("hapi/chart/metadata.proto", fileDescriptor2) }
 
 var fileDescriptor2 = []byte{
 	// 339 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x92, 0x4f, 0x4b, 0xeb, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x4f, 0x4b, 0xeb, 0x40,
 	0x14, 0xc5, 0x5f, 0x5e, 0x9a, 0x7f, 0x37, 0xef, 0x3d, 0xca, 0xf0, 0x28, 0xa3, 0x88, 0x84, 0xae,
 	0xb2, 0x4a, 0x41, 0x41, 0x5c, 0x0b, 0xe2, 0x42, 0xdb, 0x4a, 0xf0, 0x0f, 0xb8, 0x1b, 0x93, 0x4b,
 	0x3b, 0x68, 0x66, 0xc2, 0xcc, 0xa8, 0xf8, 0xe5, 0xfc, 0x6c, 0x32, 0x93, 0xa4, 0xcd, 0xc2, 0xdd,
diff --git a/pkg/proto/hapi/chart/template.pb.go b/pkg/proto/hapi/chart/template.pb.go
index 2bed587b5..74ecc4292 100644
--- a/pkg/proto/hapi/chart/template.pb.go
+++ b/pkg/proto/hapi/chart/template.pb.go
@@ -37,7 +37,7 @@ func init() { proto.RegisterFile("hapi/chart/template.proto", fileDescriptor3) }
 
 var fileDescriptor3 = []byte{
 	// 107 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0x48, 0x2c, 0xc8,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
diff --git a/pkg/proto/hapi/release/hook.pb.go b/pkg/proto/hapi/release/hook.pb.go
index 956ca15f3..32ab1323c 100644
--- a/pkg/proto/hapi/release/hook.pb.go
+++ b/pkg/proto/hapi/release/hook.pb.go
@@ -123,7 +123,7 @@ func init() { proto.RegisterFile("hapi/release/hook.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
 	// 354 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x90, 0xdd, 0x6e, 0xa2, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xdd, 0x6e, 0xa2, 0x40,
 	0x18, 0x86, 0x17, 0x41, 0xd0, 0xd1, 0x75, 0x67, 0x27, 0x9b, 0xec, 0xc4, 0x93, 0x35, 0x1e, 0x79,
 	0x34, 0x6c, 0x6c, 0x7a, 0x01, 0xa8, 0xd3, 0xd6, 0x48, 0xd0, 0x0c, 0x90, 0x26, 0x3d, 0x21, 0x98,
 	0x8e, 0x4a, 0x14, 0x86, 0x08, 0xf6, 0x72, 0x7a, 0x55, 0xbd, 0xa0, 0x66, 0x86, 0x9f, 0x34, 0xe9,
diff --git a/pkg/proto/hapi/release/info.pb.go b/pkg/proto/hapi/release/info.pb.go
index a73dcab2f..daa26d4c9 100644
--- a/pkg/proto/hapi/release/info.pb.go
+++ b/pkg/proto/hapi/release/info.pb.go
@@ -66,7 +66,7 @@ func init() { proto.RegisterFile("hapi/release/info.proto", fileDescriptor1) }
 
 var fileDescriptor1 = []byte{
 	// 235 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0x31, 0x4f, 0xc3, 0x30,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x31, 0x4f, 0xc3, 0x30,
 	0x10, 0x85, 0x95, 0x52, 0x5a, 0xd5, 0x6d, 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, 0x83, 0xd2, 0xa9, 0xab, 0xbf, 0xf7, 0x3e, 0xbf,
diff --git a/pkg/proto/hapi/release/release.pb.go b/pkg/proto/hapi/release/release.pb.go
index 72255e3e2..01f79fe29 100644
--- a/pkg/proto/hapi/release/release.pb.go
+++ b/pkg/proto/hapi/release/release.pb.go
@@ -78,7 +78,7 @@ func init() { proto.RegisterFile("hapi/release/release.proto", fileDescriptor2)
 
 var fileDescriptor2 = []byte{
 	// 256 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x90, 0xbf, 0x4e, 0xc3, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xbf, 0x4e, 0xc3, 0x40,
 	0x0c, 0xc6, 0x95, 0x36, 0x7f, 0x1a, 0xc3, 0x82, 0x07, 0xb0, 0x22, 0x86, 0x88, 0x01, 0x22, 0x86,
 	0x54, 0x82, 0x37, 0x80, 0x05, 0xd6, 0x1b, 0xd9, 0x8e, 0xe8, 0x42, 0x4e, 0xa5, 0xe7, 0x28, 0x17,
 	0xf1, 0x2c, 0x3c, 0x2e, 0xba, 0x3f, 0x85, 0x94, 0x2e, 0x4e, 0xec, 0xdf, 0xa7, 0xcf, 0xdf, 0x19,
diff --git a/pkg/proto/hapi/release/status.pb.go b/pkg/proto/hapi/release/status.pb.go
index 29144b7ca..65672a0cf 100644
--- a/pkg/proto/hapi/release/status.pb.go
+++ b/pkg/proto/hapi/release/status.pb.go
@@ -85,7 +85,7 @@ func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor3) }
 
 var fileDescriptor3 = []byte{
 	// 291 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x54, 0x90, 0xdf, 0x6a, 0xc2, 0x30,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xdf, 0x6a, 0xc2, 0x30,
 	0x14, 0xc6, 0x57, 0xad, 0x3a, 0x8f, 0x22, 0x21, 0x1b, 0xac, 0xca, 0x06, 0xc5, 0xab, 0xde, 0xac,
 	0x05, 0xf7, 0x04, 0xdb, 0x12, 0x87, 0xac, 0x54, 0x69, 0x2b, 0xfb, 0x73, 0x53, 0xaa, 0x9e, 0x39,
 	0xa1, 0x34, 0xd2, 0x24, 0x17, 0x7b, 0x88, 0xbd, 0xf3, 0x68, 0x2b, 0x74, 0x5e, 0x7e, 0xf9, 0xfd,
diff --git a/pkg/proto/hapi/release/test_run.pb.go b/pkg/proto/hapi/release/test_run.pb.go
index 51b3e72f9..46bdf81fc 100644
--- a/pkg/proto/hapi/release/test_run.pb.go
+++ b/pkg/proto/hapi/release/test_run.pb.go
@@ -74,7 +74,7 @@ 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,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
diff --git a/pkg/proto/hapi/release/test_suite.pb.go b/pkg/proto/hapi/release/test_suite.pb.go
index 27fe45ac5..f168bf1d2 100644
--- a/pkg/proto/hapi/release/test_suite.pb.go
+++ b/pkg/proto/hapi/release/test_suite.pb.go
@@ -58,7 +58,7 @@ func init() { proto.RegisterFile("hapi/release/test_suite.proto", fileDescriptor
 
 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,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
diff --git a/pkg/proto/hapi/services/tiller.pb.go b/pkg/proto/hapi/services/tiller.pb.go
index 4e772dd0d..e2059beef 100644
--- a/pkg/proto/hapi/services/tiller.pb.go
+++ b/pkg/proto/hapi/services/tiller.pb.go
@@ -16,8 +16,8 @@ It has these top-level messages:
 	GetReleaseStatusResponse
 	GetReleaseContentRequest
 	GetReleaseContentResponse
-	UpdateReleaseRequest
-	UpdateReleaseResponse
+	UpgradeReleaseRequest
+	UpgradeReleaseResponse
 	RollbackReleaseRequest
 	RollbackReleaseResponse
 	InstallReleaseRequest
@@ -238,8 +238,8 @@ func (m *GetReleaseContentResponse) GetRelease() *hapi_release5.Release {
 	return nil
 }
 
-// UpdateReleaseRequest updates a release.
-type UpdateReleaseRequest struct {
+// UpgradeReleaseRequest upgrades a release.
+type UpgradeReleaseRequest struct {
 	// The name of the release
 	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 	// Chart is the protobuf representation of a chart.
@@ -261,36 +261,36 @@ type UpdateReleaseRequest struct {
 	Wait bool `protobuf:"varint,9,opt,name=wait" json:"wait,omitempty"`
 }
 
-func (m *UpdateReleaseRequest) Reset()                    { *m = UpdateReleaseRequest{} }
-func (m *UpdateReleaseRequest) String() string            { return proto.CompactTextString(m) }
-func (*UpdateReleaseRequest) ProtoMessage()               {}
-func (*UpdateReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+func (m *UpgradeReleaseRequest) Reset()                    { *m = UpgradeReleaseRequest{} }
+func (m *UpgradeReleaseRequest) String() string            { return proto.CompactTextString(m) }
+func (*UpgradeReleaseRequest) ProtoMessage()               {}
+func (*UpgradeReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 
-func (m *UpdateReleaseRequest) GetChart() *hapi_chart3.Chart {
+func (m *UpgradeReleaseRequest) GetChart() *hapi_chart3.Chart {
 	if m != nil {
 		return m.Chart
 	}
 	return nil
 }
 
-func (m *UpdateReleaseRequest) GetValues() *hapi_chart.Config {
+func (m *UpgradeReleaseRequest) GetValues() *hapi_chart.Config {
 	if m != nil {
 		return m.Values
 	}
 	return nil
 }
 
-// UpdateReleaseResponse is the response to an update request.
-type UpdateReleaseResponse struct {
+// UpgradeReleaseResponse is the response to an upgrade request.
+type UpgradeReleaseResponse struct {
 	Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"`
 }
 
-func (m *UpdateReleaseResponse) Reset()                    { *m = UpdateReleaseResponse{} }
-func (m *UpdateReleaseResponse) String() string            { return proto.CompactTextString(m) }
-func (*UpdateReleaseResponse) ProtoMessage()               {}
-func (*UpdateReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+func (m *UpgradeReleaseResponse) Reset()                    { *m = UpgradeReleaseResponse{} }
+func (m *UpgradeReleaseResponse) String() string            { return proto.CompactTextString(m) }
+func (*UpgradeReleaseResponse) ProtoMessage()               {}
+func (*UpgradeReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 
-func (m *UpdateReleaseResponse) GetRelease() *hapi_release5.Release {
+func (m *UpgradeReleaseResponse) GetRelease() *hapi_release5.Release {
 	if m != nil {
 		return m.Release
 	}
@@ -320,7 +320,7 @@ func (m *RollbackReleaseRequest) String() string            { return proto.Compa
 func (*RollbackReleaseRequest) ProtoMessage()               {}
 func (*RollbackReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 
-// RollbackReleaseResponse is the response to an update request.
+// RollbackReleaseResponse is the response to an upgrade request.
 type RollbackReleaseResponse struct {
 	Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"`
 }
@@ -525,8 +525,8 @@ func init() {
 	proto.RegisterType((*GetReleaseStatusResponse)(nil), "hapi.services.tiller.GetReleaseStatusResponse")
 	proto.RegisterType((*GetReleaseContentRequest)(nil), "hapi.services.tiller.GetReleaseContentRequest")
 	proto.RegisterType((*GetReleaseContentResponse)(nil), "hapi.services.tiller.GetReleaseContentResponse")
-	proto.RegisterType((*UpdateReleaseRequest)(nil), "hapi.services.tiller.UpdateReleaseRequest")
-	proto.RegisterType((*UpdateReleaseResponse)(nil), "hapi.services.tiller.UpdateReleaseResponse")
+	proto.RegisterType((*UpgradeReleaseRequest)(nil), "hapi.services.tiller.UpgradeReleaseRequest")
+	proto.RegisterType((*UpgradeReleaseResponse)(nil), "hapi.services.tiller.UpgradeReleaseResponse")
 	proto.RegisterType((*RollbackReleaseRequest)(nil), "hapi.services.tiller.RollbackReleaseRequest")
 	proto.RegisterType((*RollbackReleaseResponse)(nil), "hapi.services.tiller.RollbackReleaseResponse")
 	proto.RegisterType((*InstallReleaseRequest)(nil), "hapi.services.tiller.InstallReleaseRequest")
@@ -563,8 +563,8 @@ type ReleaseServiceClient interface {
 	GetReleaseStatus(ctx context.Context, in *GetReleaseStatusRequest, opts ...grpc.CallOption) (*GetReleaseStatusResponse, error)
 	// GetReleaseContent retrieves the release content (chart + value) for the specified release.
 	GetReleaseContent(ctx context.Context, in *GetReleaseContentRequest, opts ...grpc.CallOption) (*GetReleaseContentResponse, error)
-	// UpdateRelease updates release content.
-	UpdateRelease(ctx context.Context, in *UpdateReleaseRequest, opts ...grpc.CallOption) (*UpdateReleaseResponse, error)
+	// UpgradeRelease upgrades release content.
+	UpgradeRelease(ctx context.Context, in *UpgradeReleaseRequest, opts ...grpc.CallOption) (*UpgradeReleaseResponse, error)
 	// InstallRelease requests installation of a chart as a new release.
 	InstallRelease(ctx context.Context, in *InstallReleaseRequest, opts ...grpc.CallOption) (*InstallReleaseResponse, error)
 	// UninstallRelease requests deletion of a named release.
@@ -637,9 +637,9 @@ func (c *releaseServiceClient) GetReleaseContent(ctx context.Context, in *GetRel
 	return out, nil
 }
 
-func (c *releaseServiceClient) UpdateRelease(ctx context.Context, in *UpdateReleaseRequest, opts ...grpc.CallOption) (*UpdateReleaseResponse, error) {
-	out := new(UpdateReleaseResponse)
-	err := grpc.Invoke(ctx, "/hapi.services.tiller.ReleaseService/UpdateRelease", in, out, c.cc, opts...)
+func (c *releaseServiceClient) UpgradeRelease(ctx context.Context, in *UpgradeReleaseRequest, opts ...grpc.CallOption) (*UpgradeReleaseResponse, error) {
+	out := new(UpgradeReleaseResponse)
+	err := grpc.Invoke(ctx, "/hapi.services.tiller.ReleaseService/UpgradeRelease", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -735,8 +735,8 @@ type ReleaseServiceServer interface {
 	GetReleaseStatus(context.Context, *GetReleaseStatusRequest) (*GetReleaseStatusResponse, error)
 	// GetReleaseContent retrieves the release content (chart + value) for the specified release.
 	GetReleaseContent(context.Context, *GetReleaseContentRequest) (*GetReleaseContentResponse, error)
-	// UpdateRelease updates release content.
-	UpdateRelease(context.Context, *UpdateReleaseRequest) (*UpdateReleaseResponse, error)
+	// UpgradeRelease upgrades release content.
+	UpgradeRelease(context.Context, *UpgradeReleaseRequest) (*UpgradeReleaseResponse, error)
 	// InstallRelease requests installation of a chart as a new release.
 	InstallRelease(context.Context, *InstallReleaseRequest) (*InstallReleaseResponse, error)
 	// UninstallRelease requests deletion of a named release.
@@ -812,20 +812,20 @@ func _ReleaseService_GetReleaseContent_Handler(srv interface{}, ctx context.Cont
 	return interceptor(ctx, in, info, handler)
 }
 
-func _ReleaseService_UpdateRelease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(UpdateReleaseRequest)
+func _ReleaseService_UpgradeRelease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpgradeReleaseRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(ReleaseServiceServer).UpdateRelease(ctx, in)
+		return srv.(ReleaseServiceServer).UpgradeRelease(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/hapi.services.tiller.ReleaseService/UpdateRelease",
+		FullMethod: "/hapi.services.tiller.ReleaseService/UpgradeRelease",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ReleaseServiceServer).UpdateRelease(ctx, req.(*UpdateReleaseRequest))
+		return srv.(ReleaseServiceServer).UpgradeRelease(ctx, req.(*UpgradeReleaseRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -954,8 +954,8 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{
 			Handler:    _ReleaseService_GetReleaseContent_Handler,
 		},
 		{
-			MethodName: "UpdateRelease",
-			Handler:    _ReleaseService_UpdateRelease_Handler,
+			MethodName: "UpgradeRelease",
+			Handler:    _ReleaseService_UpgradeRelease_Handler,
 		},
 		{
 			MethodName: "InstallRelease",
@@ -996,78 +996,78 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("hapi/services/tiller.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 1162 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x57, 0xdd, 0x6e, 0xe3, 0xc4,
-	0x17, 0xaf, 0xe3, 0x7c, 0x9e, 0x76, 0xfb, 0x4f, 0xa7, 0x5f, 0xae, 0xf5, 0x07, 0x15, 0x23, 0x68,
-	0x76, 0x61, 0x53, 0x08, 0x57, 0x48, 0x08, 0xa9, 0xdb, 0x8d, 0xda, 0x42, 0xe9, 0x4a, 0xce, 0x76,
-	0x91, 0x10, 0x22, 0x72, 0x93, 0x49, 0x6b, 0xd6, 0xf1, 0x04, 0xcf, 0xb8, 0x6c, 0x6f, 0xb9, 0xe3,
-	0x51, 0xe0, 0x29, 0x78, 0x02, 0x5e, 0x80, 0x97, 0x41, 0x9e, 0x0f, 0xd7, 0xe3, 0xda, 0xad, 0xe9,
-	0x4d, 0x3c, 0x33, 0xe7, 0xcc, 0xf9, 0xf8, 0x9d, 0x33, 0xbf, 0x99, 0x80, 0x7d, 0xe5, 0x2d, 0xfc,
-	0x7d, 0x8a, 0xa3, 0x6b, 0x7f, 0x82, 0xe9, 0x3e, 0xf3, 0x83, 0x00, 0x47, 0xfd, 0x45, 0x44, 0x18,
-	0x41, 0x1b, 0x89, 0xac, 0xaf, 0x64, 0x7d, 0x21, 0xb3, 0xb7, 0xf8, 0x8e, 0xc9, 0x95, 0x17, 0x31,
-	0xf1, 0x2b, 0xb4, 0xed, 0xed, 0xec, 0x3a, 0x09, 0x67, 0xfe, 0xa5, 0x14, 0x08, 0x17, 0x11, 0x0e,
-	0xb0, 0x47, 0xb1, 0xfa, 0x6a, 0x9b, 0x94, 0xcc, 0x0f, 0x67, 0x44, 0x0a, 0x76, 0x34, 0x01, 0x65,
-	0x1e, 0x8b, 0xa9, 0x66, 0xef, 0x1a, 0x47, 0xd4, 0x27, 0xa1, 0xfa, 0x0a, 0x99, 0xf3, 0x57, 0x0d,
-	0xd6, 0x4f, 0x7d, 0xca, 0x5c, 0xb1, 0x91, 0xba, 0xf8, 0x97, 0x18, 0x53, 0x86, 0x36, 0xa0, 0x11,
-	0xf8, 0x73, 0x9f, 0x59, 0xc6, 0xae, 0xd1, 0x33, 0x5d, 0x31, 0x41, 0x5b, 0xd0, 0x24, 0xb3, 0x19,
-	0xc5, 0xcc, 0xaa, 0xed, 0x1a, 0xbd, 0x8e, 0x2b, 0x67, 0xe8, 0x6b, 0x68, 0x51, 0x12, 0xb1, 0xf1,
-	0xc5, 0x8d, 0x65, 0xee, 0x1a, 0xbd, 0xd5, 0xc1, 0x47, 0xfd, 0x22, 0x28, 0xfa, 0x89, 0xa7, 0x11,
-	0x89, 0x58, 0x3f, 0xf9, 0x79, 0x71, 0xe3, 0x36, 0x29, 0xff, 0x26, 0x76, 0x67, 0x7e, 0xc0, 0x70,
-	0x64, 0xd5, 0x85, 0x5d, 0x31, 0x43, 0x47, 0x00, 0xdc, 0x2e, 0x89, 0xa6, 0x38, 0xb2, 0x1a, 0xdc,
-	0x74, 0xaf, 0x82, 0xe9, 0x57, 0x89, 0xbe, 0xdb, 0xa1, 0x6a, 0x88, 0xbe, 0x82, 0x15, 0x01, 0xc9,
-	0x78, 0x42, 0xa6, 0x98, 0x5a, 0xcd, 0x5d, 0xb3, 0xb7, 0x3a, 0xd8, 0x11, 0xa6, 0x14, 0xc2, 0x23,
-	0x01, 0xda, 0x21, 0x99, 0x62, 0x77, 0x59, 0xa8, 0x27, 0x63, 0x8a, 0xfe, 0x0f, 0x9d, 0xd0, 0x9b,
-	0x63, 0xba, 0xf0, 0x26, 0xd8, 0x6a, 0xf1, 0x08, 0x6f, 0x17, 0x9c, 0x9f, 0xa0, 0xad, 0x9c, 0x3b,
-	0x03, 0x68, 0x8a, 0xd4, 0xd0, 0x32, 0xb4, 0xce, 0xcf, 0xbe, 0x3d, 0x7b, 0xf5, 0xfd, 0x59, 0x77,
-	0x09, 0xb5, 0xa1, 0x7e, 0x76, 0xf0, 0xdd, 0xb0, 0x6b, 0xa0, 0x35, 0x78, 0x72, 0x7a, 0x30, 0x7a,
-	0x3d, 0x76, 0x87, 0xa7, 0xc3, 0x83, 0xd1, 0xf0, 0x65, 0xb7, 0xe6, 0xbc, 0x0f, 0x9d, 0x34, 0x66,
-	0xd4, 0x02, 0xf3, 0x60, 0x74, 0x28, 0xb6, 0xbc, 0x1c, 0x8e, 0x0e, 0xbb, 0x86, 0xf3, 0xbb, 0x01,
-	0x1b, 0x7a, 0x89, 0xe8, 0x82, 0x84, 0x14, 0x27, 0x35, 0x9a, 0x90, 0x38, 0x4c, 0x6b, 0xc4, 0x27,
-	0x08, 0x41, 0x3d, 0xc4, 0xef, 0x54, 0x85, 0xf8, 0x38, 0xd1, 0x64, 0x84, 0x79, 0x01, 0xaf, 0x8e,
-	0xe9, 0x8a, 0x09, 0xfa, 0x1c, 0xda, 0x32, 0x75, 0x6a, 0xd5, 0x77, 0xcd, 0xde, 0xf2, 0x60, 0x53,
-	0x07, 0x44, 0x7a, 0x74, 0x53, 0x35, 0xe7, 0x08, 0xb6, 0x8f, 0xb0, 0x8a, 0x44, 0xe0, 0xa5, 0x3a,
-	0x26, 0xf1, 0xeb, 0xcd, 0x31, 0x0f, 0x26, 0xf1, 0xeb, 0xcd, 0x31, 0xb2, 0xa0, 0x25, 0xdb, 0x8d,
-	0x87, 0xd3, 0x70, 0xd5, 0xd4, 0x61, 0x60, 0xdd, 0x35, 0x24, 0xf3, 0x2a, 0xb2, 0xf4, 0x31, 0xd4,
-	0x93, 0x66, 0xe7, 0x66, 0x96, 0x07, 0x48, 0x8f, 0xf3, 0x24, 0x9c, 0x11, 0x97, 0xcb, 0xf5, 0x52,
-	0x99, 0xf9, 0x52, 0x1d, 0x67, 0xbd, 0x1e, 0x92, 0x90, 0xe1, 0x90, 0x3d, 0x2e, 0xfe, 0x53, 0xd8,
-	0x29, 0xb0, 0x24, 0x13, 0xd8, 0x87, 0x96, 0x0c, 0x8d, 0x5b, 0x2b, 0xc5, 0x55, 0x69, 0x39, 0x7f,
-	0xd6, 0x60, 0xe3, 0x7c, 0x31, 0xf5, 0x18, 0x56, 0xa2, 0x7b, 0x82, 0xda, 0x83, 0x06, 0x27, 0x0d,
-	0x89, 0xc5, 0x9a, 0xb0, 0x2d, 0x98, 0xe5, 0x30, 0xf9, 0x75, 0x85, 0x1c, 0x3d, 0x83, 0xe6, 0xb5,
-	0x17, 0xc4, 0x98, 0x72, 0x20, 0x52, 0xd4, 0xa4, 0x26, 0x67, 0x1c, 0x57, 0x6a, 0xa0, 0x6d, 0x68,
-	0x4d, 0xa3, 0x9b, 0x71, 0x14, 0x87, 0xfc, 0x08, 0xb6, 0xdd, 0xe6, 0x34, 0xba, 0x71, 0xe3, 0x10,
-	0x7d, 0x08, 0x4f, 0xa6, 0x3e, 0xf5, 0x2e, 0x02, 0x3c, 0xbe, 0x22, 0xe4, 0x2d, 0xe5, 0xa7, 0xb0,
-	0xed, 0xae, 0xc8, 0xc5, 0xe3, 0x64, 0x0d, 0xd9, 0x49, 0x27, 0x4d, 0x22, 0xec, 0x31, 0x6c, 0x35,
-	0xb9, 0x3c, 0x9d, 0x27, 0x18, 0x32, 0x7f, 0x8e, 0x49, 0xcc, 0xf8, 0xd1, 0x31, 0x5d, 0x35, 0x45,
-	0x1f, 0xc0, 0x4a, 0x84, 0x29, 0x66, 0x63, 0x19, 0x65, 0x9b, 0xef, 0x5c, 0xe6, 0x6b, 0x6f, 0x44,
-	0x58, 0x08, 0xea, 0xbf, 0x7a, 0x3e, 0xb3, 0x3a, 0x5c, 0xc4, 0xc7, 0xce, 0x31, 0x6c, 0xe6, 0xb0,
-	0x7a, 0x2c, 0xec, 0x7f, 0x1b, 0xb0, 0xe5, 0x92, 0x20, 0xb8, 0xf0, 0x26, 0x6f, 0x2b, 0x00, 0x9f,
-	0xc1, 0xa8, 0x76, 0x3f, 0x46, 0x66, 0x01, 0x46, 0x99, 0x5e, 0xaa, 0x6b, 0xbd, 0xa4, 0xa1, 0xd7,
-	0x28, 0x47, 0xaf, 0xa9, 0xa3, 0xa7, 0xa0, 0x69, 0x65, 0xa0, 0xf9, 0x06, 0xb6, 0xef, 0xe4, 0xf3,
-	0x58, 0x70, 0xfe, 0xa8, 0xc1, 0xe6, 0x49, 0x48, 0x99, 0x17, 0x04, 0x39, 0x6c, 0xd2, 0x06, 0x34,
-	0x2a, 0x37, 0x60, 0xed, 0xbf, 0x34, 0xa0, 0xa9, 0x81, 0xab, 0x2a, 0x51, 0xcf, 0x54, 0xa2, 0x52,
-	0x53, 0x6a, 0x54, 0xd0, 0xcc, 0x51, 0x01, 0x7a, 0x0f, 0x20, 0xc2, 0x31, 0xc5, 0x63, 0x6e, 0x5c,
-	0x80, 0xd8, 0xe1, 0x2b, 0x67, 0xf2, 0xe4, 0x2b, 0xdc, 0xdb, 0xc5, 0xb8, 0x67, 0x5b, 0xf2, 0x04,
-	0xb6, 0xf2, 0x50, 0x3d, 0x16, 0xf6, 0xdf, 0x0c, 0xd8, 0x3e, 0x0f, 0xfd, 0x42, 0xe0, 0x8b, 0x9a,
-	0xf2, 0x0e, 0x14, 0xb5, 0x02, 0x28, 0x36, 0xa0, 0xb1, 0x88, 0xa3, 0x4b, 0x2c, 0xa1, 0x15, 0x93,
-	0x6c, 0x8e, 0x75, 0x2d, 0x47, 0x67, 0x0c, 0xd6, 0xdd, 0x18, 0x1e, 0x99, 0x51, 0x12, 0x75, 0x4a,
-	0xdd, 0x1d, 0x41, 0xd3, 0xce, 0x3a, 0xac, 0x1d, 0x61, 0xf6, 0x46, 0x1c, 0x00, 0x99, 0x9e, 0x33,
-	0x04, 0x94, 0x5d, 0xbc, 0xf5, 0x27, 0x97, 0x74, 0x7f, 0xea, 0x1d, 0xa3, 0xf4, 0x95, 0x96, 0xf3,
-	0x25, 0xb7, 0x7d, 0xec, 0x53, 0x46, 0xa2, 0x9b, 0xfb, 0xa0, 0xeb, 0x82, 0x39, 0xf7, 0xde, 0x49,
-	0x66, 0x4f, 0x86, 0xce, 0x11, 0x8f, 0x20, 0xdd, 0x2a, 0x23, 0xc8, 0xde, 0x93, 0x46, 0xb5, 0x7b,
-	0xf2, 0x47, 0x40, 0xaf, 0x71, 0x7a, 0x65, 0x3f, 0x70, 0xc5, 0xa8, 0x22, 0xd4, 0xf4, 0x46, 0xb3,
-	0xa0, 0x35, 0x09, 0xb0, 0x17, 0xc6, 0x0b, 0x59, 0x36, 0x35, 0x75, 0xf6, 0x60, 0x5d, 0xb3, 0x2e,
-	0xe3, 0x4c, 0xf2, 0xa1, 0x97, 0xd2, 0x7a, 0x32, 0x1c, 0xfc, 0xd3, 0x86, 0x55, 0x75, 0xc7, 0x8a,
-	0xf7, 0x12, 0xf2, 0x61, 0x25, 0xfb, 0x98, 0x40, 0x4f, 0xcb, 0x9f, 0x53, 0xb9, 0x37, 0xa1, 0xfd,
-	0xac, 0x8a, 0xaa, 0x88, 0xc5, 0x59, 0xfa, 0xcc, 0x40, 0x14, 0xba, 0xf9, 0x3b, 0x1e, 0x3d, 0x2f,
-	0xb6, 0x51, 0xf2, 0xa8, 0xb0, 0xfb, 0x55, 0xd5, 0x95, 0x5b, 0x74, 0xcd, 0xab, 0xaf, 0x5f, 0xcc,
-	0xe8, 0x41, 0x33, 0xfa, 0x5b, 0xc0, 0xde, 0xaf, 0xac, 0x9f, 0xfa, 0xfd, 0x19, 0x9e, 0x68, 0xb7,
-	0x12, 0x2a, 0x41, 0xab, 0xe8, 0x9a, 0xb7, 0x3f, 0xa9, 0xa4, 0x9b, 0xfa, 0x9a, 0xc3, 0xaa, 0x4e,
-	0x37, 0xa8, 0xc4, 0x40, 0x21, 0x7f, 0xdb, 0x9f, 0x56, 0x53, 0x4e, 0xdd, 0x51, 0xe8, 0xe6, 0xd9,
-	0xa0, 0xac, 0x8e, 0x25, 0xcc, 0x55, 0x56, 0xc7, 0x32, 0x92, 0x71, 0x96, 0x90, 0x07, 0x70, 0x4b,
-	0x06, 0x68, 0xaf, 0xb4, 0x20, 0x3a, 0x87, 0xd8, 0xbd, 0x87, 0x15, 0x53, 0x17, 0x0b, 0xf8, 0x5f,
-	0xee, 0xb6, 0x44, 0x25, 0xd0, 0x14, 0x3f, 0x12, 0xec, 0xe7, 0x15, 0xb5, 0x73, 0x49, 0x49, 0x7e,
-	0xb9, 0x27, 0x29, 0x9d, 0xbc, 0xee, 0x49, 0x2a, 0x47, 0x55, 0xce, 0x12, 0xf2, 0x61, 0xd5, 0x8d,
-	0x43, 0xe9, 0x3a, 0x61, 0x09, 0x54, 0xb2, 0xfb, 0x2e, 0x3f, 0xd9, 0x4f, 0x2b, 0x68, 0xde, 0x9e,
-	0xef, 0x17, 0xf0, 0x43, 0x5b, 0xa9, 0x5e, 0x34, 0xf9, 0xdf, 0xc9, 0x2f, 0xfe, 0x0d, 0x00, 0x00,
-	0xff, 0xff, 0xf9, 0x32, 0x44, 0xf7, 0x1f, 0x0f, 0x00, 0x00,
+	// 1157 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xdd, 0x6e, 0xe3, 0x44,
+	0x14, 0xae, 0xe3, 0xfc, 0x9e, 0x76, 0x4b, 0x3a, 0xfd, 0x73, 0x2d, 0x40, 0xc5, 0x08, 0x9a, 0x5d,
+	0xd8, 0x14, 0xc2, 0x15, 0x12, 0x42, 0xea, 0x76, 0xa3, 0xb6, 0x50, 0xba, 0x92, 0xb3, 0x5d, 0x24,
+	0x84, 0x88, 0xdc, 0x64, 0xd2, 0x5a, 0xeb, 0xd8, 0xc1, 0x33, 0x2e, 0xdb, 0x5b, 0xee, 0x78, 0x14,
+	0xc4, 0x4b, 0xf0, 0x04, 0x3c, 0x02, 0xcf, 0x82, 0xe6, 0xcf, 0xf5, 0xb8, 0x76, 0x6b, 0x7a, 0x13,
+	0xcf, 0xcc, 0x39, 0x73, 0x7e, 0xbe, 0x73, 0xe6, 0x9b, 0x09, 0xd8, 0x57, 0xde, 0xc2, 0xdf, 0x27,
+	0x38, 0xbe, 0xf6, 0x27, 0x98, 0xec, 0x53, 0x3f, 0x08, 0x70, 0xdc, 0x5f, 0xc4, 0x11, 0x8d, 0xd0,
+	0x06, 0x93, 0xf5, 0x95, 0xac, 0x2f, 0x64, 0xf6, 0x16, 0xdf, 0x31, 0xb9, 0xf2, 0x62, 0x2a, 0x7e,
+	0x85, 0xb6, 0xbd, 0x9d, 0x5d, 0x8f, 0xc2, 0x99, 0x7f, 0x29, 0x05, 0xc2, 0x45, 0x8c, 0x03, 0xec,
+	0x11, 0xac, 0xbe, 0xda, 0x26, 0x25, 0xf3, 0xc3, 0x59, 0x24, 0x05, 0x3b, 0x9a, 0x80, 0x50, 0x8f,
+	0x26, 0x44, 0xb3, 0x77, 0x8d, 0x63, 0xe2, 0x47, 0xa1, 0xfa, 0x0a, 0x99, 0xf3, 0x77, 0x0d, 0xd6,
+	0x4f, 0x7d, 0x42, 0x5d, 0xb1, 0x91, 0xb8, 0xf8, 0xd7, 0x04, 0x13, 0x8a, 0x36, 0xa0, 0x11, 0xf8,
+	0x73, 0x9f, 0x5a, 0xc6, 0xae, 0xd1, 0x33, 0x5d, 0x31, 0x41, 0x5b, 0xd0, 0x8c, 0x66, 0x33, 0x82,
+	0xa9, 0x55, 0xdb, 0x35, 0x7a, 0x1d, 0x57, 0xce, 0xd0, 0xb7, 0xd0, 0x22, 0x51, 0x4c, 0xc7, 0x17,
+	0x37, 0x96, 0xb9, 0x6b, 0xf4, 0x56, 0x07, 0x9f, 0xf4, 0x8b, 0xa0, 0xe8, 0x33, 0x4f, 0xa3, 0x28,
+	0xa6, 0x7d, 0xf6, 0xf3, 0xe2, 0xc6, 0x6d, 0x12, 0xfe, 0x65, 0x76, 0x67, 0x7e, 0x40, 0x71, 0x6c,
+	0xd5, 0x85, 0x5d, 0x31, 0x43, 0x47, 0x00, 0xdc, 0x6e, 0x14, 0x4f, 0x71, 0x6c, 0x35, 0xb8, 0xe9,
+	0x5e, 0x05, 0xd3, 0xaf, 0x98, 0xbe, 0xdb, 0x21, 0x6a, 0x88, 0xbe, 0x81, 0x15, 0x01, 0xc9, 0x78,
+	0x12, 0x4d, 0x31, 0xb1, 0x9a, 0xbb, 0x66, 0x6f, 0x75, 0xb0, 0x23, 0x4c, 0x29, 0x84, 0x47, 0x02,
+	0xb4, 0xc3, 0x68, 0x8a, 0xdd, 0x65, 0xa1, 0xce, 0xc6, 0x04, 0xbd, 0x0f, 0x9d, 0xd0, 0x9b, 0x63,
+	0xb2, 0xf0, 0x26, 0xd8, 0x6a, 0xf1, 0x08, 0x6f, 0x17, 0x9c, 0x5f, 0xa0, 0xad, 0x9c, 0x3b, 0x03,
+	0x68, 0x8a, 0xd4, 0xd0, 0x32, 0xb4, 0xce, 0xcf, 0xbe, 0x3f, 0x7b, 0xf5, 0xe3, 0x59, 0x77, 0x09,
+	0xb5, 0xa1, 0x7e, 0x76, 0xf0, 0xc3, 0xb0, 0x6b, 0xa0, 0x35, 0x78, 0x72, 0x7a, 0x30, 0x7a, 0x3d,
+	0x76, 0x87, 0xa7, 0xc3, 0x83, 0xd1, 0xf0, 0x65, 0xb7, 0xe6, 0x7c, 0x08, 0x9d, 0x34, 0x66, 0xd4,
+	0x02, 0xf3, 0x60, 0x74, 0x28, 0xb6, 0xbc, 0x1c, 0x8e, 0x0e, 0xbb, 0x86, 0xf3, 0x87, 0x01, 0x1b,
+	0x7a, 0x89, 0xc8, 0x22, 0x0a, 0x09, 0x66, 0x35, 0x9a, 0x44, 0x49, 0x98, 0xd6, 0x88, 0x4f, 0x10,
+	0x82, 0x7a, 0x88, 0xdf, 0xa9, 0x0a, 0xf1, 0x31, 0xd3, 0xa4, 0x11, 0xf5, 0x02, 0x5e, 0x1d, 0xd3,
+	0x15, 0x13, 0xf4, 0x25, 0xb4, 0x65, 0xea, 0xc4, 0xaa, 0xef, 0x9a, 0xbd, 0xe5, 0xc1, 0xa6, 0x0e,
+	0x88, 0xf4, 0xe8, 0xa6, 0x6a, 0xce, 0x11, 0x6c, 0x1f, 0x61, 0x15, 0x89, 0xc0, 0x4b, 0x75, 0x0c,
+	0xf3, 0xeb, 0xcd, 0x31, 0x0f, 0x86, 0xf9, 0xf5, 0xe6, 0x18, 0x59, 0xd0, 0x92, 0xed, 0xc6, 0xc3,
+	0x69, 0xb8, 0x6a, 0xea, 0x50, 0xb0, 0xee, 0x1a, 0x92, 0x79, 0x15, 0x59, 0xfa, 0x14, 0xea, 0xac,
+	0xd9, 0xb9, 0x99, 0xe5, 0x01, 0xd2, 0xe3, 0x3c, 0x09, 0x67, 0x91, 0xcb, 0xe5, 0x7a, 0xa9, 0xcc,
+	0x7c, 0xa9, 0x8e, 0xb3, 0x5e, 0x0f, 0xa3, 0x90, 0xe2, 0x90, 0x3e, 0x2e, 0xfe, 0x53, 0xd8, 0x29,
+	0xb0, 0x24, 0x13, 0xd8, 0x87, 0x96, 0x0c, 0x8d, 0x5b, 0x2b, 0xc5, 0x55, 0x69, 0x39, 0x7f, 0xd5,
+	0x60, 0xf3, 0x7c, 0x71, 0x19, 0x7b, 0x53, 0xac, 0x64, 0xf7, 0x44, 0xb5, 0x07, 0x0d, 0xce, 0x1a,
+	0x12, 0x8c, 0x35, 0x61, 0x5c, 0x50, 0xcb, 0x21, 0xfb, 0x75, 0x85, 0x1c, 0x3d, 0x83, 0xe6, 0xb5,
+	0x17, 0x24, 0x98, 0x70, 0x24, 0x52, 0xd8, 0xa4, 0x26, 0xa7, 0x1c, 0x57, 0x6a, 0xa0, 0x6d, 0x68,
+	0x4d, 0xe3, 0x9b, 0x71, 0x9c, 0x84, 0xfc, 0x0c, 0xb6, 0xdd, 0xe6, 0x34, 0xbe, 0x71, 0x93, 0x10,
+	0x7d, 0x0c, 0x4f, 0xa6, 0x3e, 0xf1, 0x2e, 0x02, 0x3c, 0xbe, 0x8a, 0xa2, 0xb7, 0x84, 0x1f, 0xc3,
+	0xb6, 0xbb, 0x22, 0x17, 0x8f, 0xd9, 0x1a, 0xb2, 0x59, 0x2b, 0x4d, 0x62, 0xec, 0x51, 0x6c, 0x35,
+	0xb9, 0x3c, 0x9d, 0x33, 0x10, 0xa9, 0x3f, 0xc7, 0x51, 0x42, 0xf9, 0xd9, 0x31, 0x5d, 0x35, 0x45,
+	0x1f, 0xc1, 0x4a, 0x8c, 0x09, 0xa6, 0x63, 0x19, 0x65, 0x9b, 0xef, 0x5c, 0xe6, 0x6b, 0x6f, 0x44,
+	0x58, 0x08, 0xea, 0xbf, 0x79, 0x3e, 0xb5, 0x3a, 0x5c, 0xc4, 0xc7, 0xce, 0x09, 0x6c, 0xe5, 0xc1,
+	0x7a, 0x2c, 0xf0, 0xff, 0x18, 0xb0, 0xe5, 0x46, 0x41, 0x70, 0xe1, 0x4d, 0xde, 0x56, 0x40, 0x3e,
+	0x03, 0x52, 0xed, 0x7e, 0x90, 0xcc, 0x02, 0x90, 0x32, 0xdd, 0x54, 0xd7, 0xba, 0x49, 0x83, 0xaf,
+	0x51, 0x0e, 0x5f, 0x53, 0x87, 0x4f, 0x61, 0xd3, 0xca, 0x60, 0xf3, 0x1d, 0x6c, 0xdf, 0xc9, 0xe7,
+	0xb1, 0xe0, 0xfc, 0x59, 0x83, 0xcd, 0x93, 0x90, 0x50, 0x2f, 0x08, 0x72, 0xd8, 0xa4, 0x1d, 0x68,
+	0x54, 0xee, 0xc0, 0xda, 0xff, 0xe9, 0x40, 0x53, 0x03, 0x57, 0x55, 0xa2, 0x9e, 0xa9, 0x44, 0xa5,
+	0xae, 0xd4, 0xc8, 0xa0, 0x99, 0x23, 0x03, 0xf4, 0x01, 0x40, 0x8c, 0x13, 0x82, 0xc7, 0xdc, 0xb8,
+	0x00, 0xb1, 0xc3, 0x57, 0xce, 0xe4, 0xd9, 0x57, 0xb8, 0xb7, 0x8b, 0x71, 0xcf, 0xf5, 0x64, 0x1e,
+	0xaa, 0xc7, 0xc2, 0xfe, 0xbb, 0x01, 0xdb, 0xe7, 0xa1, 0x5f, 0x08, 0x7c, 0x51, 0x53, 0xde, 0x81,
+	0xa2, 0x56, 0x00, 0xc5, 0x06, 0x34, 0x16, 0x49, 0x7c, 0x89, 0x25, 0xb4, 0x62, 0x92, 0xcd, 0xb1,
+	0xae, 0xe5, 0xe8, 0x8c, 0xc1, 0xba, 0x1b, 0xc3, 0x23, 0x33, 0x62, 0x51, 0xa7, 0xe4, 0xdd, 0x11,
+	0x44, 0xed, 0xac, 0xc3, 0xda, 0x11, 0xa6, 0x6f, 0xc4, 0x01, 0x90, 0xe9, 0x39, 0x43, 0x40, 0xd9,
+	0xc5, 0x5b, 0x7f, 0x72, 0x49, 0xf7, 0xa7, 0x5e, 0x32, 0x4a, 0x5f, 0x69, 0x39, 0x5f, 0x73, 0xdb,
+	0xc7, 0x3e, 0xa1, 0x51, 0x7c, 0x73, 0x1f, 0x74, 0x5d, 0x30, 0xe7, 0xde, 0x3b, 0xc9, 0xed, 0x6c,
+	0xe8, 0x1c, 0xf1, 0x08, 0xd2, 0xad, 0x32, 0x82, 0xec, 0x4d, 0x69, 0x54, 0xbb, 0x29, 0x7f, 0x06,
+	0xf4, 0x1a, 0xa7, 0x97, 0xf6, 0x03, 0x97, 0x8c, 0x2a, 0x42, 0x4d, 0x6f, 0x34, 0x0b, 0x5a, 0x93,
+	0x00, 0x7b, 0x61, 0xb2, 0x90, 0x65, 0x53, 0x53, 0x67, 0x0f, 0xd6, 0x35, 0xeb, 0x32, 0x4e, 0x96,
+	0x0f, 0xb9, 0x94, 0xd6, 0xd9, 0x70, 0xf0, 0x6f, 0x1b, 0x56, 0xd5, 0x2d, 0x2b, 0x5e, 0x4c, 0xc8,
+	0x87, 0x95, 0xec, 0x73, 0x02, 0x3d, 0x2d, 0x7f, 0x50, 0xe5, 0x5e, 0x85, 0xf6, 0xb3, 0x2a, 0xaa,
+	0x22, 0x16, 0x67, 0xe9, 0x0b, 0x03, 0x11, 0xe8, 0xe6, 0x6f, 0x79, 0xf4, 0xbc, 0xd8, 0x46, 0xc9,
+	0xb3, 0xc2, 0xee, 0x57, 0x55, 0x57, 0x6e, 0xd1, 0x35, 0xaf, 0xbe, 0x7e, 0x35, 0xa3, 0x07, 0xcd,
+	0xe8, 0xaf, 0x01, 0x7b, 0xbf, 0xb2, 0x7e, 0xea, 0x77, 0x0e, 0xab, 0xfa, 0xb5, 0x84, 0x3e, 0x2b,
+	0x36, 0x52, 0x78, 0xd3, 0xdb, 0x9f, 0x57, 0x53, 0xce, 0xba, 0xd3, 0x19, 0xa7, 0xcc, 0x5d, 0x21,
+	0x85, 0x97, 0xb9, 0x2b, 0x26, 0x31, 0x67, 0x89, 0x95, 0x32, 0x4f, 0x08, 0x65, 0xa5, 0x2c, 0x21,
+	0xaf, 0xb2, 0x52, 0x96, 0xf1, 0x8c, 0xb3, 0x84, 0x3c, 0x80, 0x5b, 0x3e, 0x40, 0x7b, 0xa5, 0x35,
+	0xd1, 0x69, 0xc4, 0xee, 0x3d, 0xac, 0x98, 0xba, 0x58, 0xc0, 0x7b, 0xb9, 0x0b, 0x13, 0x95, 0x40,
+	0x53, 0xfc, 0x4e, 0xb0, 0x9f, 0x57, 0xd4, 0xce, 0x25, 0x25, 0x29, 0xe6, 0x9e, 0xa4, 0x74, 0xfe,
+	0xba, 0x27, 0xa9, 0x1c, 0x5b, 0x39, 0x4b, 0xc8, 0x87, 0x55, 0x37, 0x09, 0xa5, 0x6b, 0x46, 0x14,
+	0xa8, 0x64, 0xf7, 0x5d, 0x8a, 0xb2, 0x9f, 0x56, 0xd0, 0xbc, 0x3d, 0xe2, 0x2f, 0xe0, 0xa7, 0xb6,
+	0x52, 0xbd, 0x68, 0xf2, 0xff, 0x94, 0x5f, 0xfd, 0x17, 0x00, 0x00, 0xff, 0xff, 0x94, 0x53, 0x5a,
+	0x6a, 0x24, 0x0f, 0x00, 0x00,
 }
diff --git a/pkg/proto/hapi/version/version.pb.go b/pkg/proto/hapi/version/version.pb.go
index 79771408e..adbee1a33 100644
--- a/pkg/proto/hapi/version/version.pb.go
+++ b/pkg/proto/hapi/version/version.pb.go
@@ -48,7 +48,7 @@ func init() { proto.RegisterFile("hapi/version/version.proto", fileDescriptor0)
 
 var fileDescriptor0 = []byte{
 	// 151 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xca, 0x48, 0x2c, 0xc8,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
diff --git a/pkg/storage/driver/cfgmaps.go b/pkg/storage/driver/cfgmaps.go
index 1e4ef2e91..5e574dfae 100644
--- a/pkg/storage/driver/cfgmaps.go
+++ b/pkg/storage/driver/cfgmaps.go
@@ -178,9 +178,9 @@ func (cfgmaps *ConfigMaps) Create(key string, rls *rspb.Release) error {
 	return nil
 }
 
-// Update updates the ConfigMap holding the release. If not found
+// Upgrade upgrades the ConfigMap holding the release. If not found
 // the ConfigMap is created to hold the release.
-func (cfgmaps *ConfigMaps) Update(key string, rls *rspb.Release) error {
+func (cfgmaps *ConfigMaps) Upgrade(key string, rls *rspb.Release) error {
 	// set labels for configmaps object meta data
 	var lbs labels
 
@@ -190,13 +190,13 @@ func (cfgmaps *ConfigMaps) Update(key string, rls *rspb.Release) error {
 	// create a new configmap object to hold the release
 	obj, err := newConfigMapsObject(key, rls, lbs)
 	if err != nil {
-		logerrf(err, "update: failed to encode release %q", rls.Name)
+		logerrf(err, "upgrade: failed to encode release %q", rls.Name)
 		return err
 	}
 	// push the configmap object out into the kubiverse
 	_, err = cfgmaps.impl.Update(obj)
 	if err != nil {
-		logerrf(err, "update: failed to update")
+		logerrf(err, "upgrade: failed to upgrade")
 		return err
 	}
 	return nil
@@ -226,7 +226,7 @@ func (cfgmaps *ConfigMaps) Delete(key string) (rls *rspb.Release, err error) {
 //
 // The following labels are used within each configmap:
 //
-//    "MODIFIED_AT"    - timestamp indicating when this configmap was last modified. (set in Update)
+//    "MODIFIED_AT"    - timestamp indicating when this configmap was last modified. (set in Upgrade)
 //    "CREATED_AT"     - timestamp indicating when this configmap was created. (set in Create)
 //    "VERSION"        - version of the release.
 //    "STATUS"         - status of the release (see proto/hapi/release.status.pb.go for variants)
diff --git a/pkg/storage/driver/cfgmaps_test.go b/pkg/storage/driver/cfgmaps_test.go
index 84a933811..ce806e514 100644
--- a/pkg/storage/driver/cfgmaps_test.go
+++ b/pkg/storage/driver/cfgmaps_test.go
@@ -156,7 +156,7 @@ func TestConfigMapCreate(t *testing.T) {
 	}
 }
 
-func TestConfigMapUpdate(t *testing.T) {
+func TestConfigMapUpgrade(t *testing.T) {
 	vers := int32(1)
 	name := "smug-pigeon"
 	namespace := "default"
@@ -169,7 +169,7 @@ func TestConfigMapUpdate(t *testing.T) {
 	rel.Info.Status.Code = rspb.Status_SUPERSEDED
 
 	// perform the update
-	if err := cfgmaps.Update(key, rel); err != nil {
+	if err := cfgmaps.Upgrade(key, rel); err != nil {
 		t.Fatalf("Failed to update release: %s", err)
 	}
 
diff --git a/pkg/storage/driver/driver.go b/pkg/storage/driver/driver.go
index 45b442cd7..c98435f97 100644
--- a/pkg/storage/driver/driver.go
+++ b/pkg/storage/driver/driver.go
@@ -39,12 +39,12 @@ type Creator interface {
 	Create(key string, rls *rspb.Release) error
 }
 
-// Updator is the interface that wraps the Update method.
+// Upgrador is the interface that wraps the Upgrade method.
 //
-// Update updates an existing release or returns
+// Upgrade upgrades an existing release or returns
 // ErrReleaseNotFound if the release does not exist.
-type Updator interface {
-	Update(key string, rls *rspb.Release) error
+type Upgrador interface {
+	Upgrade(key string, rls *rspb.Release) error
 }
 
 // Deletor is the interface that wraps the Delete method.
@@ -69,13 +69,13 @@ type Queryor interface {
 	Query(labels map[string]string) ([]*rspb.Release, error)
 }
 
-// Driver is the interface composed of Creator, Updator, Deletor, Queryor
+// Driver is the interface composed of Creator, Upgrador, Deletor, Queryor
 // interfaces. It defines the behavior for storing, updating, deleted,
 // and retrieving tiller releases from some underlying storage mechanism,
 // e.g. memory, configmaps.
 type Driver interface {
 	Creator
-	Updator
+	Upgrador
 	Deletor
 	Queryor
 	Name() string
diff --git a/pkg/storage/driver/memory.go b/pkg/storage/driver/memory.go
index 4dea98ed8..f9b857b09 100644
--- a/pkg/storage/driver/memory.go
+++ b/pkg/storage/driver/memory.go
@@ -118,8 +118,8 @@ func (mem *Memory) Create(key string, rls *rspb.Release) error {
 	return nil
 }
 
-// Update updates a release or returns ErrReleaseNotFound.
-func (mem *Memory) Update(key string, rls *rspb.Release) error {
+// Upgrade upgrades a release or returns ErrReleaseNotFound.
+func (mem *Memory) Upgrade(key string, rls *rspb.Release) error {
 	defer unlock(mem.wlock())
 
 	if rs, ok := mem.cache[rls.Name]; ok && rs.Exists(key) {
diff --git a/pkg/storage/driver/memory_test.go b/pkg/storage/driver/memory_test.go
index 51f942992..24a88e45a 100644
--- a/pkg/storage/driver/memory_test.go
+++ b/pkg/storage/driver/memory_test.go
@@ -106,7 +106,7 @@ func TestMemoryQuery(t *testing.T) {
 	}
 }
 
-func TestMemoryUpdate(t *testing.T) {
+func TestMemoryUpgrade(t *testing.T) {
 	var tests = []struct {
 		desc string
 		key  string
@@ -129,7 +129,7 @@ func TestMemoryUpdate(t *testing.T) {
 
 	ts := tsFixtureMemory(t)
 	for _, tt := range tests {
-		if err := ts.Update(tt.key, tt.rls); err != nil {
+		if err := ts.Upgrade(tt.key, tt.rls); err != nil {
 			if !tt.err {
 				t.Fatalf("Failed %q: %s\n", tt.desc, err)
 			}
diff --git a/pkg/storage/storage.go b/pkg/storage/storage.go
index a10f377da..35d3bc5ff 100644
--- a/pkg/storage/storage.go
+++ b/pkg/storage/storage.go
@@ -46,12 +46,12 @@ func (s *Storage) Create(rls *rspb.Release) error {
 	return s.Driver.Create(makeKey(rls.Name, rls.Version), rls)
 }
 
-// Update update the release in storage. An error is returned if the
-// storage backend fails to update the release or if the release
+// Upgrade upgrades the release in storage. An error is returned if the
+// storage backend fails to upgrade the release or if the release
 // does not exist.
-func (s *Storage) Update(rls *rspb.Release) error {
+func (s *Storage) Upgrade(rls *rspb.Release) error {
 	log.Printf("Updating %q (v%d) in storage\n", rls.Name, rls.Version)
-	return s.Driver.Update(makeKey(rls.Name, rls.Version), rls)
+	return s.Driver.Upgrade(makeKey(rls.Name, rls.Version), rls)
 }
 
 // Delete deletes the release from storage. An error is returned if
diff --git a/pkg/storage/storage_test.go b/pkg/storage/storage_test.go
index 141a019fa..21d598c11 100644
--- a/pkg/storage/storage_test.go
+++ b/pkg/storage/storage_test.go
@@ -47,7 +47,7 @@ func TestStorageCreate(t *testing.T) {
 	}
 }
 
-func TestStorageUpdate(t *testing.T) {
+func TestStorageUpgrade(t *testing.T) {
 	// initialize storage
 	storage := Init(driver.NewMemory())
 
@@ -62,9 +62,9 @@ func TestStorageUpdate(t *testing.T) {
 
 	// modify the release
 	rls.Info.Status.Code = rspb.Status_DELETED
-	assertErrNil(t.Fatal, storage.Update(rls), "UpdateRelease")
+	assertErrNil(t.Fatal, storage.Upgrade(rls), "UpgradeRelease")
 
-	// retrieve the updated release
+	// retrieve the upgraded release
 	res, err := storage.Get(rls.Name, rls.Version)
 	assertErrNil(t.Fatal, err, "QueryRelease")
 
diff --git a/pkg/tiller/release_server.go b/pkg/tiller/release_server.go
index 873d2335a..a8313f7fd 100644
--- a/pkg/tiller/release_server.go
+++ b/pkg/tiller/release_server.go
@@ -282,20 +282,20 @@ func (s *ReleaseServer) GetReleaseContent(c ctx.Context, req *services.GetReleas
 	return &services.GetReleaseContentResponse{Release: rel}, err
 }
 
-// UpdateRelease takes an existing release and new information, and upgrades the release.
-func (s *ReleaseServer) UpdateRelease(c ctx.Context, req *services.UpdateReleaseRequest) (*services.UpdateReleaseResponse, error) {
-	currentRelease, updatedRelease, err := s.prepareUpdate(req)
+// UpgradeRelease takes an existing release and new information, and upgrades the release.
+func (s *ReleaseServer) UpgradeRelease(c ctx.Context, req *services.UpgradeReleaseRequest) (*services.UpgradeReleaseResponse, error) {
+	currentRelease, upgradedRelease, err := s.prepareUpgrade(req)
 	if err != nil {
 		return nil, err
 	}
 
-	res, err := s.performUpdate(currentRelease, updatedRelease, req)
+	res, err := s.performUpgrade(currentRelease, upgradedRelease, req)
 	if err != nil {
 		return res, err
 	}
 
 	if !req.DryRun {
-		if err := s.env.Releases.Create(updatedRelease); err != nil {
+		if err := s.env.Releases.Create(upgradedRelease); err != nil {
 			return res, err
 		}
 	}
@@ -303,36 +303,36 @@ func (s *ReleaseServer) UpdateRelease(c ctx.Context, req *services.UpdateRelease
 	return res, nil
 }
 
-func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.Release, req *services.UpdateReleaseRequest) (*services.UpdateReleaseResponse, error) {
-	res := &services.UpdateReleaseResponse{Release: updatedRelease}
+func (s *ReleaseServer) performUpgrade(originalRelease, upgradedRelease *release.Release, req *services.UpgradeReleaseRequest) (*services.UpgradeReleaseResponse, error) {
+	res := &services.UpgradeReleaseResponse{Release: upgradedRelease}
 
 	if req.DryRun {
-		log.Printf("Dry run for %s", updatedRelease.Name)
+		log.Printf("Dry run for %s", upgradedRelease.Name)
 		res.Release.Info.Description = "Dry run complete"
 		return res, nil
 	}
 
 	// pre-upgrade hooks
 	if !req.DisableHooks {
-		if err := s.execHook(updatedRelease.Hooks, updatedRelease.Name, updatedRelease.Namespace, hooks.PreUpgrade, req.Timeout); err != nil {
+		if err := s.execHook(upgradedRelease.Hooks, upgradedRelease.Name, upgradedRelease.Namespace, hooks.PreUpgrade, req.Timeout); err != nil {
 			return res, err
 		}
 	}
 
-	if err := s.performKubeUpdate(originalRelease, updatedRelease, req.Recreate, req.Timeout, req.Wait); err != nil {
-		msg := fmt.Sprintf("Upgrade %q failed: %s", updatedRelease.Name, err)
+	if err := s.performKubeUpgrade(originalRelease, upgradedRelease, req.Recreate, req.Timeout, req.Wait); err != nil {
+		msg := fmt.Sprintf("Upgrade %q failed: %s", upgradedRelease.Name, err)
 		log.Printf("warning: %s", msg)
 		originalRelease.Info.Status.Code = release.Status_SUPERSEDED
-		updatedRelease.Info.Status.Code = release.Status_FAILED
-		updatedRelease.Info.Description = msg
+		upgradedRelease.Info.Status.Code = release.Status_FAILED
+		upgradedRelease.Info.Description = msg
 		s.recordRelease(originalRelease, true)
-		s.recordRelease(updatedRelease, false)
+		s.recordRelease(upgradedRelease, false)
 		return res, err
 	}
 
 	// post-upgrade hooks
 	if !req.DisableHooks {
-		if err := s.execHook(updatedRelease.Hooks, updatedRelease.Name, updatedRelease.Namespace, hooks.PostUpgrade, req.Timeout); err != nil {
+		if err := s.execHook(upgradedRelease.Hooks, upgradedRelease.Name, upgradedRelease.Namespace, hooks.PostUpgrade, req.Timeout); err != nil {
 			return res, err
 		}
 	}
@@ -340,8 +340,8 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
 	originalRelease.Info.Status.Code = release.Status_SUPERSEDED
 	s.recordRelease(originalRelease, true)
 
-	updatedRelease.Info.Status.Code = release.Status_DEPLOYED
-	updatedRelease.Info.Description = "Upgrade complete"
+	upgradedRelease.Info.Status.Code = release.Status_DEPLOYED
+	upgradedRelease.Info.Description = "Upgrade complete"
 
 	return res, nil
 }
@@ -354,7 +354,7 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
 //
 // This is skipped if the req.ResetValues flag is set, in which case the
 // request values are not altered.
-func (s *ReleaseServer) reuseValues(req *services.UpdateReleaseRequest, current *release.Release) {
+func (s *ReleaseServer) reuseValues(req *services.UpgradeReleaseRequest, current *release.Release) {
 	if req.ResetValues {
 		// If ResetValues is set, we comletely ignore current.Config.
 		log.Print("Reset values to the chart's original version.")
@@ -371,8 +371,8 @@ func (s *ReleaseServer) reuseValues(req *services.UpdateReleaseRequest, current
 	}
 }
 
-// prepareUpdate builds an updated release for an update operation.
-func (s *ReleaseServer) prepareUpdate(req *services.UpdateReleaseRequest) (*release.Release, *release.Release, error) {
+// prepareUpgrade builds an upgraded release for an upgrade operation.
+func (s *ReleaseServer) prepareUpgrade(req *services.UpgradeReleaseRequest) (*release.Release, *release.Release, error) {
 	if !ValidName.MatchString(req.Name) {
 		return nil, nil, errMissingRelease
 	}
@@ -417,8 +417,8 @@ func (s *ReleaseServer) prepareUpdate(req *services.UpdateReleaseRequest) (*rele
 		return nil, nil, err
 	}
 
-	// Store an updated release.
-	updatedRelease := &release.Release{
+	// Store an upgraded release.
+	upgradedRelease := &release.Release{
 		Name:      req.Name,
 		Namespace: currentRelease.Namespace,
 		Chart:     req.Chart,
@@ -435,10 +435,10 @@ func (s *ReleaseServer) prepareUpdate(req *services.UpdateReleaseRequest) (*rele
 	}
 
 	if len(notesTxt) > 0 {
-		updatedRelease.Info.Status.Notes = notesTxt
+		upgradedRelease.Info.Status.Notes = notesTxt
 	}
 	err = validateManifest(s.env.KubeClient, currentRelease.Namespace, manifestDoc.Bytes())
-	return currentRelease, updatedRelease, err
+	return currentRelease, upgradedRelease, err
 }
 
 // RollbackRelease rolls back to a previous version of the given release.
@@ -477,7 +477,7 @@ func (s *ReleaseServer) performRollback(currentRelease, targetRelease *release.R
 		}
 	}
 
-	if err := s.performKubeUpdate(currentRelease, targetRelease, req.Recreate, req.Timeout, req.Wait); err != nil {
+	if err := s.performKubeUpgrade(currentRelease, targetRelease, req.Recreate, req.Timeout, req.Wait); err != nil {
 		msg := fmt.Sprintf("Rollback %q failed: %s", targetRelease.Name, err)
 		log.Printf("warning: %s", msg)
 		currentRelease.Info.Status.Code = release.Status_SUPERSEDED
@@ -503,7 +503,7 @@ func (s *ReleaseServer) performRollback(currentRelease, targetRelease *release.R
 	return res, nil
 }
 
-func (s *ReleaseServer) performKubeUpdate(currentRelease, targetRelease *release.Release, recreate bool, timeout int64, shouldWait bool) error {
+func (s *ReleaseServer) performKubeUpgrade(currentRelease, targetRelease *release.Release, recreate bool, timeout int64, shouldWait bool) error {
 	kubeCli := s.env.KubeClient
 	current := bytes.NewBufferString(currentRelease.Manifest)
 	target := bytes.NewBufferString(targetRelease.Manifest)
@@ -810,8 +810,8 @@ func (s *ReleaseServer) renderResources(ch *chart.Chart, values chartutil.Values
 
 func (s *ReleaseServer) recordRelease(r *release.Release, reuse bool) {
 	if reuse {
-		if err := s.env.Releases.Update(r); err != nil {
-			log.Printf("warning: Failed to update release %q: %s", r.Name, err)
+		if err := s.env.Releases.Upgrade(r); err != nil {
+			log.Printf("warning: Failed to upgrade release %q: %s", r.Name, err)
 		}
 	} else if err := s.env.Releases.Create(r); err != nil {
 		log.Printf("warning: Failed to record release %q: %s", r.Name, err)
@@ -844,15 +844,15 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
 		// old release
 		old := h[0]
 
-		// update old release status
+		// upgrade old release status
 		old.Info.Status.Code = release.Status_SUPERSEDED
 		s.recordRelease(old, true)
 
-		// update new release with next revision number
+		// upgrade new release with next revision number
 		// so as to append to the old release's history
 		r.Version = old.Version + 1
 
-		if err := s.performKubeUpdate(old, r, false, req.Timeout, req.Wait); err != nil {
+		if err := s.performKubeUpgrade(old, r, false, req.Timeout, req.Wait); err != nil {
 			msg := fmt.Sprintf("Release replace %q failed: %s", r.Name, err)
 			log.Printf("warning: %s", msg)
 			old.Info.Status.Code = release.Status_SUPERSEDED
@@ -1005,8 +1005,8 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
 
 	// From here on out, the release is currently considered to be in Status_DELETING
 	// state.
-	if err := s.env.Releases.Update(rel); err != nil {
-		log.Printf("uninstall: Failed to store updated release: %s", err)
+	if err := s.env.Releases.Upgrade(rel); err != nil {
+		log.Printf("uninstall: Failed to store upgraded release: %s", err)
 	}
 
 	manifests := relutil.SplitManifests(rel.Manifest)
@@ -1055,8 +1055,8 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
 		return res, err
 	}
 
-	if err := s.env.Releases.Update(rel); err != nil {
-		log.Printf("uninstall: Failed to store updated release: %s", err)
+	if err := s.env.Releases.Upgrade(rel); err != nil {
+		log.Printf("uninstall: Failed to store upgraded release: %s", err)
 	}
 
 	if len(es) > 0 {
@@ -1112,5 +1112,5 @@ func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream
 		testEnv.DeleteTestPods(tSuite.TestManifests)
 	}
 
-	return s.env.Releases.Update(rel)
+	return s.env.Releases.Upgrade(rel)
 }
diff --git a/pkg/tiller/release_server_test.go b/pkg/tiller/release_server_test.go
index 185ef05e7..b20e782ae 100644
--- a/pkg/tiller/release_server_test.go
+++ b/pkg/tiller/release_server_test.go
@@ -637,13 +637,13 @@ func TestInstallReleaseReuseName(t *testing.T) {
 	}
 }
 
-func TestUpdateRelease(t *testing.T) {
+func TestUpgradeRelease(t *testing.T) {
 	c := helm.NewContext()
 	rs := rsFixture()
 	rel := releaseStub()
 	rs.env.Releases.Create(rel)
 
-	req := &services.UpdateReleaseRequest{
+	req := &services.UpgradeReleaseRequest{
 		Name: rel.Name,
 		Chart: &chart.Chart{
 			Metadata: &chart.Metadata{Name: "hello"},
@@ -653,9 +653,9 @@ func TestUpdateRelease(t *testing.T) {
 			},
 		},
 	}
-	res, err := rs.UpdateRelease(c, req)
+	res, err := rs.UpgradeRelease(c, req)
 	if err != nil {
-		t.Fatalf("Failed updated: %s", err)
+		t.Fatalf("Failed upgraded: %s", err)
 	}
 
 	if res.Release.Name == "" {
@@ -663,30 +663,30 @@ func TestUpdateRelease(t *testing.T) {
 	}
 
 	if res.Release.Name != rel.Name {
-		t.Errorf("Updated release name does not match previous release name. Expected %s, got %s", rel.Name, res.Release.Name)
+		t.Errorf("Upgraded release name does not match previous release name. Expected %s, got %s", rel.Name, res.Release.Name)
 	}
 
 	if res.Release.Namespace != rel.Namespace {
 		t.Errorf("Expected release namespace '%s', got '%s'.", rel.Namespace, res.Release.Namespace)
 	}
 
-	updated, err := rs.env.Releases.Get(res.Release.Name, res.Release.Version)
+	upgraded, err := rs.env.Releases.Get(res.Release.Name, res.Release.Version)
 	if err != nil {
 		t.Errorf("Expected release for %s (%v).", res.Release.Name, rs.env.Releases)
 	}
 
-	if len(updated.Hooks) != 1 {
-		t.Fatalf("Expected 1 hook, got %d", len(updated.Hooks))
+	if len(upgraded.Hooks) != 1 {
+		t.Fatalf("Expected 1 hook, got %d", len(upgraded.Hooks))
 	}
-	if updated.Hooks[0].Manifest != manifestWithUpgradeHooks {
-		t.Errorf("Unexpected manifest: %v", updated.Hooks[0].Manifest)
+	if upgraded.Hooks[0].Manifest != manifestWithUpgradeHooks {
+		t.Errorf("Unexpected manifest: %v", upgraded.Hooks[0].Manifest)
 	}
 
-	if updated.Hooks[0].Events[0] != release.Hook_POST_UPGRADE {
+	if upgraded.Hooks[0].Events[0] != release.Hook_POST_UPGRADE {
 		t.Errorf("Expected event 0 to be post upgrade")
 	}
 
-	if updated.Hooks[0].Events[1] != release.Hook_PRE_UPGRADE {
+	if upgraded.Hooks[0].Events[1] != release.Hook_PRE_UPGRADE {
 		t.Errorf("Expected event 0 to be pre upgrade")
 	}
 
@@ -700,11 +700,11 @@ func TestUpdateRelease(t *testing.T) {
 		t.Errorf("Expected release values %q, got %q", rel.Config.Raw, res.Release.Config.Raw)
 	}
 
-	if len(updated.Manifest) == 0 {
+	if len(upgraded.Manifest) == 0 {
 		t.Errorf("Expected manifest in %v", res)
 	}
 
-	if !strings.Contains(updated.Manifest, "---\n# Source: hello/templates/hello\nhello: world") {
+	if !strings.Contains(upgraded.Manifest, "---\n# Source: hello/templates/hello\nhello: world") {
 		t.Errorf("unexpected output: %s", rel.Manifest)
 	}
 
@@ -717,13 +717,13 @@ func TestUpdateRelease(t *testing.T) {
 		t.Errorf("Expected description %q, got %q", edesc, got)
 	}
 }
-func TestUpdateReleaseResetValues(t *testing.T) {
+func TestUpgradeReleaseResetValues(t *testing.T) {
 	c := helm.NewContext()
 	rs := rsFixture()
 	rel := releaseStub()
 	rs.env.Releases.Create(rel)
 
-	req := &services.UpdateReleaseRequest{
+	req := &services.UpgradeReleaseRequest{
 		Name: rel.Name,
 		Chart: &chart.Chart{
 			Metadata: &chart.Metadata{Name: "hello"},
@@ -734,9 +734,9 @@ func TestUpdateReleaseResetValues(t *testing.T) {
 		},
 		ResetValues: true,
 	}
-	res, err := rs.UpdateRelease(c, req)
+	res, err := rs.UpgradeRelease(c, req)
 	if err != nil {
-		t.Fatalf("Failed updated: %s", err)
+		t.Fatalf("Failed upgraded: %s", err)
 	}
 	// This should have been unset. Config:  &chart.Config{Raw: `name: value`},
 	if res.Release.Config != nil && res.Release.Config.Raw != "" {
@@ -744,14 +744,14 @@ func TestUpdateReleaseResetValues(t *testing.T) {
 	}
 }
 
-func TestUpdateReleaseFailure(t *testing.T) {
+func TestUpgradeReleaseFailure(t *testing.T) {
 	c := helm.NewContext()
 	rs := rsFixture()
 	rel := releaseStub()
 	rs.env.Releases.Create(rel)
-	rs.env.KubeClient = newUpdateFailingKubeClient()
+	rs.env.KubeClient = newUpgradeFailingKubeClient()
 
-	req := &services.UpdateReleaseRequest{
+	req := &services.UpgradeReleaseRequest{
 		Name:         rel.Name,
 		DisableHooks: true,
 		Chart: &chart.Chart{
@@ -762,16 +762,16 @@ func TestUpdateReleaseFailure(t *testing.T) {
 		},
 	}
 
-	res, err := rs.UpdateRelease(c, req)
+	res, err := rs.UpgradeRelease(c, req)
 	if err == nil {
-		t.Error("Expected failed update")
+		t.Error("Expected failed upgrade")
 	}
 
-	if updatedStatus := res.Release.Info.Status.Code; updatedStatus != release.Status_FAILED {
-		t.Errorf("Expected FAILED release. Got %d", updatedStatus)
+	if upgradedStatus := res.Release.Info.Status.Code; upgradedStatus != release.Status_FAILED {
+		t.Errorf("Expected FAILED release. Got %d", upgradedStatus)
 	}
 
-	edesc := "Upgrade \"angry-panda\" failed: Failed update in kube client"
+	edesc := "Upgrade \"angry-panda\" failed: Failed upgrade in kube client"
 	if got := res.Release.Info.Description; got != edesc {
 		t.Errorf("Expected description %q, got %q", edesc, got)
 	}
@@ -791,7 +791,7 @@ func TestRollbackReleaseFailure(t *testing.T) {
 	rel := releaseStub()
 	rs.env.Releases.Create(rel)
 	upgradedRel := upgradeReleaseVersion(rel)
-	rs.env.Releases.Update(rel)
+	rs.env.Releases.Upgrade(rel)
 	rs.env.Releases.Create(upgradedRel)
 
 	req := &services.RollbackReleaseRequest{
@@ -799,7 +799,7 @@ func TestRollbackReleaseFailure(t *testing.T) {
 		DisableHooks: true,
 	}
 
-	rs.env.KubeClient = newUpdateFailingKubeClient()
+	rs.env.KubeClient = newUpgradeFailingKubeClient()
 	res, err := rs.RollbackRelease(c, req)
 	if err == nil {
 		t.Error("Expected failed rollback")
@@ -818,13 +818,13 @@ func TestRollbackReleaseFailure(t *testing.T) {
 	}
 }
 
-func TestUpdateReleaseNoHooks(t *testing.T) {
+func TestUpgradeReleaseNoHooks(t *testing.T) {
 	c := helm.NewContext()
 	rs := rsFixture()
 	rel := releaseStub()
 	rs.env.Releases.Create(rel)
 
-	req := &services.UpdateReleaseRequest{
+	req := &services.UpgradeReleaseRequest{
 		Name:         rel.Name,
 		DisableHooks: true,
 		Chart: &chart.Chart{
@@ -836,9 +836,9 @@ func TestUpdateReleaseNoHooks(t *testing.T) {
 		},
 	}
 
-	res, err := rs.UpdateRelease(c, req)
+	res, err := rs.UpgradeRelease(c, req)
 	if err != nil {
-		t.Fatalf("Failed updated: %s", err)
+		t.Fatalf("Failed upgraded: %s", err)
 	}
 
 	if hl := res.Release.Hooks[0].LastRun; hl != nil {
@@ -847,21 +847,21 @@ func TestUpdateReleaseNoHooks(t *testing.T) {
 
 }
 
-func TestUpdateReleaseNoChanges(t *testing.T) {
+func TestUpgradeReleaseNoChanges(t *testing.T) {
 	c := helm.NewContext()
 	rs := rsFixture()
 	rel := releaseStub()
 	rs.env.Releases.Create(rel)
 
-	req := &services.UpdateReleaseRequest{
+	req := &services.UpgradeReleaseRequest{
 		Name:         rel.Name,
 		DisableHooks: true,
 		Chart:        rel.GetChart(),
 	}
 
-	_, err := rs.UpdateRelease(c, req)
+	_, err := rs.UpgradeRelease(c, req)
 	if err != nil {
-		t.Fatalf("Failed updated: %s", err)
+		t.Fatalf("Failed upgraded: %s", err)
 	}
 }
 
@@ -883,7 +883,7 @@ func TestRollbackReleaseNoHooks(t *testing.T) {
 	}
 	rs.env.Releases.Create(rel)
 	upgradedRel := upgradeReleaseVersion(rel)
-	rs.env.Releases.Update(rel)
+	rs.env.Releases.Upgrade(rel)
 	rs.env.Releases.Create(upgradedRel)
 
 	req := &services.RollbackReleaseRequest{
@@ -907,7 +907,7 @@ func TestRollbackWithReleaseVersion(t *testing.T) {
 	rel := releaseStub()
 	rs.env.Releases.Create(rel)
 	upgradedRel := upgradeReleaseVersion(rel)
-	rs.env.Releases.Update(rel)
+	rs.env.Releases.Upgrade(rel)
 	rs.env.Releases.Create(upgradedRel)
 
 	req := &services.RollbackReleaseRequest{
@@ -942,7 +942,7 @@ func TestRollbackRelease(t *testing.T) {
 	}
 
 	upgradedRel.Manifest = "hello world"
-	rs.env.Releases.Update(rel)
+	rs.env.Releases.Upgrade(rel)
 	rs.env.Releases.Create(upgradedRel)
 
 	req := &services.RollbackReleaseRequest{
@@ -958,7 +958,7 @@ func TestRollbackRelease(t *testing.T) {
 	}
 
 	if res.Release.Name != rel.Name {
-		t.Errorf("Updated release name does not match previous release name. Expected %s, got %s", rel.Name, res.Release.Name)
+		t.Errorf("Upgraded release name does not match previous release name. Expected %s, got %s", rel.Name, res.Release.Name)
 	}
 
 	if res.Release.Namespace != rel.Namespace {
@@ -969,21 +969,21 @@ func TestRollbackRelease(t *testing.T) {
 		t.Errorf("Expected release version to be %v, got %v", 3, res.Release.Version)
 	}
 
-	updated, err := rs.env.Releases.Get(res.Release.Name, res.Release.Version)
+	upgraded, err := rs.env.Releases.Get(res.Release.Name, res.Release.Version)
 	if err != nil {
 		t.Errorf("Expected release for %s (%v).", res.Release.Name, rs.env.Releases)
 	}
 
-	if len(updated.Hooks) != 2 {
-		t.Fatalf("Expected 2 hooks, got %d", len(updated.Hooks))
+	if len(upgraded.Hooks) != 2 {
+		t.Fatalf("Expected 2 hooks, got %d", len(upgraded.Hooks))
 	}
 
-	if updated.Hooks[0].Manifest != manifestWithHook {
-		t.Errorf("Unexpected manifest: %v", updated.Hooks[0].Manifest)
+	if upgraded.Hooks[0].Manifest != manifestWithHook {
+		t.Errorf("Unexpected manifest: %v", upgraded.Hooks[0].Manifest)
 	}
 
 	anotherUpgradedRelease := upgradeReleaseVersion(upgradedRel)
-	rs.env.Releases.Update(upgradedRel)
+	rs.env.Releases.Upgrade(upgradedRel)
 	rs.env.Releases.Create(anotherUpgradedRelease)
 
 	res, err = rs.RollbackRelease(c, req)
@@ -991,28 +991,28 @@ func TestRollbackRelease(t *testing.T) {
 		t.Fatalf("Failed rollback: %s", err)
 	}
 
-	updated, err = rs.env.Releases.Get(res.Release.Name, res.Release.Version)
+	upgraded, err = rs.env.Releases.Get(res.Release.Name, res.Release.Version)
 	if err != nil {
 		t.Errorf("Expected release for %s (%v).", res.Release.Name, rs.env.Releases)
 	}
 
-	if len(updated.Hooks) != 1 {
-		t.Fatalf("Expected 1 hook, got %d", len(updated.Hooks))
+	if len(upgraded.Hooks) != 1 {
+		t.Fatalf("Expected 1 hook, got %d", len(upgraded.Hooks))
 	}
 
-	if updated.Hooks[0].Manifest != manifestWithRollbackHooks {
-		t.Errorf("Unexpected manifest: %v", updated.Hooks[0].Manifest)
+	if upgraded.Hooks[0].Manifest != manifestWithRollbackHooks {
+		t.Errorf("Unexpected manifest: %v", upgraded.Hooks[0].Manifest)
 	}
 
 	if res.Release.Version != 4 {
 		t.Errorf("Expected release version to be %v, got %v", 3, res.Release.Version)
 	}
 
-	if updated.Hooks[0].Events[0] != release.Hook_PRE_ROLLBACK {
+	if upgraded.Hooks[0].Events[0] != release.Hook_PRE_ROLLBACK {
 		t.Errorf("Expected event 0 to be pre rollback")
 	}
 
-	if updated.Hooks[0].Events[1] != release.Hook_POST_ROLLBACK {
+	if upgraded.Hooks[0].Events[1] != release.Hook_POST_ROLLBACK {
 		t.Errorf("Expected event 1 to be post rollback")
 	}
 
@@ -1020,11 +1020,11 @@ func TestRollbackRelease(t *testing.T) {
 		t.Errorf("No manifest returned: %v", res.Release)
 	}
 
-	if len(updated.Manifest) == 0 {
+	if len(upgraded.Manifest) == 0 {
 		t.Errorf("Expected manifest in %v", res)
 	}
 
-	if !strings.Contains(updated.Manifest, "hello world") {
+	if !strings.Contains(upgraded.Manifest, "hello world") {
 		t.Errorf("unexpected output: %s", rel.Manifest)
 	}
 
@@ -1075,7 +1075,7 @@ func TestUninstallPurgeRelease(t *testing.T) {
 	rel := releaseStub()
 	rs.env.Releases.Create(rel)
 	upgradedRel := upgradeReleaseVersion(rel)
-	rs.env.Releases.Update(rel)
+	rs.env.Releases.Upgrade(rel)
 	rs.env.Releases.Create(upgradedRel)
 
 	req := &services.UninstallReleaseRequest{
@@ -1496,19 +1496,19 @@ func MockEnvironment() *environment.Environment {
 	return e
 }
 
-func newUpdateFailingKubeClient() *updateFailingKubeClient {
-	return &updateFailingKubeClient{
+func newUpgradeFailingKubeClient() *upgradeFailingKubeClient {
+	return &upgradeFailingKubeClient{
 		PrintingKubeClient: environment.PrintingKubeClient{Out: os.Stdout},
 	}
 
 }
 
-type updateFailingKubeClient struct {
+type upgradeFailingKubeClient struct {
 	environment.PrintingKubeClient
 }
 
-func (u *updateFailingKubeClient) Update(namespace string, originalReader, modifiedReader io.Reader, recreate bool, timeout int64, shouldWait bool) error {
-	return errors.New("Failed update in kube client")
+func (u *upgradeFailingKubeClient) Update(namespace string, originalReader, modifiedReader io.Reader, recreate bool, timeout int64, shouldWait bool) error {
+	return errors.New("Failed upgrade in kube client")
 }
 
 func newHookFailingKubeClient() *hookFailingKubeClient {