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

Change Update to Upgrade in context of helm release

Browse Source 
This commit aims to stop using Update and Upgrade as synonyms in context
of changing Helm Releases.

Upgrade was chosen as the correct word, as the user facing command for
changing the release is `helm upgrade`.
pull/2126/head
Maciej Kwiek 9 years ago
parent 50f4c2bfd0
commit 84d57d5e58
28 changed files with 292 additions and 292 deletions
Show Stats Download Patch File Download Diff File

14
_proto/hapi/services/tiller.proto
Unescape View File

@ -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;
}

4
cmd/helm/helm_test.go
Unescape View File

@ -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
}

4
cmd/helm/upgrade.go
Unescape View File

@ -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),

24
pkg/helm/client.go
Unescape View File

@ -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.

24
pkg/helm/helm_test.go
Unescape View File

@ -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.

4
pkg/helm/interface.go
Unescape View File

@ -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)

30
pkg/helm/option.go
Unescape View File

@ -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

2
pkg/proto/hapi/chart/chart.pb.go
Unescape View File

@ -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,

2
pkg/proto/hapi/chart/config.pb.go
Unescape View File

@ -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,

2
pkg/proto/hapi/chart/metadata.pb.go
Unescape View File

@ -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,

2
pkg/proto/hapi/chart/template.pb.go
Unescape View File

@ -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,

2
pkg/proto/hapi/release/hook.pb.go
Unescape View File

@ -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,

2
pkg/proto/hapi/release/info.pb.go
Unescape View File

@ -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,

2
pkg/proto/hapi/release/release.pb.go
Unescape View File

@ -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,

2
pkg/proto/hapi/release/status.pb.go
Unescape View File

@ -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,

2
pkg/proto/hapi/release/test_run.pb.go
Unescape View File

@ -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,

2
pkg/proto/hapi/release/test_suite.pb.go
Unescape View File

@ -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,

216
pkg/proto/hapi/services/tiller.pb.go
Unescape View File

@ -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,
}

2
pkg/proto/hapi/version/version.pb.go
Unescape View File

@ -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,

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

@ -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)

4
pkg/storage/driver/cfgmaps_test.go
Unescape View File

@ -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)
}

12
pkg/storage/driver/driver.go
Unescape View File

@ -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

4
pkg/storage/driver/memory.go
Unescape View File

@ -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) {

4
pkg/storage/driver/memory_test.go
Unescape View File

@ -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)
}

8
pkg/storage/storage.go
Unescape View File

@ -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

6
pkg/storage/storage_test.go
Unescape View File

@ -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")

72
pkg/tiller/release_server.go
Unescape View File

@ -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)
}

122
pkg/tiller/release_server_test.go
Unescape View File

@ -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 {

Write Preview
Loading…
Cancel
Save