From c1fcaf09ce3186368c70b33075b12dcbff4a9034 Mon Sep 17 00:00:00 2001 From: Maciej Kwiek Date: Wed, 8 Mar 2017 14:05:45 +0100 Subject: [PATCH 01/12] Experimental Rudder implementation This change introduces the concept of Rudders - pluggable modules that Tiller communicates with via grpc, which allow to decouple orchestration logic from Tiller into separate service. This commit consists of simple Rudder implementation which does exactly the same thing as built in Tiller orchestrator - it creates all k8s objects from provided manifest without orchestrating them. --experimental-release flag is introduced to enable this behaviour. This change allows to use the service and tiller outside of the cluster. Following commits will add Rudder to helm deployment. --- _proto/hapi/release/modules.proto | 83 ++++ cmd/rudder/rudder.go | 84 ++++ cmd/tiller/tiller.go | 14 +- pkg/proto/hapi/release/hook.pb.go | 12 + pkg/proto/hapi/release/modules.pb.go | 500 ++++++++++++++++++++++++ pkg/proto/hapi/release/release.pb.go | 6 +- pkg/proto/hapi/release/status.pb.go | 8 +- pkg/proto/hapi/release/test_run.pb.go | 8 +- pkg/proto/hapi/release/test_suite.pb.go | 6 +- pkg/rudder/client.go | 42 ++ pkg/tiller/release_modules.go | 50 +++ pkg/tiller/release_server.go | 18 +- pkg/tiller/release_server_test.go | 5 +- 13 files changed, 809 insertions(+), 27 deletions(-) create mode 100644 _proto/hapi/release/modules.proto create mode 100644 cmd/rudder/rudder.go create mode 100644 pkg/proto/hapi/release/modules.pb.go create mode 100644 pkg/rudder/client.go create mode 100644 pkg/tiller/release_modules.go diff --git a/_proto/hapi/release/modules.proto b/_proto/hapi/release/modules.proto new file mode 100644 index 000000000..4112bda7e --- /dev/null +++ b/_proto/hapi/release/modules.proto @@ -0,0 +1,83 @@ +syntax = "proto3"; + +package hapi.release; + +import "hapi/release/release.proto"; + +option go_package = "release"; + +service ReleaseModuleService { + rpc Version(VersionReleaseRequest) returns (VersionReleaseResponse) { + } + + // InstallRelease requests installation of a chart as a new release. + rpc InstallRelease(InstallReleaseRequest) returns (InstallReleaseResponse) { + } + + // DeleteRelease requests deletion of a named release. + rpc DeleteRelease(DeleteReleaseRequest) returns (DeleteReleaseResponse) { + } + + // RollbackRelease rolls back a release to a previous version. + rpc RollbackRelease(RollbackReleaseRequest) returns (RollbackReleaseResponse) { + } + + // UpgradeRelease updates release content. + rpc UpgradeRelease(UpgradeReleaseRequest) returns (UpgradeReleaseResponse) { + } +} + +message Result { + enum Status { + // No status set + UNKNOWN = 0; + // Operation was successful + SUCCESS = 1; + // Operation had no results (e.g. upgrade identical, rollback to same, delete non-existent) + UNCHANGED = 2; + // Operation failed + ERROR = 3; + } + string info = 1; + repeated string log = 2; +} + +message VersionReleaseRequest { +} + +message VersionReleaseResponse { + string name = 1; // The canonical name of the release module + string version = 2; // The version of the release module +} + +message InstallReleaseRequest { + hapi.release.Release release = 1; +} +message InstallReleaseResponse { + hapi.release.Release release = 1; + Result result = 2; +} + +message DeleteReleaseRequest { + hapi.release.Release release = 1; +} +message DeleteReleaseResponse { + hapi.release.Release release = 1; + Result result = 2; +} + +message UpgradeReleaseRequest{ + hapi.release.Release release = 1; +} +message UpgradeReleaseResponse{ + hapi.release.Release release = 1; + Result result = 2; +} + +message RollbackReleaseRequest{ + hapi.release.Release release = 1; +} +message RollbackReleaseResponse{ + hapi.release.Release release = 1; + Result result = 2; +} diff --git a/cmd/rudder/rudder.go b/cmd/rudder/rudder.go new file mode 100644 index 000000000..55b9f1773 --- /dev/null +++ b/cmd/rudder/rudder.go @@ -0,0 +1,84 @@ +/* +Copyright 2017 The Kubernetes Authors All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main // import "k8s.io/helm/cmd/rudder" + +import ( + "bytes" + "fmt" + "net" + + "golang.org/x/net/context" + "google.golang.org/grpc" + "google.golang.org/grpc/grpclog" + + "k8s.io/helm/pkg/kube" + "k8s.io/helm/pkg/proto/hapi/release" + "k8s.io/helm/pkg/rudder" +) + +var kubeClient = kube.New(nil) + +func main() { + lis, err := net.Listen("tcp", fmt.Sprintf(":%d", rudder.GrpcAddr)) + if err != nil { + grpclog.Fatalf("failed to listen: %v", err) + } + grpcServer := grpc.NewServer() + release.RegisterReleaseModuleServiceServer(grpcServer, &ReleaseModuleServiceServer{}) + + grpclog.Print("Server starting") + grpcServer.Serve(lis) + grpclog.Print("Server started") +} + +// ReleaseModuleServiceServer provides implementation for release.ReleaseModuleServiceServer +type ReleaseModuleServiceServer struct{} + +// Version is not yet implemented +func (r *ReleaseModuleServiceServer) Version(ctx context.Context, in *release.VersionReleaseRequest) (*release.VersionReleaseResponse, error) { + grpclog.Print("version") + return &release.VersionReleaseResponse{}, nil +} + +// InstallRelease creates a release using kubeClient.Create +func (r *ReleaseModuleServiceServer) InstallRelease(ctx context.Context, in *release.InstallReleaseRequest) (*release.InstallReleaseResponse, error) { + grpclog.Print("install") + b := bytes.NewBufferString(in.Release.Manifest) + err := kubeClient.Create(in.Release.Namespace, b, 500, false) + if err != nil { + grpclog.Printf("error when creating release: %s", err) + } + return &release.InstallReleaseResponse{}, err +} + +// DeleteRelease is not implemented +func (r *ReleaseModuleServiceServer) DeleteRelease(ctx context.Context, in *release.DeleteReleaseRequest) (*release.DeleteReleaseResponse, error) { + grpclog.Print("delete") + return nil, nil +} + +// RollbackRelease is not implemented +func (r *ReleaseModuleServiceServer) RollbackRelease(ctx context.Context, in *release.RollbackReleaseRequest) (*release.RollbackReleaseResponse, error) { + grpclog.Print("rollback") + return nil, nil +} + +// UpgradeRelease is not implemented +func (r *ReleaseModuleServiceServer) UpgradeRelease(ctx context.Context, in *release.UpgradeReleaseRequest) (*release.UpgradeReleaseResponse, error) { + grpclog.Print("upgrade") + return nil, nil +} diff --git a/cmd/tiller/tiller.go b/cmd/tiller/tiller.go index 2f193936e..e5f3a33f3 100644 --- a/cmd/tiller/tiller.go +++ b/cmd/tiller/tiller.go @@ -70,11 +70,12 @@ var rootServer *grpc.Server var env = environment.New() var ( - grpcAddr = ":44134" - probeAddr = ":44135" - traceAddr = ":44136" - enableTracing = false - store = storageConfigMap + grpcAddr = ":44134" + probeAddr = ":44135" + traceAddr = ":44136" + enableTracing = false + store = storageConfigMap + remoteReleaseModules = false ) var ( @@ -108,6 +109,7 @@ func main() { p.StringVarP(&grpcAddr, "listen", "l", ":44134", "address:port to listen on") p.StringVar(&store, "storage", storageConfigMap, "storage driver to use. One of 'configmap' or 'memory'") p.BoolVar(&enableTracing, "trace", false, "enable rpc tracing") + p.BoolVar(&remoteReleaseModules, "experimental-release", false, "enable experimental release modules") p.BoolVar(&tlsEnable, "tls", tlsEnableEnvVarDefault(), "enable TLS") p.BoolVar(&tlsVerify, "tls-verify", tlsVerifyEnvVarDefault(), "enable TLS and verify remote certificate") @@ -173,7 +175,7 @@ func start(c *cobra.Command, args []string) { srvErrCh := make(chan error) probeErrCh := make(chan error) go func() { - svc := tiller.NewReleaseServer(env, clientset) + svc := tiller.NewReleaseServer(env, clientset, remoteReleaseModules) services.RegisterReleaseServiceServer(rootServer, svc) if err := rootServer.Serve(lstn); err != nil { srvErrCh <- err diff --git a/pkg/proto/hapi/release/hook.pb.go b/pkg/proto/hapi/release/hook.pb.go index 1724842e3..2b8f0330a 100644 --- a/pkg/proto/hapi/release/hook.pb.go +++ b/pkg/proto/hapi/release/hook.pb.go @@ -8,6 +8,7 @@ Package release is a generated protocol buffer package. It is generated from these files: hapi/release/hook.proto hapi/release/info.proto + hapi/release/modules.proto hapi/release/release.proto hapi/release/status.proto hapi/release/test_run.proto @@ -16,6 +17,17 @@ It is generated from these files: It has these top-level messages: Hook Info + Result + VersionReleaseRequest + VersionReleaseResponse + InstallReleaseRequest + InstallReleaseResponse + DeleteReleaseRequest + DeleteReleaseResponse + UpgradeReleaseRequest + UpgradeReleaseResponse + RollbackReleaseRequest + RollbackReleaseResponse Release Status TestRun diff --git a/pkg/proto/hapi/release/modules.pb.go b/pkg/proto/hapi/release/modules.pb.go new file mode 100644 index 000000000..cfe36e572 --- /dev/null +++ b/pkg/proto/hapi/release/modules.pb.go @@ -0,0 +1,500 @@ +// Code generated by protoc-gen-go. +// source: hapi/release/modules.proto +// DO NOT EDIT! + +package release + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Result_Status int32 + +const ( + // No status set + Result_UNKNOWN Result_Status = 0 + // Operation was successful + Result_SUCCESS Result_Status = 1 + // Operation had no results (e.g. upgrade identical, rollback to same, delete non-existent) + Result_UNCHANGED Result_Status = 2 + // Operation failed + Result_ERROR Result_Status = 3 +) + +var Result_Status_name = map[int32]string{ + 0: "UNKNOWN", + 1: "SUCCESS", + 2: "UNCHANGED", + 3: "ERROR", +} +var Result_Status_value = map[string]int32{ + "UNKNOWN": 0, + "SUCCESS": 1, + "UNCHANGED": 2, + "ERROR": 3, +} + +func (x Result_Status) String() string { + return proto.EnumName(Result_Status_name, int32(x)) +} +func (Result_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{0, 0} } + +type Result struct { + Info string `protobuf:"bytes,1,opt,name=info" json:"info,omitempty"` + Log []string `protobuf:"bytes,2,rep,name=log" json:"log,omitempty"` +} + +func (m *Result) Reset() { *m = Result{} } +func (m *Result) String() string { return proto.CompactTextString(m) } +func (*Result) ProtoMessage() {} +func (*Result) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } + +type VersionReleaseRequest struct { +} + +func (m *VersionReleaseRequest) Reset() { *m = VersionReleaseRequest{} } +func (m *VersionReleaseRequest) String() string { return proto.CompactTextString(m) } +func (*VersionReleaseRequest) ProtoMessage() {} +func (*VersionReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} } + +type VersionReleaseResponse struct { + Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Version string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` +} + +func (m *VersionReleaseResponse) Reset() { *m = VersionReleaseResponse{} } +func (m *VersionReleaseResponse) String() string { return proto.CompactTextString(m) } +func (*VersionReleaseResponse) ProtoMessage() {} +func (*VersionReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} } + +type InstallReleaseRequest struct { + Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` +} + +func (m *InstallReleaseRequest) Reset() { *m = InstallReleaseRequest{} } +func (m *InstallReleaseRequest) String() string { return proto.CompactTextString(m) } +func (*InstallReleaseRequest) ProtoMessage() {} +func (*InstallReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} } + +func (m *InstallReleaseRequest) GetRelease() *Release { + if m != nil { + return m.Release + } + return nil +} + +type InstallReleaseResponse struct { + Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` +} + +func (m *InstallReleaseResponse) Reset() { *m = InstallReleaseResponse{} } +func (m *InstallReleaseResponse) String() string { return proto.CompactTextString(m) } +func (*InstallReleaseResponse) ProtoMessage() {} +func (*InstallReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} } + +func (m *InstallReleaseResponse) GetRelease() *Release { + if m != nil { + return m.Release + } + return nil +} + +func (m *InstallReleaseResponse) GetResult() *Result { + if m != nil { + return m.Result + } + return nil +} + +type DeleteReleaseRequest struct { + Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` +} + +func (m *DeleteReleaseRequest) Reset() { *m = DeleteReleaseRequest{} } +func (m *DeleteReleaseRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteReleaseRequest) ProtoMessage() {} +func (*DeleteReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} } + +func (m *DeleteReleaseRequest) GetRelease() *Release { + if m != nil { + return m.Release + } + return nil +} + +type DeleteReleaseResponse struct { + Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` +} + +func (m *DeleteReleaseResponse) Reset() { *m = DeleteReleaseResponse{} } +func (m *DeleteReleaseResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteReleaseResponse) ProtoMessage() {} +func (*DeleteReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} } + +func (m *DeleteReleaseResponse) GetRelease() *Release { + if m != nil { + return m.Release + } + return nil +} + +func (m *DeleteReleaseResponse) GetResult() *Result { + if m != nil { + return m.Result + } + return nil +} + +type UpgradeReleaseRequest struct { + Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` +} + +func (m *UpgradeReleaseRequest) Reset() { *m = UpgradeReleaseRequest{} } +func (m *UpgradeReleaseRequest) String() string { return proto.CompactTextString(m) } +func (*UpgradeReleaseRequest) ProtoMessage() {} +func (*UpgradeReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} } + +func (m *UpgradeReleaseRequest) GetRelease() *Release { + if m != nil { + return m.Release + } + return nil +} + +type UpgradeReleaseResponse struct { + Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` +} + +func (m *UpgradeReleaseResponse) Reset() { *m = UpgradeReleaseResponse{} } +func (m *UpgradeReleaseResponse) String() string { return proto.CompactTextString(m) } +func (*UpgradeReleaseResponse) ProtoMessage() {} +func (*UpgradeReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} } + +func (m *UpgradeReleaseResponse) GetRelease() *Release { + if m != nil { + return m.Release + } + return nil +} + +func (m *UpgradeReleaseResponse) GetResult() *Result { + if m != nil { + return m.Result + } + return nil +} + +type RollbackReleaseRequest struct { + Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` +} + +func (m *RollbackReleaseRequest) Reset() { *m = RollbackReleaseRequest{} } +func (m *RollbackReleaseRequest) String() string { return proto.CompactTextString(m) } +func (*RollbackReleaseRequest) ProtoMessage() {} +func (*RollbackReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} } + +func (m *RollbackReleaseRequest) GetRelease() *Release { + if m != nil { + return m.Release + } + return nil +} + +type RollbackReleaseResponse struct { + Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` +} + +func (m *RollbackReleaseResponse) Reset() { *m = RollbackReleaseResponse{} } +func (m *RollbackReleaseResponse) String() string { return proto.CompactTextString(m) } +func (*RollbackReleaseResponse) ProtoMessage() {} +func (*RollbackReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} } + +func (m *RollbackReleaseResponse) GetRelease() *Release { + if m != nil { + return m.Release + } + return nil +} + +func (m *RollbackReleaseResponse) GetResult() *Result { + if m != nil { + return m.Result + } + return nil +} + +func init() { + proto.RegisterType((*Result)(nil), "hapi.release.Result") + proto.RegisterType((*VersionReleaseRequest)(nil), "hapi.release.VersionReleaseRequest") + proto.RegisterType((*VersionReleaseResponse)(nil), "hapi.release.VersionReleaseResponse") + proto.RegisterType((*InstallReleaseRequest)(nil), "hapi.release.InstallReleaseRequest") + proto.RegisterType((*InstallReleaseResponse)(nil), "hapi.release.InstallReleaseResponse") + proto.RegisterType((*DeleteReleaseRequest)(nil), "hapi.release.DeleteReleaseRequest") + proto.RegisterType((*DeleteReleaseResponse)(nil), "hapi.release.DeleteReleaseResponse") + proto.RegisterType((*UpgradeReleaseRequest)(nil), "hapi.release.UpgradeReleaseRequest") + proto.RegisterType((*UpgradeReleaseResponse)(nil), "hapi.release.UpgradeReleaseResponse") + proto.RegisterType((*RollbackReleaseRequest)(nil), "hapi.release.RollbackReleaseRequest") + proto.RegisterType((*RollbackReleaseResponse)(nil), "hapi.release.RollbackReleaseResponse") + proto.RegisterEnum("hapi.release.Result_Status", Result_Status_name, Result_Status_value) +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion3 + +// Client API for ReleaseModuleService service + +type ReleaseModuleServiceClient interface { + Version(ctx context.Context, in *VersionReleaseRequest, opts ...grpc.CallOption) (*VersionReleaseResponse, error) + // InstallRelease requests installation of a chart as a new release. + InstallRelease(ctx context.Context, in *InstallReleaseRequest, opts ...grpc.CallOption) (*InstallReleaseResponse, error) + // DeleteRelease requests deletion of a named release. + DeleteRelease(ctx context.Context, in *DeleteReleaseRequest, opts ...grpc.CallOption) (*DeleteReleaseResponse, error) + // RollbackRelease rolls back a release to a previous version. + RollbackRelease(ctx context.Context, in *RollbackReleaseRequest, opts ...grpc.CallOption) (*RollbackReleaseResponse, error) + // UpgradeRelease updates release content. + UpgradeRelease(ctx context.Context, in *UpgradeReleaseRequest, opts ...grpc.CallOption) (*UpgradeReleaseResponse, error) +} + +type releaseModuleServiceClient struct { + cc *grpc.ClientConn +} + +func NewReleaseModuleServiceClient(cc *grpc.ClientConn) ReleaseModuleServiceClient { + return &releaseModuleServiceClient{cc} +} + +func (c *releaseModuleServiceClient) Version(ctx context.Context, in *VersionReleaseRequest, opts ...grpc.CallOption) (*VersionReleaseResponse, error) { + out := new(VersionReleaseResponse) + err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/Version", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *releaseModuleServiceClient) InstallRelease(ctx context.Context, in *InstallReleaseRequest, opts ...grpc.CallOption) (*InstallReleaseResponse, error) { + out := new(InstallReleaseResponse) + err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/InstallRelease", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *releaseModuleServiceClient) DeleteRelease(ctx context.Context, in *DeleteReleaseRequest, opts ...grpc.CallOption) (*DeleteReleaseResponse, error) { + out := new(DeleteReleaseResponse) + err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/DeleteRelease", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *releaseModuleServiceClient) RollbackRelease(ctx context.Context, in *RollbackReleaseRequest, opts ...grpc.CallOption) (*RollbackReleaseResponse, error) { + out := new(RollbackReleaseResponse) + err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/RollbackRelease", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *releaseModuleServiceClient) UpgradeRelease(ctx context.Context, in *UpgradeReleaseRequest, opts ...grpc.CallOption) (*UpgradeReleaseResponse, error) { + out := new(UpgradeReleaseResponse) + err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/UpgradeRelease", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for ReleaseModuleService service + +type ReleaseModuleServiceServer interface { + Version(context.Context, *VersionReleaseRequest) (*VersionReleaseResponse, error) + // InstallRelease requests installation of a chart as a new release. + InstallRelease(context.Context, *InstallReleaseRequest) (*InstallReleaseResponse, error) + // DeleteRelease requests deletion of a named release. + DeleteRelease(context.Context, *DeleteReleaseRequest) (*DeleteReleaseResponse, error) + // RollbackRelease rolls back a release to a previous version. + RollbackRelease(context.Context, *RollbackReleaseRequest) (*RollbackReleaseResponse, error) + // UpgradeRelease updates release content. + UpgradeRelease(context.Context, *UpgradeReleaseRequest) (*UpgradeReleaseResponse, error) +} + +func RegisterReleaseModuleServiceServer(s *grpc.Server, srv ReleaseModuleServiceServer) { + s.RegisterService(&_ReleaseModuleService_serviceDesc, srv) +} + +func _ReleaseModuleService_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VersionReleaseRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ReleaseModuleServiceServer).Version(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hapi.release.ReleaseModuleService/Version", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ReleaseModuleServiceServer).Version(ctx, req.(*VersionReleaseRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ReleaseModuleService_InstallRelease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(InstallReleaseRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ReleaseModuleServiceServer).InstallRelease(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hapi.release.ReleaseModuleService/InstallRelease", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ReleaseModuleServiceServer).InstallRelease(ctx, req.(*InstallReleaseRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ReleaseModuleService_DeleteRelease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteReleaseRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ReleaseModuleServiceServer).DeleteRelease(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hapi.release.ReleaseModuleService/DeleteRelease", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ReleaseModuleServiceServer).DeleteRelease(ctx, req.(*DeleteReleaseRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ReleaseModuleService_RollbackRelease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RollbackReleaseRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ReleaseModuleServiceServer).RollbackRelease(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hapi.release.ReleaseModuleService/RollbackRelease", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ReleaseModuleServiceServer).RollbackRelease(ctx, req.(*RollbackReleaseRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ReleaseModuleService_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.(ReleaseModuleServiceServer).UpgradeRelease(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hapi.release.ReleaseModuleService/UpgradeRelease", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ReleaseModuleServiceServer).UpgradeRelease(ctx, req.(*UpgradeReleaseRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _ReleaseModuleService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "hapi.release.ReleaseModuleService", + HandlerType: (*ReleaseModuleServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Version", + Handler: _ReleaseModuleService_Version_Handler, + }, + { + MethodName: "InstallRelease", + Handler: _ReleaseModuleService_InstallRelease_Handler, + }, + { + MethodName: "DeleteRelease", + Handler: _ReleaseModuleService_DeleteRelease_Handler, + }, + { + MethodName: "RollbackRelease", + Handler: _ReleaseModuleService_RollbackRelease_Handler, + }, + { + MethodName: "UpgradeRelease", + Handler: _ReleaseModuleService_UpgradeRelease_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: fileDescriptor2, +} + +func init() { proto.RegisterFile("hapi/release/modules.proto", fileDescriptor2) } + +var fileDescriptor2 = []byte{ + // 450 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x5d, 0x6b, 0xd4, 0x40, + 0x14, 0xdd, 0x0f, 0xdd, 0x25, 0x77, 0xad, 0x86, 0xcb, 0x66, 0x1b, 0xf2, 0x54, 0xa6, 0x0a, 0x7d, + 0x90, 0x2c, 0xac, 0xaf, 0xbe, 0xe8, 0x76, 0xed, 0x16, 0x31, 0x85, 0x09, 0xa9, 0x50, 0x10, 0x4c, + 0xdb, 0x6b, 0x0d, 0x4e, 0x33, 0x31, 0x93, 0xac, 0xfe, 0x66, 0x7f, 0x85, 0xe4, 0x4b, 0x9a, 0x31, + 0x54, 0x64, 0xcb, 0x3e, 0x65, 0x26, 0xf7, 0xe4, 0xe4, 0x9c, 0x3b, 0xf7, 0x0c, 0x38, 0x5f, 0xc3, + 0x24, 0x9a, 0xa7, 0x24, 0x28, 0x54, 0x34, 0xbf, 0x95, 0xd7, 0xb9, 0x20, 0xe5, 0x26, 0xa9, 0xcc, + 0x24, 0x3e, 0x29, 0x6a, 0x6e, 0x5d, 0x73, 0xda, 0xc8, 0xfa, 0x59, 0x21, 0x99, 0x80, 0x11, 0x27, + 0x95, 0x8b, 0x0c, 0x11, 0x1e, 0x45, 0xf1, 0x17, 0x69, 0xf7, 0x0f, 0xfa, 0x47, 0x06, 0x2f, 0xd7, + 0x68, 0xc2, 0x50, 0xc8, 0x1b, 0x7b, 0x70, 0x30, 0x3c, 0x32, 0x78, 0xb1, 0x64, 0xaf, 0x61, 0xe4, + 0x67, 0x61, 0x96, 0x2b, 0x9c, 0xc0, 0x38, 0xf0, 0xde, 0x7b, 0x67, 0x1f, 0x3d, 0xb3, 0x57, 0x6c, + 0xfc, 0x60, 0xb9, 0x5c, 0xf9, 0xbe, 0xd9, 0xc7, 0x3d, 0x30, 0x02, 0x6f, 0xb9, 0x7e, 0xe3, 0x9d, + 0xac, 0x8e, 0xcd, 0x01, 0x1a, 0xf0, 0x78, 0xc5, 0xf9, 0x19, 0x37, 0x87, 0x6c, 0x1f, 0xac, 0x73, + 0x4a, 0x55, 0x24, 0x63, 0x5e, 0xa9, 0xe0, 0xf4, 0x3d, 0x27, 0x95, 0xb1, 0x77, 0x30, 0xd3, 0x0b, + 0x2a, 0x91, 0xb1, 0xa2, 0x42, 0x56, 0x1c, 0xde, 0x52, 0x23, 0xab, 0x58, 0xa3, 0x0d, 0xe3, 0x4d, + 0x85, 0xb6, 0x07, 0xe5, 0xeb, 0x66, 0xcb, 0xd6, 0x60, 0x9d, 0xc6, 0x2a, 0x0b, 0x85, 0x68, 0xff, + 0x00, 0xe7, 0x30, 0xae, 0x8d, 0x97, 0x4c, 0x93, 0x85, 0xe5, 0xde, 0xed, 0x91, 0xdb, 0xc0, 0x1b, + 0x14, 0xfb, 0x01, 0x33, 0x9d, 0xa9, 0x56, 0xf4, 0xbf, 0x54, 0xf8, 0x12, 0x46, 0x69, 0xd9, 0xe3, + 0x52, 0xed, 0x64, 0x31, 0xd5, 0xf1, 0x45, 0x8d, 0xd7, 0x18, 0x76, 0x02, 0xd3, 0x63, 0x12, 0x94, + 0xd1, 0xb6, 0x0e, 0x36, 0x60, 0x69, 0x44, 0xbb, 0x31, 0xb0, 0x06, 0x2b, 0x48, 0x6e, 0xd2, 0xf0, + 0x9a, 0x1e, 0xe0, 0x0c, 0x74, 0xa6, 0xdd, 0x58, 0x38, 0x85, 0x19, 0x97, 0x42, 0x5c, 0x86, 0x57, + 0xdf, 0xb6, 0xf5, 0xf0, 0x13, 0xf6, 0xff, 0xa2, 0xda, 0x89, 0x89, 0xc5, 0xaf, 0x21, 0x4c, 0x6b, + 0x8a, 0x0f, 0xe5, 0xed, 0xe0, 0x53, 0xba, 0x89, 0xae, 0x08, 0xcf, 0x61, 0x5c, 0x87, 0x0d, 0x0f, + 0xdb, 0x0c, 0x9d, 0xe1, 0x74, 0x9e, 0xdf, 0x0f, 0xaa, 0xdc, 0xb0, 0x1e, 0x7e, 0x82, 0xa7, 0xed, + 0xc8, 0xe8, 0xf4, 0x9d, 0xd1, 0xd4, 0xe9, 0xbb, 0x53, 0xc7, 0x7a, 0x78, 0x01, 0x7b, 0xad, 0x79, + 0x46, 0xd6, 0xfe, 0xb0, 0x2b, 0x35, 0xce, 0xe1, 0xbd, 0x98, 0x3f, 0xdc, 0x9f, 0xe1, 0x99, 0x76, + 0x4a, 0xa8, 0xc9, 0xea, 0x9e, 0x07, 0xe7, 0xc5, 0x3f, 0x50, 0x77, 0x9b, 0xd3, 0x9e, 0x65, 0xbd, + 0x39, 0x9d, 0x99, 0xd1, 0x9b, 0xd3, 0x1d, 0x07, 0xd6, 0x7b, 0x6b, 0x5c, 0x34, 0x53, 0x72, 0x39, + 0x2a, 0x6f, 0xf6, 0x57, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x89, 0x83, 0xd3, 0x0a, 0x21, 0x06, + 0x00, 0x00, +} diff --git a/pkg/proto/hapi/release/release.pb.go b/pkg/proto/hapi/release/release.pb.go index 47b321b50..f58ce1502 100644 --- a/pkg/proto/hapi/release/release.pb.go +++ b/pkg/proto/hapi/release/release.pb.go @@ -40,7 +40,7 @@ type Release struct { func (m *Release) Reset() { *m = Release{} } func (m *Release) String() string { return proto.CompactTextString(m) } func (*Release) ProtoMessage() {} -func (*Release) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } +func (*Release) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} } func (m *Release) GetName() string { if m != nil { @@ -102,9 +102,9 @@ func init() { proto.RegisterType((*Release)(nil), "hapi.release.Release") } -func init() { proto.RegisterFile("hapi/release/release.proto", fileDescriptor2) } +func init() { proto.RegisterFile("hapi/release/release.proto", fileDescriptor3) } -var fileDescriptor2 = []byte{ +var fileDescriptor3 = []byte{ // 256 bytes of a gzipped FileDescriptorProto 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, diff --git a/pkg/proto/hapi/release/status.pb.go b/pkg/proto/hapi/release/status.pb.go index 0098207a7..71ed631c8 100644 --- a/pkg/proto/hapi/release/status.pb.go +++ b/pkg/proto/hapi/release/status.pb.go @@ -51,7 +51,7 @@ var Status_Code_value = map[string]int32{ func (x Status_Code) String() string { return proto.EnumName(Status_Code_name, int32(x)) } -func (Status_Code) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{0, 0} } +func (Status_Code) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{0, 0} } // Status defines the status of a release. type Status struct { @@ -67,7 +67,7 @@ type Status struct { func (m *Status) Reset() { *m = Status{} } func (m *Status) String() string { return proto.CompactTextString(m) } func (*Status) ProtoMessage() {} -func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} } +func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} } func (m *Status) GetCode() Status_Code { if m != nil { @@ -102,9 +102,9 @@ func init() { proto.RegisterEnum("hapi.release.Status_Code", Status_Code_name, Status_Code_value) } -func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor3) } +func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor4) } -var fileDescriptor3 = []byte{ +var fileDescriptor4 = []byte{ // 291 bytes of a gzipped FileDescriptorProto 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, diff --git a/pkg/proto/hapi/release/test_run.pb.go b/pkg/proto/hapi/release/test_run.pb.go index 79fce4ab4..a40a410f8 100644 --- a/pkg/proto/hapi/release/test_run.pb.go +++ b/pkg/proto/hapi/release/test_run.pb.go @@ -36,7 +36,7 @@ var TestRun_Status_value = map[string]int32{ func (x TestRun_Status) String() string { return proto.EnumName(TestRun_Status_name, int32(x)) } -func (TestRun_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{0, 0} } +func (TestRun_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor5, []int{0, 0} } type TestRun struct { Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` @@ -49,7 +49,7 @@ type TestRun struct { func (m *TestRun) Reset() { *m = TestRun{} } func (m *TestRun) String() string { return proto.CompactTextString(m) } func (*TestRun) ProtoMessage() {} -func (*TestRun) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} } +func (*TestRun) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} } func (m *TestRun) GetName() string { if m != nil { @@ -91,9 +91,9 @@ func init() { proto.RegisterEnum("hapi.release.TestRun_Status", TestRun_Status_name, TestRun_Status_value) } -func init() { proto.RegisterFile("hapi/release/test_run.proto", fileDescriptor4) } +func init() { proto.RegisterFile("hapi/release/test_run.proto", fileDescriptor5) } -var fileDescriptor4 = []byte{ +var fileDescriptor5 = []byte{ // 265 bytes of a gzipped FileDescriptorProto 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, diff --git a/pkg/proto/hapi/release/test_suite.pb.go b/pkg/proto/hapi/release/test_suite.pb.go index f168bf1d2..304cded78 100644 --- a/pkg/proto/hapi/release/test_suite.pb.go +++ b/pkg/proto/hapi/release/test_suite.pb.go @@ -27,7 +27,7 @@ type TestSuite struct { func (m *TestSuite) Reset() { *m = TestSuite{} } func (m *TestSuite) String() string { return proto.CompactTextString(m) } func (*TestSuite) ProtoMessage() {} -func (*TestSuite) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} } +func (*TestSuite) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} } func (m *TestSuite) GetStartedAt() *google_protobuf.Timestamp { if m != nil { @@ -54,9 +54,9 @@ func init() { proto.RegisterType((*TestSuite)(nil), "hapi.release.TestSuite") } -func init() { proto.RegisterFile("hapi/release/test_suite.proto", fileDescriptor5) } +func init() { proto.RegisterFile("hapi/release/test_suite.proto", fileDescriptor6) } -var fileDescriptor5 = []byte{ +var fileDescriptor6 = []byte{ // 207 bytes of a gzipped FileDescriptorProto 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, diff --git a/pkg/rudder/client.go b/pkg/rudder/client.go new file mode 100644 index 000000000..cc3b193ab --- /dev/null +++ b/pkg/rudder/client.go @@ -0,0 +1,42 @@ +/* +Copyright 2017 The Kubernetes Authors All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package rudder // import "k8s.io/helm/pkg/rudder" + +import ( + "fmt" + + "golang.org/x/net/context" + "google.golang.org/grpc" + + "k8s.io/helm/pkg/proto/hapi/release" +) + +// GrpcAddr is port number for accessing Rudder service +var GrpcAddr = 10001 + +// InstallRelease calls Rudder InstallRelease method which should create provided release +func InstallRelease(rel *release.InstallReleaseRequest) (*release.InstallReleaseResponse, error) { + //TODO(mkwiek): parametrize this + conn, err := grpc.Dial(fmt.Sprintf("127.0.0.1:%d", GrpcAddr), grpc.WithInsecure()) + if err != nil { + return nil, err + } + + defer conn.Close() + client := release.NewReleaseModuleServiceClient(conn) + return client.InstallRelease(context.Background(), rel) +} diff --git a/pkg/tiller/release_modules.go b/pkg/tiller/release_modules.go new file mode 100644 index 000000000..12d4cdcb2 --- /dev/null +++ b/pkg/tiller/release_modules.go @@ -0,0 +1,50 @@ +/* +Copyright 2017 The Kubernetes Authors All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tiller + +import ( + "bytes" + + "k8s.io/helm/pkg/proto/hapi/release" + "k8s.io/helm/pkg/proto/hapi/services" + "k8s.io/helm/pkg/rudder" + "k8s.io/helm/pkg/tiller/environment" +) + +// ReleaseModule is an interface that allows ReleaseServer to run operations on release via either local implementation or Rudder service +type ReleaseModule interface { + Create(r *release.Release, req *services.InstallReleaseRequest, env *environment.Environment) error +} + +// LocalReleaseModule is a local implementation of ReleaseModule +type LocalReleaseModule struct{} + +// Create creates a release via kubeclient from provided environment +func (m *LocalReleaseModule) Create(r *release.Release, req *services.InstallReleaseRequest, env *environment.Environment) error { + b := bytes.NewBufferString(r.Manifest) + return env.KubeClient.Create(r.Namespace, b, req.Timeout, req.Wait) +} + +// RemoteReleaseModule is a ReleaseModule which calls Rudder service to operate on a release +type RemoteReleaseModule struct{} + +// Create calls rudder.InstallRelease +func (m *RemoteReleaseModule) Create(r *release.Release, req *services.InstallReleaseRequest, env *environment.Environment) error { + request := &release.InstallReleaseRequest{Release: r} + _, err := rudder.InstallRelease(request) + return err +} diff --git a/pkg/tiller/release_server.go b/pkg/tiller/release_server.go index bd480fb32..4d56465cb 100644 --- a/pkg/tiller/release_server.go +++ b/pkg/tiller/release_server.go @@ -82,15 +82,24 @@ var ValidName = regexp.MustCompile("^(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])+ // ReleaseServer implements the server-side gRPC endpoint for the HAPI services. type ReleaseServer struct { + ReleaseModule env *environment.Environment clientset internalclientset.Interface } // NewReleaseServer creates a new release server. -func NewReleaseServer(env *environment.Environment, clientset internalclientset.Interface) *ReleaseServer { +func NewReleaseServer(env *environment.Environment, clientset internalclientset.Interface, useRemote bool) *ReleaseServer { + var releaseModule ReleaseModule + if useRemote { + releaseModule = &RemoteReleaseModule{} + } else { + releaseModule = &LocalReleaseModule{} + } + return &ReleaseServer{ - env: env, - clientset: clientset, + env: env, + clientset: clientset, + ReleaseModule: releaseModule, } } @@ -907,8 +916,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install default: // nothing to replace, create as normal // regular manifests - b := bytes.NewBufferString(r.Manifest) - if err := s.env.KubeClient.Create(r.Namespace, b, req.Timeout, req.Wait); err != nil { + if err := s.ReleaseModule.Create(r, req, s.env); err != nil { msg := fmt.Sprintf("Release %q failed: %s", r.Name, err) log.Printf("warning: %s", msg) r.Info.Status.Code = release.Status_FAILED diff --git a/pkg/tiller/release_server_test.go b/pkg/tiller/release_server_test.go index 596f0803b..e34d68e98 100644 --- a/pkg/tiller/release_server_test.go +++ b/pkg/tiller/release_server_test.go @@ -99,8 +99,9 @@ data: func rsFixture() *ReleaseServer { return &ReleaseServer{ - env: MockEnvironment(), - clientset: fake.NewSimpleClientset(), + ReleaseModule: &LocalReleaseModule{}, + env: MockEnvironment(), + clientset: fake.NewSimpleClientset(), } } From cce50f805247119028b9ecc046887ddf0b16d3d7 Mon Sep 17 00:00:00 2001 From: Maciej Kwiek Date: Mon, 13 Mar 2017 14:50:08 +0100 Subject: [PATCH 02/12] Add experimental dockerfiles Added dockerfiles for rudder service and tiller run with --experimental-release flag --- .gitignore | 1 + Makefile | 21 +++++++++++++++------ rootfs/Dockerfile.experimental | 24 ++++++++++++++++++++++++ rootfs/Dockerfile.rudder | 23 +++++++++++++++++++++++ versioning.mk | 7 ++++--- 5 files changed, 67 insertions(+), 9 deletions(-) create mode 100644 rootfs/Dockerfile.experimental create mode 100644 rootfs/Dockerfile.rudder diff --git a/.gitignore b/.gitignore index 12b7ab7bc..b94f87b26 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,7 @@ _dist/ _proto/*.pb.go bin/ rootfs/tiller +rootfs/rudder vendor/ *.exe .idea/ diff --git a/Makefile b/Makefile index d9d869a3b..86d9b76e9 100644 --- a/Makefile +++ b/Makefile @@ -1,9 +1,10 @@ -DOCKER_REGISTRY ?= gcr.io -IMAGE_PREFIX ?= kubernetes-helm -SHORT_NAME ?= tiller -TARGETS = darwin/amd64 linux/amd64 linux/386 linux/arm linux/arm64 linux/ppc64le windows/amd64 -DIST_DIRS = find * -type d -exec -APP = helm +DOCKER_REGISTRY ?= gcr.io +IMAGE_PREFIX ?= kubernetes-helm +SHORT_NAME ?= tiller +SHORT_NAME_RUDDER ?= rudder +TARGETS = darwin/amd64 linux/amd64 linux/386 linux/arm linux/arm64 linux/ppc64le windows/amd64 +DIST_DIRS = find * -type d -exec +APP = helm # go option GO ?= go @@ -60,12 +61,20 @@ docker-binary: BINDIR = ./rootfs docker-binary: GOFLAGS += -a -installsuffix cgo docker-binary: GOOS=linux GOARCH=amd64 CGO_ENABLED=0 $(GO) build -o $(BINDIR)/tiller $(GOFLAGS) -tags '$(TAGS)' -ldflags '$(LDFLAGS)' k8s.io/helm/cmd/tiller + GOOS=linux GOARCH=amd64 CGO_ENABLED=0 $(GO) build -o $(BINDIR)/rudder $(GOFLAGS) -tags '$(TAGS)' -ldflags '$(LDFLAGS)' k8s.io/helm/cmd/rudder .PHONY: docker-build docker-build: check-docker docker-binary docker build --rm -t ${IMAGE} rootfs docker tag ${IMAGE} ${MUTABLE_IMAGE} +.PHONY: docker-build-experimental +docker-build-experimental: check-docker docker-binary + docker build --rm -t ${IMAGE} rootfs -f rootfs/Dockerfile.experimental + docker tag ${IMAGE} ${MUTABLE_IMAGE} + docker build --rm -t ${IMAGE_RUDDER} rootfs -f rootfs/Dockerfile.rudder + docker tag ${IMAGE_RUDDER} ${MUTABLE_IMAGE_RUDDER} + .PHONY: test test: build test: TESTFLAGS += -race -v diff --git a/rootfs/Dockerfile.experimental b/rootfs/Dockerfile.experimental new file mode 100644 index 000000000..0528471e6 --- /dev/null +++ b/rootfs/Dockerfile.experimental @@ -0,0 +1,24 @@ +# Copyright 2017 The Kubernetes Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FROM alpine:3.3 + +ENV HOME /tmp + +COPY . / + +EXPOSE 44134 + +CMD ["/tiller", "--experimental-release"] + diff --git a/rootfs/Dockerfile.rudder b/rootfs/Dockerfile.rudder new file mode 100644 index 000000000..d39d0ebdb --- /dev/null +++ b/rootfs/Dockerfile.rudder @@ -0,0 +1,23 @@ +# Copyright 2017 The Kubernetes Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FROM alpine:3.3 + +ENV HOME /tmp + +COPY . / + +EXPOSE 10001 + +CMD ["/rudder"] diff --git a/versioning.mk b/versioning.mk index 83921f04d..2333530d9 100644 --- a/versioning.mk +++ b/versioning.mk @@ -22,12 +22,13 @@ endif ifneq ($(GIT_TAG),) LDFLAGS += -X k8s.io/helm/pkg/version.BuildMetadata= endif - LDFLAGS += -X k8s.io/helm/pkg/version.GitCommit=${GIT_COMMIT} LDFLAGS += -X k8s.io/helm/pkg/version.GitTreeState=${GIT_DIRTY} -IMAGE := ${DOCKER_REGISTRY}/${IMAGE_PREFIX}/${SHORT_NAME}:${DOCKER_VERSION} -MUTABLE_IMAGE := ${DOCKER_REGISTRY}/${IMAGE_PREFIX}/${SHORT_NAME}:${MUTABLE_VERSION} +IMAGE := ${DOCKER_REGISTRY}/${IMAGE_PREFIX}/${SHORT_NAME}:${DOCKER_VERSION} +IMAGE_RUDDER := ${DOCKER_REGISTRY}/${IMAGE_PREFIX}/${SHORT_NAME_RUDDER}:${DOCKER_VERSION} +MUTABLE_IMAGE := ${DOCKER_REGISTRY}/${IMAGE_PREFIX}/${SHORT_NAME}:${MUTABLE_VERSION} +MUTABLE_IMAGE_RUDDER := ${DOCKER_REGISTRY}/${IMAGE_PREFIX}/${SHORT_NAME_RUDDER}:${DOCKER_VERSION} DOCKER_PUSH = docker push ifeq ($(DOCKER_REGISTRY),gcr.io) From 8ef9144fb19849eab306aca7bfdbdf381c97efb9 Mon Sep 17 00:00:00 2001 From: Maciej Kwiek Date: Wed, 15 Mar 2017 14:01:05 +0100 Subject: [PATCH 03/12] Use helm version as rudder version --- cmd/rudder/rudder.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/cmd/rudder/rudder.go b/cmd/rudder/rudder.go index 55b9f1773..93913be91 100644 --- a/cmd/rudder/rudder.go +++ b/cmd/rudder/rudder.go @@ -28,6 +28,7 @@ import ( "k8s.io/helm/pkg/kube" "k8s.io/helm/pkg/proto/hapi/release" "k8s.io/helm/pkg/rudder" + "k8s.io/helm/pkg/version" ) var kubeClient = kube.New(nil) @@ -51,7 +52,10 @@ type ReleaseModuleServiceServer struct{} // Version is not yet implemented func (r *ReleaseModuleServiceServer) Version(ctx context.Context, in *release.VersionReleaseRequest) (*release.VersionReleaseResponse, error) { grpclog.Print("version") - return &release.VersionReleaseResponse{}, nil + return &release.VersionReleaseResponse{ + Name: "helm-rudder-native", + Version: version.Version, + }, nil } // InstallRelease creates a release using kubeClient.Create From a883531f98b5257fa7d9873f510b94ca61c0047d Mon Sep 17 00:00:00 2001 From: Dmitry Shulyak Date: Wed, 15 Mar 2017 15:42:22 +0200 Subject: [PATCH 04/12] Implement upgrade for rudder --- cmd/rudder/rudder.go | 8 ++++++-- pkg/proto/hapi/release/modules.pb.go | 12 ++++++++++-- pkg/rudder/client.go | 11 +++++++++++ pkg/tiller/release_modules.go | 20 ++++++++++++++++++++ pkg/tiller/release_server.go | 14 +++----------- 5 files changed, 50 insertions(+), 15 deletions(-) diff --git a/cmd/rudder/rudder.go b/cmd/rudder/rudder.go index 93913be91..71f5325d1 100644 --- a/cmd/rudder/rudder.go +++ b/cmd/rudder/rudder.go @@ -81,8 +81,12 @@ func (r *ReleaseModuleServiceServer) RollbackRelease(ctx context.Context, in *re return nil, nil } -// UpgradeRelease is not implemented +// UpgradeRelease upgrades manifests using kubernetes client func (r *ReleaseModuleServiceServer) UpgradeRelease(ctx context.Context, in *release.UpgradeReleaseRequest) (*release.UpgradeReleaseResponse, error) { grpclog.Print("upgrade") - return nil, nil + c := bytes.NewBufferString(in.Current.Manifest) + t := bytes.NewBufferString(in.Target.Manifest) + err := kubeClient.Update(in.Target.Namespace, c, t, in.Recreate, in.Timeout, in.Wait) + // upgrade response object should be changed to include status + return &release.UpgradeReleaseResponse{}, err } diff --git a/pkg/proto/hapi/release/modules.pb.go b/pkg/proto/hapi/release/modules.pb.go index cfe36e572..123eb378a 100644 --- a/pkg/proto/hapi/release/modules.pb.go +++ b/pkg/proto/hapi/release/modules.pb.go @@ -158,7 +158,15 @@ func (m *DeleteReleaseResponse) GetResult() *Result { } type UpgradeReleaseRequest struct { - Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Current *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Target *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + // Performs pods restart for resources if applicable + Recreate bool `protobuf:"varint,6,opt,name=recreate" json:"recreate,omitempty"` + // timeout specifies the max amount of time any kubernetes client command can run. + Timeout int64 `protobuf:"varint,7,opt,name=timeout" json:"timeout,omitempty"` + // wait, if true, will wait until all Pods, PVCs, and Services are in a ready state + // before marking the release as successful. It will wait for as long as timeout + Wait bool `protobuf:"varint,9,opt,name=wait" json:"wait,omitempty"` } func (m *UpgradeReleaseRequest) Reset() { *m = UpgradeReleaseRequest{} } @@ -168,7 +176,7 @@ func (*UpgradeReleaseRequest) Descriptor() ([]byte, []int) { return fileDescript func (m *UpgradeReleaseRequest) GetRelease() *Release { if m != nil { - return m.Release + return m.Target } return nil } diff --git a/pkg/rudder/client.go b/pkg/rudder/client.go index cc3b193ab..1583ac69b 100644 --- a/pkg/rudder/client.go +++ b/pkg/rudder/client.go @@ -40,3 +40,14 @@ func InstallRelease(rel *release.InstallReleaseRequest) (*release.InstallRelease client := release.NewReleaseModuleServiceClient(conn) return client.InstallRelease(context.Background(), rel) } + +// UpgradeReleas calls Rudder UpgradeRelease method which should perform update +func UpgradeRelease(req *release.UpgradeReleaseRequest) (*release.UpgradeReleaseResponse, error) { + conn, err := grpc.Dial(fmt.Sprintf("127.0.0.1:%d", GrpcAddr), grpc.WithInsecure()) + if err != nil { + return nil, err + } + defer conn.Close() + client := release.NewReleaseModuleServiceClient(conn) + return client.UpgradeRelease(context.Background(), req) +} diff --git a/pkg/tiller/release_modules.go b/pkg/tiller/release_modules.go index 12d4cdcb2..a377527f6 100644 --- a/pkg/tiller/release_modules.go +++ b/pkg/tiller/release_modules.go @@ -28,6 +28,7 @@ import ( // ReleaseModule is an interface that allows ReleaseServer to run operations on release via either local implementation or Rudder service type ReleaseModule interface { Create(r *release.Release, req *services.InstallReleaseRequest, env *environment.Environment) error + Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error } // LocalReleaseModule is a local implementation of ReleaseModule @@ -39,6 +40,12 @@ func (m *LocalReleaseModule) Create(r *release.Release, req *services.InstallRel return env.KubeClient.Create(r.Namespace, b, req.Timeout, req.Wait) } +func (m *LocalReleaseModule) Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error { + c := bytes.NewBufferString(current.Manifest) + t := bytes.NewBufferString(target.Manifest) + return env.KubeClient.Update(target.Namespace, c, t, req.Recreate, req.Timeout, req.Wait) +} + // RemoteReleaseModule is a ReleaseModule which calls Rudder service to operate on a release type RemoteReleaseModule struct{} @@ -48,3 +55,16 @@ func (m *RemoteReleaseModule) Create(r *release.Release, req *services.InstallRe _, err := rudder.InstallRelease(request) return err } + +// Update calls rudder.UpgradeRelease +func (m *RemoteReleaseModule) Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error { + req := &release.UpgradeReleaseRequest{ + Current: current, + Target: target, + Recreate: req.Recreate, + Timeout: req.Timeout, + Wait: req.Wait, + } + _, err := rudder.UpgradeRelease(req) + return err +} diff --git a/pkg/tiller/release_server.go b/pkg/tiller/release_server.go index 4d56465cb..ea5cafd02 100644 --- a/pkg/tiller/release_server.go +++ b/pkg/tiller/release_server.go @@ -332,8 +332,7 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R return res, err } } - - if err := s.performKubeUpdate(originalRelease, updatedRelease, req.Recreate, req.Timeout, req.Wait); err != nil { + if err := s.ReleaseModule.Update(originalRelease, updatedRelease, req, s.env); err != nil { msg := fmt.Sprintf("Upgrade %q failed: %s", updatedRelease.Name, err) log.Printf("warning: %s", msg) originalRelease.Info.Status.Code = release.Status_SUPERSEDED @@ -520,7 +519,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.ReleaseModule.Update(currentRelease, targetRelease, req); err != nil { msg := fmt.Sprintf("Rollback %q failed: %s", targetRelease.Name, err) log.Printf("warning: %s", msg) currentRelease.Info.Status.Code = release.Status_SUPERSEDED @@ -546,13 +545,6 @@ 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 { - kubeCli := s.env.KubeClient - current := bytes.NewBufferString(currentRelease.Manifest) - target := bytes.NewBufferString(targetRelease.Manifest) - return kubeCli.Update(targetRelease.Namespace, current, target, recreate, timeout, shouldWait) -} - // prepareRollback finds the previous release and prepares a new release object with // the previous release's configuration func (s *ReleaseServer) prepareRollback(req *services.RollbackReleaseRequest) (*release.Release, *release.Release, error) { @@ -902,7 +894,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install // 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.ReleaseModule.Update(old, r, req, s.env); 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 From 8b33e4720b64ddb8687371059e37dd7b093c6b2e Mon Sep 17 00:00:00 2001 From: Dmitry Shulyak Date: Thu, 16 Mar 2017 10:33:33 +0200 Subject: [PATCH 05/12] Update release proto --- _proto/hapi/release/modules.proto | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/_proto/hapi/release/modules.proto b/_proto/hapi/release/modules.proto index 4112bda7e..ab99c4b75 100644 --- a/_proto/hapi/release/modules.proto +++ b/_proto/hapi/release/modules.proto @@ -67,7 +67,11 @@ message DeleteReleaseResponse { } message UpgradeReleaseRequest{ - hapi.release.Release release = 1; + hapi.release.Release current = 1; + hapi.release.Release target = 2; + int64 Timeout = 3; + bool Wait = 4; + bool Recreate = 5; } message UpgradeReleaseResponse{ hapi.release.Release release = 1; From 59af46502d523bcdc9a967880874f8445a9b4225 Mon Sep 17 00:00:00 2001 From: Dmitry Shulyak Date: Thu, 16 Mar 2017 10:33:47 +0200 Subject: [PATCH 06/12] Run make protoc to update hapi --- pkg/proto/hapi/chart/chart.pb.go | 2 +- pkg/proto/hapi/chart/config.pb.go | 2 +- pkg/proto/hapi/chart/template.pb.go | 2 +- pkg/proto/hapi/release/info.pb.go | 2 +- pkg/proto/hapi/release/modules.pb.go | 87 +++++++++++++------------ pkg/proto/hapi/release/release.pb.go | 2 +- pkg/proto/hapi/release/status.pb.go | 2 +- pkg/proto/hapi/release/test_run.pb.go | 2 +- pkg/proto/hapi/release/test_suite.pb.go | 2 +- pkg/proto/hapi/version/version.pb.go | 2 +- 10 files changed, 56 insertions(+), 49 deletions(-) diff --git a/pkg/proto/hapi/chart/chart.pb.go b/pkg/proto/hapi/chart/chart.pb.go index dbb188e91..c3afc3f44 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, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0xc3, 0x30, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0xc3, 0x30, 0x10, 0x86, 0x15, 0x4a, 0x0a, 0x1c, 0x2c, 0x58, 0x08, 0x4c, 0xa7, 0x8a, 0x09, 0x75, 0x70, 0x50, 0x11, 0x0f, 0x00, 0xcc, 0x2c, 0x16, 0x13, 0xdb, 0xb5, 0xb9, 0xa4, 0x91, 0x52, 0x3b, 0xaa, 0x5d, 0xa4, 0xbe, 0x3b, 0x03, 0xea, 0xd9, 0xa6, 0x09, 0xea, 0x12, 0x29, 0xf7, 0x7d, 0xff, 0xe5, 0xbf, diff --git a/pkg/proto/hapi/chart/config.pb.go b/pkg/proto/hapi/chart/config.pb.go index 4a8b36d89..8ce01968d 100644 --- a/pkg/proto/hapi/chart/config.pb.go +++ b/pkg/proto/hapi/chart/config.pb.go @@ -64,7 +64,7 @@ func init() { proto.RegisterFile("hapi/chart/config.proto", fileDescriptor1) } var fileDescriptor1 = []byte{ // 182 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0xc8, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0xc8, 0xd4, 0x4f, 0xce, 0x48, 0x2c, 0x2a, 0xd1, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x02, 0x49, 0xe8, 0x81, 0x25, 0x94, 0x16, 0x30, 0x72, 0xb1, 0x39, 0x83, 0x25, 0x85, 0x04, 0xb8, 0x98, 0x8b, 0x12, 0xcb, 0x25, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, diff --git a/pkg/proto/hapi/chart/template.pb.go b/pkg/proto/hapi/chart/template.pb.go index 416269d18..862efa372 100644 --- a/pkg/proto/hapi/chart/template.pb.go +++ b/pkg/proto/hapi/chart/template.pb.go @@ -51,7 +51,7 @@ func init() { proto.RegisterFile("hapi/chart/template.proto", fileDescriptor3) } var fileDescriptor3 = []byte{ // 107 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0x48, 0x2c, 0xc8, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0x48, 0x2c, 0xc8, 0xd4, 0x4f, 0xce, 0x48, 0x2c, 0x2a, 0xd1, 0x2f, 0x49, 0xcd, 0x2d, 0xc8, 0x49, 0x2c, 0x49, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x02, 0x49, 0xe9, 0x81, 0xa5, 0x94, 0x8c, 0xb8, 0x38, 0x42, 0xa0, 0xb2, 0x42, 0x42, 0x5c, 0x2c, 0x79, 0x89, 0xb9, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, diff --git a/pkg/proto/hapi/release/info.pb.go b/pkg/proto/hapi/release/info.pb.go index 9485ad058..fd57fecf9 100644 --- a/pkg/proto/hapi/release/info.pb.go +++ b/pkg/proto/hapi/release/info.pb.go @@ -73,7 +73,7 @@ func init() { proto.RegisterFile("hapi/release/info.proto", fileDescriptor1) } var fileDescriptor1 = []byte{ // 235 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x31, 0x4f, 0xc3, 0x30, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 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/modules.pb.go b/pkg/proto/hapi/release/modules.pb.go index 123eb378a..bab0b9915 100644 --- a/pkg/proto/hapi/release/modules.pb.go +++ b/pkg/proto/hapi/release/modules.pb.go @@ -158,15 +158,11 @@ func (m *DeleteReleaseResponse) GetResult() *Result { } type UpgradeReleaseRequest struct { - Current *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` - Target *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` - // Performs pods restart for resources if applicable - Recreate bool `protobuf:"varint,6,opt,name=recreate" json:"recreate,omitempty"` - // timeout specifies the max amount of time any kubernetes client command can run. - Timeout int64 `protobuf:"varint,7,opt,name=timeout" json:"timeout,omitempty"` - // wait, if true, will wait until all Pods, PVCs, and Services are in a ready state - // before marking the release as successful. It will wait for as long as timeout - Wait bool `protobuf:"varint,9,opt,name=wait" json:"wait,omitempty"` + Current *Release `protobuf:"bytes,1,opt,name=current" json:"current,omitempty"` + Target *Release `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` + Timeout int64 `protobuf:"varint,3,opt,name=Timeout" json:"Timeout,omitempty"` + Wait bool `protobuf:"varint,4,opt,name=Wait" json:"Wait,omitempty"` + Recreate bool `protobuf:"varint,5,opt,name=Recreate" json:"Recreate,omitempty"` } func (m *UpgradeReleaseRequest) Reset() { *m = UpgradeReleaseRequest{} } @@ -174,7 +170,14 @@ func (m *UpgradeReleaseRequest) String() string { return proto.Compac func (*UpgradeReleaseRequest) ProtoMessage() {} func (*UpgradeReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} } -func (m *UpgradeReleaseRequest) GetRelease() *Release { +func (m *UpgradeReleaseRequest) GetCurrent() *Release { + if m != nil { + return m.Current + } + return nil +} + +func (m *UpgradeReleaseRequest) GetTarget() *Release { if m != nil { return m.Target } @@ -475,34 +478,38 @@ var _ReleaseModuleService_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("hapi/release/modules.proto", fileDescriptor2) } var fileDescriptor2 = []byte{ - // 450 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x5d, 0x6b, 0xd4, 0x40, - 0x14, 0xdd, 0x0f, 0xdd, 0x25, 0x77, 0xad, 0x86, 0xcb, 0x66, 0x1b, 0xf2, 0x54, 0xa6, 0x0a, 0x7d, - 0x90, 0x2c, 0xac, 0xaf, 0xbe, 0xe8, 0x76, 0xed, 0x16, 0x31, 0x85, 0x09, 0xa9, 0x50, 0x10, 0x4c, - 0xdb, 0x6b, 0x0d, 0x4e, 0x33, 0x31, 0x93, 0xac, 0xfe, 0x66, 0x7f, 0x85, 0xe4, 0x4b, 0x9a, 0x31, - 0x54, 0x64, 0xcb, 0x3e, 0x65, 0x26, 0xf7, 0xe4, 0xe4, 0x9c, 0x3b, 0xf7, 0x0c, 0x38, 0x5f, 0xc3, - 0x24, 0x9a, 0xa7, 0x24, 0x28, 0x54, 0x34, 0xbf, 0x95, 0xd7, 0xb9, 0x20, 0xe5, 0x26, 0xa9, 0xcc, - 0x24, 0x3e, 0x29, 0x6a, 0x6e, 0x5d, 0x73, 0xda, 0xc8, 0xfa, 0x59, 0x21, 0x99, 0x80, 0x11, 0x27, - 0x95, 0x8b, 0x0c, 0x11, 0x1e, 0x45, 0xf1, 0x17, 0x69, 0xf7, 0x0f, 0xfa, 0x47, 0x06, 0x2f, 0xd7, - 0x68, 0xc2, 0x50, 0xc8, 0x1b, 0x7b, 0x70, 0x30, 0x3c, 0x32, 0x78, 0xb1, 0x64, 0xaf, 0x61, 0xe4, - 0x67, 0x61, 0x96, 0x2b, 0x9c, 0xc0, 0x38, 0xf0, 0xde, 0x7b, 0x67, 0x1f, 0x3d, 0xb3, 0x57, 0x6c, - 0xfc, 0x60, 0xb9, 0x5c, 0xf9, 0xbe, 0xd9, 0xc7, 0x3d, 0x30, 0x02, 0x6f, 0xb9, 0x7e, 0xe3, 0x9d, - 0xac, 0x8e, 0xcd, 0x01, 0x1a, 0xf0, 0x78, 0xc5, 0xf9, 0x19, 0x37, 0x87, 0x6c, 0x1f, 0xac, 0x73, - 0x4a, 0x55, 0x24, 0x63, 0x5e, 0xa9, 0xe0, 0xf4, 0x3d, 0x27, 0x95, 0xb1, 0x77, 0x30, 0xd3, 0x0b, - 0x2a, 0x91, 0xb1, 0xa2, 0x42, 0x56, 0x1c, 0xde, 0x52, 0x23, 0xab, 0x58, 0xa3, 0x0d, 0xe3, 0x4d, - 0x85, 0xb6, 0x07, 0xe5, 0xeb, 0x66, 0xcb, 0xd6, 0x60, 0x9d, 0xc6, 0x2a, 0x0b, 0x85, 0x68, 0xff, - 0x00, 0xe7, 0x30, 0xae, 0x8d, 0x97, 0x4c, 0x93, 0x85, 0xe5, 0xde, 0xed, 0x91, 0xdb, 0xc0, 0x1b, - 0x14, 0xfb, 0x01, 0x33, 0x9d, 0xa9, 0x56, 0xf4, 0xbf, 0x54, 0xf8, 0x12, 0x46, 0x69, 0xd9, 0xe3, - 0x52, 0xed, 0x64, 0x31, 0xd5, 0xf1, 0x45, 0x8d, 0xd7, 0x18, 0x76, 0x02, 0xd3, 0x63, 0x12, 0x94, - 0xd1, 0xb6, 0x0e, 0x36, 0x60, 0x69, 0x44, 0xbb, 0x31, 0xb0, 0x06, 0x2b, 0x48, 0x6e, 0xd2, 0xf0, - 0x9a, 0x1e, 0xe0, 0x0c, 0x74, 0xa6, 0xdd, 0x58, 0x38, 0x85, 0x19, 0x97, 0x42, 0x5c, 0x86, 0x57, - 0xdf, 0xb6, 0xf5, 0xf0, 0x13, 0xf6, 0xff, 0xa2, 0xda, 0x89, 0x89, 0xc5, 0xaf, 0x21, 0x4c, 0x6b, - 0x8a, 0x0f, 0xe5, 0xed, 0xe0, 0x53, 0xba, 0x89, 0xae, 0x08, 0xcf, 0x61, 0x5c, 0x87, 0x0d, 0x0f, - 0xdb, 0x0c, 0x9d, 0xe1, 0x74, 0x9e, 0xdf, 0x0f, 0xaa, 0xdc, 0xb0, 0x1e, 0x7e, 0x82, 0xa7, 0xed, - 0xc8, 0xe8, 0xf4, 0x9d, 0xd1, 0xd4, 0xe9, 0xbb, 0x53, 0xc7, 0x7a, 0x78, 0x01, 0x7b, 0xad, 0x79, - 0x46, 0xd6, 0xfe, 0xb0, 0x2b, 0x35, 0xce, 0xe1, 0xbd, 0x98, 0x3f, 0xdc, 0x9f, 0xe1, 0x99, 0x76, - 0x4a, 0xa8, 0xc9, 0xea, 0x9e, 0x07, 0xe7, 0xc5, 0x3f, 0x50, 0x77, 0x9b, 0xd3, 0x9e, 0x65, 0xbd, - 0x39, 0x9d, 0x99, 0xd1, 0x9b, 0xd3, 0x1d, 0x07, 0xd6, 0x7b, 0x6b, 0x5c, 0x34, 0x53, 0x72, 0x39, - 0x2a, 0x6f, 0xf6, 0x57, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x89, 0x83, 0xd3, 0x0a, 0x21, 0x06, - 0x00, 0x00, + // 520 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x55, 0x51, 0x6f, 0xd3, 0x30, + 0x10, 0x6e, 0x9a, 0xad, 0x5d, 0xae, 0x0c, 0x22, 0xab, 0xe9, 0xa2, 0x3c, 0x55, 0x1e, 0x48, 0x7d, + 0x80, 0x56, 0x2a, 0xaf, 0xbc, 0x40, 0x57, 0xb6, 0x09, 0x91, 0x49, 0x0e, 0xdd, 0xa4, 0x49, 0x48, + 0x78, 0xdd, 0x51, 0x22, 0xdc, 0xa4, 0x38, 0x4e, 0xe1, 0xef, 0xf1, 0x77, 0xf8, 0x15, 0x28, 0x69, + 0x32, 0x2d, 0x26, 0x6c, 0x9a, 0x26, 0xf5, 0xa9, 0x3e, 0xdf, 0xd7, 0xcf, 0xf7, 0x9d, 0xef, 0x73, + 0xc0, 0xfb, 0xc6, 0x57, 0xe1, 0x48, 0xa2, 0x40, 0x9e, 0xe0, 0x68, 0x19, 0x5f, 0xa7, 0x02, 0x93, + 0xe1, 0x4a, 0xc6, 0x2a, 0x26, 0x4f, 0xb2, 0xdc, 0xb0, 0xc8, 0x79, 0x55, 0x64, 0xf1, 0xbb, 0x41, + 0x52, 0x01, 0x2d, 0x86, 0x49, 0x2a, 0x14, 0x21, 0xb0, 0x13, 0x46, 0x5f, 0x63, 0xd7, 0xe8, 0x1b, + 0x03, 0x8b, 0xe5, 0x6b, 0x62, 0x83, 0x29, 0xe2, 0x85, 0xdb, 0xec, 0x9b, 0x03, 0x8b, 0x65, 0x4b, + 0xfa, 0x06, 0x5a, 0x81, 0xe2, 0x2a, 0x4d, 0x48, 0x07, 0xda, 0x33, 0xff, 0x83, 0x7f, 0x76, 0xe1, + 0xdb, 0x8d, 0x2c, 0x08, 0x66, 0x93, 0xc9, 0x34, 0x08, 0x6c, 0x83, 0xec, 0x83, 0x35, 0xf3, 0x27, + 0x27, 0x6f, 0xfd, 0xe3, 0xe9, 0x91, 0xdd, 0x24, 0x16, 0xec, 0x4e, 0x19, 0x3b, 0x63, 0xb6, 0x49, + 0x0f, 0xc0, 0x39, 0x47, 0x99, 0x84, 0x71, 0xc4, 0x36, 0x55, 0x30, 0xfc, 0x91, 0x62, 0xa2, 0xe8, + 0x7b, 0xe8, 0xe9, 0x89, 0x64, 0x15, 0x47, 0x09, 0x66, 0x65, 0x45, 0x7c, 0x89, 0x65, 0x59, 0xd9, + 0x9a, 0xb8, 0xd0, 0x5e, 0x6f, 0xd0, 0x6e, 0x33, 0xdf, 0x2e, 0x43, 0x7a, 0x02, 0xce, 0x69, 0x94, + 0x28, 0x2e, 0x44, 0xf5, 0x00, 0x32, 0x82, 0x76, 0x21, 0x3c, 0x67, 0xea, 0x8c, 0x9d, 0xe1, 0xed, + 0x1e, 0x0d, 0x4b, 0x78, 0x89, 0xa2, 0x3f, 0xa1, 0xa7, 0x33, 0x15, 0x15, 0x3d, 0x94, 0x8a, 0xbc, + 0x84, 0x96, 0xcc, 0x7b, 0x9c, 0x57, 0xdb, 0x19, 0x77, 0x75, 0x7c, 0x96, 0x63, 0x05, 0x86, 0x1e, + 0x43, 0xf7, 0x08, 0x05, 0x2a, 0x7c, 0xac, 0x82, 0x35, 0x38, 0x1a, 0xd1, 0x76, 0x04, 0xfc, 0x36, + 0xc0, 0x99, 0xad, 0x16, 0x92, 0x5f, 0xd7, 0x48, 0x98, 0xa7, 0x52, 0x62, 0xa4, 0xee, 0x39, 0xb8, + 0x40, 0x91, 0x57, 0xd0, 0x52, 0x5c, 0x2e, 0xb0, 0x3c, 0xf8, 0x3f, 0xf8, 0x02, 0x94, 0xcd, 0xc5, + 0xa7, 0x70, 0x89, 0x71, 0xaa, 0x5c, 0xb3, 0x6f, 0x0c, 0x4c, 0x56, 0x86, 0xd9, 0x14, 0x5d, 0xf0, + 0x50, 0xb9, 0x3b, 0x7d, 0x63, 0xb0, 0xc7, 0xf2, 0x35, 0xf1, 0x60, 0x8f, 0xe1, 0x5c, 0x22, 0x57, + 0xe8, 0xee, 0xe6, 0xfb, 0x37, 0x71, 0x76, 0xfb, 0xba, 0x84, 0xed, 0x34, 0xef, 0x14, 0x7a, 0x2c, + 0x16, 0xe2, 0x8a, 0xcf, 0xbf, 0x3f, 0xf6, 0xfe, 0x7f, 0xc1, 0xc1, 0x3f, 0x54, 0x5b, 0x11, 0x31, + 0xfe, 0x63, 0x42, 0xb7, 0xa0, 0xf8, 0x98, 0xbf, 0x4b, 0x01, 0xca, 0x75, 0x38, 0x47, 0x72, 0x0e, + 0xed, 0xc2, 0xe6, 0xe4, 0xb0, 0xca, 0x50, 0xfb, 0x2c, 0x78, 0xcf, 0xef, 0x06, 0x6d, 0xd4, 0xd0, + 0x06, 0xf9, 0x0c, 0x4f, 0xab, 0x66, 0xd5, 0xe9, 0x6b, 0x1f, 0x05, 0x9d, 0xbe, 0xde, 0xef, 0xb4, + 0x41, 0x2e, 0x61, 0xbf, 0xe2, 0x24, 0x42, 0xab, 0x7f, 0xac, 0xf3, 0xab, 0x77, 0x78, 0x27, 0xe6, + 0x86, 0xfb, 0x0b, 0x3c, 0xd3, 0x6e, 0x89, 0x68, 0x65, 0xd5, 0xcf, 0x83, 0xf7, 0xe2, 0x1e, 0xd4, + 0xed, 0xe6, 0x54, 0x67, 0x59, 0x6f, 0x4e, 0xad, 0x59, 0xf5, 0xe6, 0xd4, 0xdb, 0x81, 0x36, 0xde, + 0x59, 0x97, 0xe5, 0x94, 0x5c, 0xb5, 0xf2, 0x6f, 0xca, 0xeb, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, + 0x28, 0x24, 0xf8, 0xab, 0x9b, 0x06, 0x00, 0x00, } diff --git a/pkg/proto/hapi/release/release.pb.go b/pkg/proto/hapi/release/release.pb.go index f58ce1502..80c3dd4d7 100644 --- a/pkg/proto/hapi/release/release.pb.go +++ b/pkg/proto/hapi/release/release.pb.go @@ -106,7 +106,7 @@ func init() { proto.RegisterFile("hapi/release/release.proto", fileDescriptor3) var fileDescriptor3 = []byte{ // 256 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xbf, 0x4e, 0xc3, 0x40, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 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 71ed631c8..d2e89d692 100644 --- a/pkg/proto/hapi/release/status.pb.go +++ b/pkg/proto/hapi/release/status.pb.go @@ -106,7 +106,7 @@ func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor4) } var fileDescriptor4 = []byte{ // 291 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xdf, 0x6a, 0xc2, 0x30, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 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 a40a410f8..b680f5a22 100644 --- a/pkg/proto/hapi/release/test_run.pb.go +++ b/pkg/proto/hapi/release/test_run.pb.go @@ -95,7 +95,7 @@ func init() { proto.RegisterFile("hapi/release/test_run.proto", fileDescriptor5) var fileDescriptor5 = []byte{ // 265 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x41, 0x4b, 0xfb, 0x40, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0x41, 0x4b, 0xfb, 0x40, 0x14, 0xc4, 0xff, 0xc9, 0xbf, 0x26, 0x64, 0x53, 0x24, 0xec, 0x29, 0x54, 0xc1, 0xd0, 0x53, 0x4e, 0xbb, 0x50, 0xbd, 0x78, 0xf0, 0x10, 0x4b, 0x05, 0x51, 0x22, 0x6c, 0x1a, 0x04, 0x2f, 0x65, 0xab, 0xaf, 0x35, 0x90, 0x64, 0x43, 0xf6, 0xe5, 0x8b, 0xf8, 0x89, 0x65, 0x93, 0xad, 0x78, 0xf3, 0xf6, diff --git a/pkg/proto/hapi/release/test_suite.pb.go b/pkg/proto/hapi/release/test_suite.pb.go index 304cded78..a7e7cde17 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 fileDescriptor6 = []byte{ // 207 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0xc1, 0x4a, 0x86, 0x40, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0xc1, 0x4a, 0x86, 0x40, 0x14, 0x85, 0x31, 0x21, 0x71, 0x74, 0x35, 0x10, 0x88, 0x11, 0x49, 0x2b, 0x57, 0x33, 0x60, 0xab, 0x16, 0x2d, 0xec, 0x11, 0xcc, 0x55, 0x1b, 0x19, 0xeb, 0x66, 0xc2, 0xe8, 0x0c, 0x73, 0xef, 0xbc, 0x5a, 0xcf, 0x17, 0xea, 0x18, 0x41, 0x8b, 0x7f, 0xfd, 0x7d, 0xe7, 0x9c, 0x7b, 0xd9, 0xdd, 0x97, diff --git a/pkg/proto/hapi/version/version.pb.go b/pkg/proto/hapi/version/version.pb.go index e3d8a7096..b8a711561 100644 --- a/pkg/proto/hapi/version/version.pb.go +++ b/pkg/proto/hapi/version/version.pb.go @@ -69,7 +69,7 @@ func init() { proto.RegisterFile("hapi/version/version.proto", fileDescriptor0) var fileDescriptor0 = []byte{ // 151 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xca, 0x48, 0x2c, 0xc8, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xca, 0x48, 0x2c, 0xc8, 0xd4, 0x2f, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0x83, 0xd1, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x3c, 0x20, 0x39, 0x3d, 0xa8, 0x98, 0x52, 0x3a, 0x17, 0x7b, 0x18, 0x84, 0x29, 0x24, 0xce, 0xc5, 0x5e, 0x9c, 0x9a, 0x1b, 0x5f, 0x96, 0x5a, 0x24, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0xc4, From bd47b8444f30b5cef2dfde9f69e0d7ec9fd795ea Mon Sep 17 00:00:00 2001 From: Dmitry Shulyak Date: Thu, 16 Mar 2017 15:00:25 +0200 Subject: [PATCH 07/12] Use rollback method on ReleaseModule interface --- _proto/hapi/release/modules.proto | 8 ++- cmd/rudder/rudder.go | 5 +- pkg/proto/hapi/release/modules.pb.go | 85 ++++++++++++++++------------ pkg/rudder/client.go | 23 +++++--- pkg/tiller/release_modules.go | 24 +++++++- pkg/tiller/release_server.go | 10 +++- 6 files changed, 103 insertions(+), 52 deletions(-) diff --git a/_proto/hapi/release/modules.proto b/_proto/hapi/release/modules.proto index ab99c4b75..4f0709a02 100644 --- a/_proto/hapi/release/modules.proto +++ b/_proto/hapi/release/modules.proto @@ -67,7 +67,7 @@ message DeleteReleaseResponse { } message UpgradeReleaseRequest{ - hapi.release.Release current = 1; + hapi.release.Release current = 1; hapi.release.Release target = 2; int64 Timeout = 3; bool Wait = 4; @@ -79,7 +79,11 @@ message UpgradeReleaseResponse{ } message RollbackReleaseRequest{ - hapi.release.Release release = 1; + hapi.release.Release current = 1; + hapi.release.Release target = 2; + int64 Timeout = 3; + bool Wait = 4; + bool Recreate = 5; } message RollbackReleaseResponse{ hapi.release.Release release = 1; diff --git a/cmd/rudder/rudder.go b/cmd/rudder/rudder.go index 71f5325d1..2b056c692 100644 --- a/cmd/rudder/rudder.go +++ b/cmd/rudder/rudder.go @@ -78,7 +78,10 @@ func (r *ReleaseModuleServiceServer) DeleteRelease(ctx context.Context, in *rele // RollbackRelease is not implemented func (r *ReleaseModuleServiceServer) RollbackRelease(ctx context.Context, in *release.RollbackReleaseRequest) (*release.RollbackReleaseResponse, error) { grpclog.Print("rollback") - return nil, nil + c := bytes.NewBufferString(in.Current.Manifest) + t := bytes.NewBufferString(in.Target.Manifest) + err := kubeClient.Update(in.Target.Namespace, c, t, in.Recreate, in.Timeout, in.Wait) + return &release.RollbackReleaseResponse{}, err } // UpgradeRelease upgrades manifests using kubernetes client diff --git a/pkg/proto/hapi/release/modules.pb.go b/pkg/proto/hapi/release/modules.pb.go index bab0b9915..fa627f42b 100644 --- a/pkg/proto/hapi/release/modules.pb.go +++ b/pkg/proto/hapi/release/modules.pb.go @@ -209,7 +209,11 @@ func (m *UpgradeReleaseResponse) GetResult() *Result { } type RollbackReleaseRequest struct { - Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Current *Release `protobuf:"bytes,1,opt,name=current" json:"current,omitempty"` + Target *Release `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` + Timeout int64 `protobuf:"varint,3,opt,name=Timeout" json:"Timeout,omitempty"` + Wait bool `protobuf:"varint,4,opt,name=Wait" json:"Wait,omitempty"` + Recreate bool `protobuf:"varint,5,opt,name=Recreate" json:"Recreate,omitempty"` } func (m *RollbackReleaseRequest) Reset() { *m = RollbackReleaseRequest{} } @@ -217,9 +221,16 @@ func (m *RollbackReleaseRequest) String() string { return proto.Compa func (*RollbackReleaseRequest) ProtoMessage() {} func (*RollbackReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} } -func (m *RollbackReleaseRequest) GetRelease() *Release { +func (m *RollbackReleaseRequest) GetCurrent() *Release { if m != nil { - return m.Release + return m.Current + } + return nil +} + +func (m *RollbackReleaseRequest) GetTarget() *Release { + if m != nil { + return m.Target } return nil } @@ -478,38 +489,38 @@ var _ReleaseModuleService_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("hapi/release/modules.proto", fileDescriptor2) } var fileDescriptor2 = []byte{ - // 520 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x55, 0x51, 0x6f, 0xd3, 0x30, - 0x10, 0x6e, 0x9a, 0xad, 0x5d, 0xae, 0x0c, 0x22, 0xab, 0xe9, 0xa2, 0x3c, 0x55, 0x1e, 0x48, 0x7d, - 0x80, 0x56, 0x2a, 0xaf, 0xbc, 0x40, 0x57, 0xb6, 0x09, 0x91, 0x49, 0x0e, 0xdd, 0xa4, 0x49, 0x48, - 0x78, 0xdd, 0x51, 0x22, 0xdc, 0xa4, 0x38, 0x4e, 0xe1, 0xef, 0xf1, 0x77, 0xf8, 0x15, 0x28, 0x69, - 0x32, 0x2d, 0x26, 0x6c, 0x9a, 0x26, 0xf5, 0xa9, 0x3e, 0xdf, 0xd7, 0xcf, 0xf7, 0x9d, 0xef, 0x73, - 0xc0, 0xfb, 0xc6, 0x57, 0xe1, 0x48, 0xa2, 0x40, 0x9e, 0xe0, 0x68, 0x19, 0x5f, 0xa7, 0x02, 0x93, - 0xe1, 0x4a, 0xc6, 0x2a, 0x26, 0x4f, 0xb2, 0xdc, 0xb0, 0xc8, 0x79, 0x55, 0x64, 0xf1, 0xbb, 0x41, - 0x52, 0x01, 0x2d, 0x86, 0x49, 0x2a, 0x14, 0x21, 0xb0, 0x13, 0x46, 0x5f, 0x63, 0xd7, 0xe8, 0x1b, - 0x03, 0x8b, 0xe5, 0x6b, 0x62, 0x83, 0x29, 0xe2, 0x85, 0xdb, 0xec, 0x9b, 0x03, 0x8b, 0x65, 0x4b, - 0xfa, 0x06, 0x5a, 0x81, 0xe2, 0x2a, 0x4d, 0x48, 0x07, 0xda, 0x33, 0xff, 0x83, 0x7f, 0x76, 0xe1, - 0xdb, 0x8d, 0x2c, 0x08, 0x66, 0x93, 0xc9, 0x34, 0x08, 0x6c, 0x83, 0xec, 0x83, 0x35, 0xf3, 0x27, - 0x27, 0x6f, 0xfd, 0xe3, 0xe9, 0x91, 0xdd, 0x24, 0x16, 0xec, 0x4e, 0x19, 0x3b, 0x63, 0xb6, 0x49, - 0x0f, 0xc0, 0x39, 0x47, 0x99, 0x84, 0x71, 0xc4, 0x36, 0x55, 0x30, 0xfc, 0x91, 0x62, 0xa2, 0xe8, - 0x7b, 0xe8, 0xe9, 0x89, 0x64, 0x15, 0x47, 0x09, 0x66, 0x65, 0x45, 0x7c, 0x89, 0x65, 0x59, 0xd9, - 0x9a, 0xb8, 0xd0, 0x5e, 0x6f, 0xd0, 0x6e, 0x33, 0xdf, 0x2e, 0x43, 0x7a, 0x02, 0xce, 0x69, 0x94, - 0x28, 0x2e, 0x44, 0xf5, 0x00, 0x32, 0x82, 0x76, 0x21, 0x3c, 0x67, 0xea, 0x8c, 0x9d, 0xe1, 0xed, - 0x1e, 0x0d, 0x4b, 0x78, 0x89, 0xa2, 0x3f, 0xa1, 0xa7, 0x33, 0x15, 0x15, 0x3d, 0x94, 0x8a, 0xbc, - 0x84, 0x96, 0xcc, 0x7b, 0x9c, 0x57, 0xdb, 0x19, 0x77, 0x75, 0x7c, 0x96, 0x63, 0x05, 0x86, 0x1e, - 0x43, 0xf7, 0x08, 0x05, 0x2a, 0x7c, 0xac, 0x82, 0x35, 0x38, 0x1a, 0xd1, 0x76, 0x04, 0xfc, 0x36, - 0xc0, 0x99, 0xad, 0x16, 0x92, 0x5f, 0xd7, 0x48, 0x98, 0xa7, 0x52, 0x62, 0xa4, 0xee, 0x39, 0xb8, - 0x40, 0x91, 0x57, 0xd0, 0x52, 0x5c, 0x2e, 0xb0, 0x3c, 0xf8, 0x3f, 0xf8, 0x02, 0x94, 0xcd, 0xc5, - 0xa7, 0x70, 0x89, 0x71, 0xaa, 0x5c, 0xb3, 0x6f, 0x0c, 0x4c, 0x56, 0x86, 0xd9, 0x14, 0x5d, 0xf0, - 0x50, 0xb9, 0x3b, 0x7d, 0x63, 0xb0, 0xc7, 0xf2, 0x35, 0xf1, 0x60, 0x8f, 0xe1, 0x5c, 0x22, 0x57, - 0xe8, 0xee, 0xe6, 0xfb, 0x37, 0x71, 0x76, 0xfb, 0xba, 0x84, 0xed, 0x34, 0xef, 0x14, 0x7a, 0x2c, - 0x16, 0xe2, 0x8a, 0xcf, 0xbf, 0x3f, 0xf6, 0xfe, 0x7f, 0xc1, 0xc1, 0x3f, 0x54, 0x5b, 0x11, 0x31, - 0xfe, 0x63, 0x42, 0xb7, 0xa0, 0xf8, 0x98, 0xbf, 0x4b, 0x01, 0xca, 0x75, 0x38, 0x47, 0x72, 0x0e, - 0xed, 0xc2, 0xe6, 0xe4, 0xb0, 0xca, 0x50, 0xfb, 0x2c, 0x78, 0xcf, 0xef, 0x06, 0x6d, 0xd4, 0xd0, - 0x06, 0xf9, 0x0c, 0x4f, 0xab, 0x66, 0xd5, 0xe9, 0x6b, 0x1f, 0x05, 0x9d, 0xbe, 0xde, 0xef, 0xb4, - 0x41, 0x2e, 0x61, 0xbf, 0xe2, 0x24, 0x42, 0xab, 0x7f, 0xac, 0xf3, 0xab, 0x77, 0x78, 0x27, 0xe6, - 0x86, 0xfb, 0x0b, 0x3c, 0xd3, 0x6e, 0x89, 0x68, 0x65, 0xd5, 0xcf, 0x83, 0xf7, 0xe2, 0x1e, 0xd4, - 0xed, 0xe6, 0x54, 0x67, 0x59, 0x6f, 0x4e, 0xad, 0x59, 0xf5, 0xe6, 0xd4, 0xdb, 0x81, 0x36, 0xde, - 0x59, 0x97, 0xe5, 0x94, 0x5c, 0xb5, 0xf2, 0x6f, 0xca, 0xeb, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, - 0x28, 0x24, 0xf8, 0xab, 0x9b, 0x06, 0x00, 0x00, + // 523 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x55, 0xc1, 0x6e, 0xd3, 0x40, + 0x10, 0x8d, 0xe3, 0x36, 0xa9, 0x27, 0x14, 0xac, 0x55, 0x9c, 0x5a, 0x3e, 0x45, 0x5b, 0x90, 0x72, + 0x80, 0x44, 0x0a, 0x57, 0x2e, 0x90, 0x86, 0x16, 0x21, 0x5c, 0x69, 0x4d, 0x5a, 0xa9, 0x12, 0x12, + 0xdb, 0x74, 0x08, 0x16, 0x1b, 0x3b, 0xac, 0xd7, 0x81, 0xdf, 0x83, 0xcf, 0xe1, 0x2b, 0x90, 0x1d, + 0xbb, 0xaa, 0x17, 0xd3, 0x0a, 0x21, 0x45, 0xea, 0x29, 0x33, 0x9e, 0x97, 0xb7, 0x33, 0xcf, 0xb3, + 0xcf, 0xe0, 0x7d, 0xe6, 0xab, 0x70, 0x24, 0x51, 0x20, 0x4f, 0x70, 0xb4, 0x8c, 0xaf, 0x52, 0x81, + 0xc9, 0x70, 0x25, 0x63, 0x15, 0x93, 0x07, 0x59, 0x6d, 0x58, 0xd4, 0xbc, 0x2a, 0xb2, 0xf8, 0xdd, + 0x20, 0xa9, 0x80, 0x16, 0xc3, 0x24, 0x15, 0x8a, 0x10, 0xd8, 0x09, 0xa3, 0x4f, 0xb1, 0x6b, 0xf4, + 0x8d, 0x81, 0xc5, 0xf2, 0x98, 0xd8, 0x60, 0x8a, 0x78, 0xe1, 0x36, 0xfb, 0xe6, 0xc0, 0x62, 0x59, + 0x48, 0x5f, 0x40, 0x2b, 0x50, 0x5c, 0xa5, 0x09, 0xe9, 0x40, 0x7b, 0xe6, 0xbf, 0xf5, 0x4f, 0xcf, + 0x7d, 0xbb, 0x91, 0x25, 0xc1, 0x6c, 0x32, 0x99, 0x06, 0x81, 0x6d, 0x90, 0x7d, 0xb0, 0x66, 0xfe, + 0xe4, 0xe4, 0xa5, 0x7f, 0x3c, 0x3d, 0xb2, 0x9b, 0xc4, 0x82, 0xdd, 0x29, 0x63, 0xa7, 0xcc, 0x36, + 0xe9, 0x01, 0x38, 0x67, 0x28, 0x93, 0x30, 0x8e, 0xd8, 0xa6, 0x0b, 0x86, 0x5f, 0x53, 0x4c, 0x14, + 0x7d, 0x0d, 0x3d, 0xbd, 0x90, 0xac, 0xe2, 0x28, 0xc1, 0xac, 0xad, 0x88, 0x2f, 0xb1, 0x6c, 0x2b, + 0x8b, 0x89, 0x0b, 0xed, 0xf5, 0x06, 0xed, 0x36, 0xf3, 0xc7, 0x65, 0x4a, 0x4f, 0xc0, 0x79, 0x13, + 0x25, 0x8a, 0x0b, 0x51, 0x3d, 0x80, 0x8c, 0xa0, 0x5d, 0x0c, 0x9e, 0x33, 0x75, 0xc6, 0xce, 0xf0, + 0xa6, 0x46, 0xc3, 0x12, 0x5e, 0xa2, 0xe8, 0x37, 0xe8, 0xe9, 0x4c, 0x45, 0x47, 0xff, 0x4a, 0x45, + 0x9e, 0x42, 0x4b, 0xe6, 0x1a, 0xe7, 0xdd, 0x76, 0xc6, 0x5d, 0x1d, 0x9f, 0xd5, 0x58, 0x81, 0xa1, + 0xc7, 0xd0, 0x3d, 0x42, 0x81, 0x0a, 0xff, 0x77, 0x82, 0x35, 0x38, 0x1a, 0xd1, 0x76, 0x06, 0xf8, + 0x61, 0x80, 0x33, 0x5b, 0x2d, 0x24, 0xbf, 0xaa, 0x19, 0x61, 0x9e, 0x4a, 0x89, 0x91, 0xba, 0xe3, + 0xe0, 0x02, 0x45, 0x9e, 0x41, 0x4b, 0x71, 0xb9, 0xc0, 0xf2, 0xe0, 0xbf, 0xe0, 0x0b, 0x50, 0xb6, + 0x17, 0xef, 0xc3, 0x25, 0xc6, 0xa9, 0x72, 0xcd, 0xbe, 0x31, 0x30, 0x59, 0x99, 0x66, 0x5b, 0x74, + 0xce, 0x43, 0xe5, 0xee, 0xf4, 0x8d, 0xc1, 0x1e, 0xcb, 0x63, 0xe2, 0xc1, 0x1e, 0xc3, 0xb9, 0x44, + 0xae, 0xd0, 0xdd, 0xcd, 0x9f, 0x5f, 0xe7, 0xd9, 0xdb, 0xd7, 0x47, 0xd8, 0x8e, 0x78, 0x3f, 0x0d, + 0xe8, 0xb1, 0x58, 0x88, 0x4b, 0x3e, 0xff, 0x72, 0x6f, 0xd5, 0xfb, 0x0e, 0x07, 0x7f, 0xcc, 0xb0, + 0x15, 0xf9, 0xc6, 0xbf, 0x4c, 0xe8, 0x16, 0x14, 0xef, 0x72, 0x47, 0x0c, 0x50, 0xae, 0xc3, 0x39, + 0x92, 0x33, 0x68, 0x17, 0x06, 0x43, 0x0e, 0xab, 0x0c, 0xb5, 0x86, 0xe4, 0x3d, 0xbe, 0x1d, 0xb4, + 0x99, 0x86, 0x36, 0xc8, 0x07, 0x78, 0x58, 0xb5, 0x09, 0x9d, 0xbe, 0xd6, 0x8e, 0x74, 0xfa, 0x7a, + 0xa7, 0xa1, 0x0d, 0x72, 0x01, 0xfb, 0x95, 0x3b, 0x4c, 0x68, 0xf5, 0x8f, 0x75, 0x4e, 0xe1, 0x1d, + 0xde, 0x8a, 0xb9, 0xe6, 0xfe, 0x08, 0x8f, 0xb4, 0xb7, 0x44, 0xb4, 0xb6, 0xea, 0x17, 0xd1, 0x7b, + 0x72, 0x07, 0xea, 0xa6, 0x38, 0xd5, 0x5b, 0xa4, 0x8b, 0x53, 0x6b, 0x13, 0xba, 0x38, 0xf5, 0x17, + 0x91, 0x36, 0x5e, 0x59, 0x17, 0xe5, 0x96, 0x5c, 0xb6, 0xf2, 0xaf, 0xd9, 0xf3, 0xdf, 0x01, 0x00, + 0x00, 0xff, 0xff, 0x6c, 0xb6, 0x1e, 0x06, 0x15, 0x07, 0x00, 0x00, } diff --git a/pkg/rudder/client.go b/pkg/rudder/client.go index 1583ac69b..af1e5dd45 100644 --- a/pkg/rudder/client.go +++ b/pkg/rudder/client.go @@ -17,21 +17,19 @@ limitations under the License. package rudder // import "k8s.io/helm/pkg/rudder" import ( - "fmt" - "golang.org/x/net/context" "google.golang.org/grpc" "k8s.io/helm/pkg/proto/hapi/release" ) -// GrpcAddr is port number for accessing Rudder service -var GrpcAddr = 10001 +// GrpcAddr is an address that should be used to access Rudder service +const GrpcAddr = "127.0.0.1:10001" // InstallRelease calls Rudder InstallRelease method which should create provided release func InstallRelease(rel *release.InstallReleaseRequest) (*release.InstallReleaseResponse, error) { //TODO(mkwiek): parametrize this - conn, err := grpc.Dial(fmt.Sprintf("127.0.0.1:%d", GrpcAddr), grpc.WithInsecure()) + conn, err := grpc.Dial(GrpcAddr, grpc.WithInsecure()) if err != nil { return nil, err } @@ -41,9 +39,9 @@ func InstallRelease(rel *release.InstallReleaseRequest) (*release.InstallRelease return client.InstallRelease(context.Background(), rel) } -// UpgradeReleas calls Rudder UpgradeRelease method which should perform update +// UpgradeRelease calls Rudder UpgradeRelease method which should perform update func UpgradeRelease(req *release.UpgradeReleaseRequest) (*release.UpgradeReleaseResponse, error) { - conn, err := grpc.Dial(fmt.Sprintf("127.0.0.1:%d", GrpcAddr), grpc.WithInsecure()) + conn, err := grpc.Dial(GrpcAddr, grpc.WithInsecure()) if err != nil { return nil, err } @@ -51,3 +49,14 @@ func UpgradeRelease(req *release.UpgradeReleaseRequest) (*release.UpgradeRelease client := release.NewReleaseModuleServiceClient(conn) return client.UpgradeRelease(context.Background(), req) } + +// RollbackRelease calls Rudder RollbackRelease method which should perform update +func RollbackRelease(req *release.RollbackReleaseRequest) (*release.RollbackReleaseResponse, error) { + conn, err := grpc.Dial(GrpcAddr, grpc.WithInsecure()) + if err != nil { + return nil, err + } + defer conn.Close() + client := release.NewReleaseModuleServiceClient(conn) + return client.RollbackRelease(context.Background(), req) +} diff --git a/pkg/tiller/release_modules.go b/pkg/tiller/release_modules.go index a377527f6..755e7a66f 100644 --- a/pkg/tiller/release_modules.go +++ b/pkg/tiller/release_modules.go @@ -29,6 +29,7 @@ import ( type ReleaseModule interface { Create(r *release.Release, req *services.InstallReleaseRequest, env *environment.Environment) error Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error + Rollback(current, target *release.Release, req *services.RollbackReleaseRequest, env *environment.Environment) error } // LocalReleaseModule is a local implementation of ReleaseModule @@ -46,6 +47,12 @@ func (m *LocalReleaseModule) Update(current, target *release.Release, req *servi return env.KubeClient.Update(target.Namespace, c, t, req.Recreate, req.Timeout, req.Wait) } +func (m *LocalReleaseModule) Rollback(current, target *release.Release, req *services.RollbackReleaseRequest, env *environment.Environment) error { + c := bytes.NewBufferString(current.Manifest) + t := bytes.NewBufferString(target.Manifest) + return env.KubeClient.Update(target.Namespace, c, t, req.Recreate, req.Timeout, req.Wait) +} + // RemoteReleaseModule is a ReleaseModule which calls Rudder service to operate on a release type RemoteReleaseModule struct{} @@ -58,13 +65,26 @@ func (m *RemoteReleaseModule) Create(r *release.Release, req *services.InstallRe // Update calls rudder.UpgradeRelease func (m *RemoteReleaseModule) Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error { - req := &release.UpgradeReleaseRequest{ + upgrade := &release.UpgradeReleaseRequest{ + Current: current, + Target: target, + Recreate: req.Recreate, + Timeout: req.Timeout, + Wait: req.Wait, + } + _, err := rudder.UpgradeRelease(upgrade) + return err +} + +// Rollback calls rudder.Rollback +func (m *RemoteReleaseModule) Rollback(current, target *release.Release, req *services.RollbackReleaseRequest, env *environment.Environment) error { + rollback := &release.RollbackReleaseRequest{ Current: current, Target: target, Recreate: req.Recreate, Timeout: req.Timeout, Wait: req.Wait, } - _, err := rudder.UpgradeRelease(req) + _, err := rudder.RollbackRelease(rollback) return err } diff --git a/pkg/tiller/release_server.go b/pkg/tiller/release_server.go index ea5cafd02..962b8bd90 100644 --- a/pkg/tiller/release_server.go +++ b/pkg/tiller/release_server.go @@ -519,7 +519,7 @@ func (s *ReleaseServer) performRollback(currentRelease, targetRelease *release.R } } - if err := s.ReleaseModule.Update(currentRelease, targetRelease, req); err != nil { + if err := s.ReleaseModule.Rollback(currentRelease, targetRelease, req, s.env); err != nil { msg := fmt.Sprintf("Rollback %q failed: %s", targetRelease.Name, err) log.Printf("warning: %s", msg) currentRelease.Info.Status.Code = release.Status_SUPERSEDED @@ -893,8 +893,12 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install // update new release with next revision number // so as to append to the old release's history r.Version = old.Version + 1 - - if err := s.ReleaseModule.Update(old, r, req, s.env); err != nil { + updateReq := &services.UpdateReleaseRequest{ + Wait: req.Wait, + Recreate: false, + Timeout: req.Timeout, + } + if err := s.ReleaseModule.Update(old, r, updateReq, s.env); 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 From 3cba189f53e78f64cc007e210ec32f760ab75c9f Mon Sep 17 00:00:00 2001 From: Dmitry Shulyak Date: Fri, 17 Mar 2017 10:49:38 +0200 Subject: [PATCH 08/12] Define both rudder port and rudder address for different needs --- cmd/rudder/rudder.go | 2 +- pkg/rudder/client.go | 16 +++++++++++----- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/cmd/rudder/rudder.go b/cmd/rudder/rudder.go index 2b056c692..9169c2ce9 100644 --- a/cmd/rudder/rudder.go +++ b/cmd/rudder/rudder.go @@ -34,7 +34,7 @@ import ( var kubeClient = kube.New(nil) func main() { - lis, err := net.Listen("tcp", fmt.Sprintf(":%d", rudder.GrpcAddr)) + lis, err := net.Listen("tcp", fmt.Sprintf(":%d", rudder.GrpcPort)) if err != nil { grpclog.Fatalf("failed to listen: %v", err) } diff --git a/pkg/rudder/client.go b/pkg/rudder/client.go index af1e5dd45..694095ef8 100644 --- a/pkg/rudder/client.go +++ b/pkg/rudder/client.go @@ -17,19 +17,25 @@ limitations under the License. package rudder // import "k8s.io/helm/pkg/rudder" import ( + "fmt" + "golang.org/x/net/context" "google.golang.org/grpc" "k8s.io/helm/pkg/proto/hapi/release" ) -// GrpcAddr is an address that should be used to access Rudder service -const GrpcAddr = "127.0.0.1:10001" +// GrpcPort specifies port on which rudder will spawn a server +const ( + GrpcPort = 10001 +) + +var grpcAddr = fmt.Sprintf("127.0.0.1:%d", GrpcPort) // InstallRelease calls Rudder InstallRelease method which should create provided release func InstallRelease(rel *release.InstallReleaseRequest) (*release.InstallReleaseResponse, error) { //TODO(mkwiek): parametrize this - conn, err := grpc.Dial(GrpcAddr, grpc.WithInsecure()) + conn, err := grpc.Dial(grpcAddr, grpc.WithInsecure()) if err != nil { return nil, err } @@ -41,7 +47,7 @@ func InstallRelease(rel *release.InstallReleaseRequest) (*release.InstallRelease // UpgradeRelease calls Rudder UpgradeRelease method which should perform update func UpgradeRelease(req *release.UpgradeReleaseRequest) (*release.UpgradeReleaseResponse, error) { - conn, err := grpc.Dial(GrpcAddr, grpc.WithInsecure()) + conn, err := grpc.Dial(grpcAddr, grpc.WithInsecure()) if err != nil { return nil, err } @@ -52,7 +58,7 @@ func UpgradeRelease(req *release.UpgradeReleaseRequest) (*release.UpgradeRelease // RollbackRelease calls Rudder RollbackRelease method which should perform update func RollbackRelease(req *release.RollbackReleaseRequest) (*release.RollbackReleaseResponse, error) { - conn, err := grpc.Dial(GrpcAddr, grpc.WithInsecure()) + conn, err := grpc.Dial(grpcAddr, grpc.WithInsecure()) if err != nil { return nil, err } From 52c54b09c002970f2c5c54edaa54848865c5dc5d Mon Sep 17 00:00:00 2001 From: Maciej Kwiek Date: Wed, 22 Mar 2017 16:09:16 +0100 Subject: [PATCH 09/12] Move rudder proto to different package, add release status --- _proto/Makefile | 10 +- .../modules.proto => rudder/rudder.proto} | 31 +- cmd/rudder/rudder.go | 30 +- pkg/proto/hapi/chart/chart.pb.go | 2 +- pkg/proto/hapi/chart/config.pb.go | 2 +- pkg/proto/hapi/chart/template.pb.go | 2 +- pkg/proto/hapi/release/hook.pb.go | 12 - pkg/proto/hapi/release/info.pb.go | 2 +- pkg/proto/hapi/release/release.pb.go | 8 +- pkg/proto/hapi/release/status.pb.go | 10 +- pkg/proto/hapi/release/test_run.pb.go | 10 +- pkg/proto/hapi/release/test_suite.pb.go | 8 +- .../modules.pb.go => rudder/rudder.pb.go} | 324 ++++++++++++------ pkg/proto/hapi/services/tiller.pb.go | 1 + pkg/proto/hapi/version/version.pb.go | 2 +- pkg/rudder/client.go | 14 +- pkg/tiller/release_modules.go | 7 +- 17 files changed, 308 insertions(+), 167 deletions(-) rename _proto/hapi/{release/modules.proto => rudder/rudder.proto} (67%) rename pkg/proto/hapi/{release/modules.pb.go => rudder/rudder.pb.go} (51%) diff --git a/_proto/Makefile b/_proto/Makefile index 078514a9c..39f72d441 100644 --- a/_proto/Makefile +++ b/_proto/Makefile @@ -20,6 +20,10 @@ services_ias = $(subst $(space),$(comma),$(addsuffix =$(import_path)/$(services_ services_pbs = $(sort $(wildcard hapi/services/*.proto)) services_pkg = services +rudder_ias = $(subst $(space),$(comma),$(addsuffix =$(import_path)/$(rudder_pkg),$(addprefix M,$(rudder_pbs)))) +rudder_pbs = $(sort $(wildcard hapi/rudder/*.proto)) +rudder_pkg = rudder + version_ias = $(subst $(space),$(comma),$(addsuffix =$(import_path)/$(version_pkg),$(addprefix M,$(version_pbs)))) version_pbs = $(sort $(wildcard hapi/version/*.proto)) version_pkg = version @@ -27,7 +31,7 @@ version_pkg = version google_deps = Mgoogle/protobuf/timestamp.proto=github.com/golang/protobuf/ptypes/timestamp,Mgoogle/protobuf/any.proto=github.com/golang/protobuf/ptypes/any .PHONY: all -all: chart release services version +all: chart release services rudder version .PHONY: chart chart: @@ -41,6 +45,10 @@ release: services: PATH=../bin:$(PATH) protoc --$(target)_out=plugins=$(plugins),$(google_deps),$(chart_ias),$(version_ias),$(release_ias):$(dst) $(services_pbs) +.PHONY: rudder +rudder: + PATH=../bin:$(PATH) protoc --$(target)_out=plugins=$(plugins),$(google_deps),$(chart_ias),$(version_ias),$(release_ias):$(dst) $(rudder_pbs) + .PHONY: version version: PATH=../bin:$(PATH) protoc --$(target)_out=plugins=$(plugins),$(google_deps):$(dst) $(version_pbs) diff --git a/_proto/hapi/release/modules.proto b/_proto/hapi/rudder/rudder.proto similarity index 67% rename from _proto/hapi/release/modules.proto rename to _proto/hapi/rudder/rudder.proto index 4f0709a02..bb724ca45 100644 --- a/_proto/hapi/release/modules.proto +++ b/_proto/hapi/rudder/rudder.proto @@ -1,10 +1,25 @@ +// Copyright 2017 The Kubernetes Authors All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + syntax = "proto3"; -package hapi.release; +package hapi.services.rudder; +import "hapi/release/info.proto"; import "hapi/release/release.proto"; -option go_package = "release"; +option go_package = "rudder"; service ReleaseModuleService { rpc Version(VersionReleaseRequest) returns (VersionReleaseResponse) { @@ -25,6 +40,10 @@ service ReleaseModuleService { // UpgradeRelease updates release content. rpc UpgradeRelease(UpgradeReleaseRequest) returns (UpgradeReleaseResponse) { } + + // ReleaseStatus retrieves release status. + rpc ReleaseStatus(ReleaseStatusRequest) returns (ReleaseStatusResponse) { + } } message Result { @@ -89,3 +108,11 @@ message RollbackReleaseResponse{ hapi.release.Release release = 1; Result result = 2; } + +message ReleaseStatusRequest{ + hapi.release.Release release = 1; +} +message ReleaseStatusResponse{ + hapi.release.Release release = 1; + hapi.release.Info info = 2; +} diff --git a/cmd/rudder/rudder.go b/cmd/rudder/rudder.go index 9169c2ce9..a0832d5d7 100644 --- a/cmd/rudder/rudder.go +++ b/cmd/rudder/rudder.go @@ -26,7 +26,7 @@ import ( "google.golang.org/grpc/grpclog" "k8s.io/helm/pkg/kube" - "k8s.io/helm/pkg/proto/hapi/release" + rudderAPI "k8s.io/helm/pkg/proto/hapi/rudder" "k8s.io/helm/pkg/rudder" "k8s.io/helm/pkg/version" ) @@ -39,57 +39,63 @@ func main() { grpclog.Fatalf("failed to listen: %v", err) } grpcServer := grpc.NewServer() - release.RegisterReleaseModuleServiceServer(grpcServer, &ReleaseModuleServiceServer{}) + rudderAPI.RegisterReleaseModuleServiceServer(grpcServer, &ReleaseModuleServiceServer{}) grpclog.Print("Server starting") grpcServer.Serve(lis) grpclog.Print("Server started") } -// ReleaseModuleServiceServer provides implementation for release.ReleaseModuleServiceServer +// ReleaseModuleServiceServer provides implementation for rudderAPI.ReleaseModuleServiceServer type ReleaseModuleServiceServer struct{} // Version is not yet implemented -func (r *ReleaseModuleServiceServer) Version(ctx context.Context, in *release.VersionReleaseRequest) (*release.VersionReleaseResponse, error) { +func (r *ReleaseModuleServiceServer) Version(ctx context.Context, in *rudderAPI.VersionReleaseRequest) (*rudderAPI.VersionReleaseResponse, error) { grpclog.Print("version") - return &release.VersionReleaseResponse{ + return &rudderAPI.VersionReleaseResponse{ Name: "helm-rudder-native", Version: version.Version, }, nil } // InstallRelease creates a release using kubeClient.Create -func (r *ReleaseModuleServiceServer) InstallRelease(ctx context.Context, in *release.InstallReleaseRequest) (*release.InstallReleaseResponse, error) { +func (r *ReleaseModuleServiceServer) InstallRelease(ctx context.Context, in *rudderAPI.InstallReleaseRequest) (*rudderAPI.InstallReleaseResponse, error) { grpclog.Print("install") b := bytes.NewBufferString(in.Release.Manifest) err := kubeClient.Create(in.Release.Namespace, b, 500, false) if err != nil { grpclog.Printf("error when creating release: %s", err) } - return &release.InstallReleaseResponse{}, err + return &rudderAPI.InstallReleaseResponse{}, err } // DeleteRelease is not implemented -func (r *ReleaseModuleServiceServer) DeleteRelease(ctx context.Context, in *release.DeleteReleaseRequest) (*release.DeleteReleaseResponse, error) { +func (r *ReleaseModuleServiceServer) DeleteRelease(ctx context.Context, in *rudderAPI.DeleteReleaseRequest) (*rudderAPI.DeleteReleaseResponse, error) { grpclog.Print("delete") return nil, nil } // RollbackRelease is not implemented -func (r *ReleaseModuleServiceServer) RollbackRelease(ctx context.Context, in *release.RollbackReleaseRequest) (*release.RollbackReleaseResponse, error) { +func (r *ReleaseModuleServiceServer) RollbackRelease(ctx context.Context, in *rudderAPI.RollbackReleaseRequest) (*rudderAPI.RollbackReleaseResponse, error) { grpclog.Print("rollback") c := bytes.NewBufferString(in.Current.Manifest) t := bytes.NewBufferString(in.Target.Manifest) err := kubeClient.Update(in.Target.Namespace, c, t, in.Recreate, in.Timeout, in.Wait) - return &release.RollbackReleaseResponse{}, err + return &rudderAPI.RollbackReleaseResponse{}, err } // UpgradeRelease upgrades manifests using kubernetes client -func (r *ReleaseModuleServiceServer) UpgradeRelease(ctx context.Context, in *release.UpgradeReleaseRequest) (*release.UpgradeReleaseResponse, error) { +func (r *ReleaseModuleServiceServer) UpgradeRelease(ctx context.Context, in *rudderAPI.UpgradeReleaseRequest) (*rudderAPI.UpgradeReleaseResponse, error) { grpclog.Print("upgrade") c := bytes.NewBufferString(in.Current.Manifest) t := bytes.NewBufferString(in.Target.Manifest) err := kubeClient.Update(in.Target.Namespace, c, t, in.Recreate, in.Timeout, in.Wait) // upgrade response object should be changed to include status - return &release.UpgradeReleaseResponse{}, err + return &rudderAPI.UpgradeReleaseResponse{}, err +} + +func (r *ReleaseModuleServiceServer) ReleaseStatus(context.Context, *rudderAPI.ReleaseStatusRequest) (*rudderAPI.ReleaseStatusResponse, error) { + grpclog.Print("status") + + return &rudderAPI.ReleaseStatusResponse{}, nil } 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 8ce01968d..4a8b36d89 100644 --- a/pkg/proto/hapi/chart/config.pb.go +++ b/pkg/proto/hapi/chart/config.pb.go @@ -64,7 +64,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/template.pb.go b/pkg/proto/hapi/chart/template.pb.go index 862efa372..416269d18 100644 --- a/pkg/proto/hapi/chart/template.pb.go +++ b/pkg/proto/hapi/chart/template.pb.go @@ -51,7 +51,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 2b8f0330a..1724842e3 100644 --- a/pkg/proto/hapi/release/hook.pb.go +++ b/pkg/proto/hapi/release/hook.pb.go @@ -8,7 +8,6 @@ Package release is a generated protocol buffer package. It is generated from these files: hapi/release/hook.proto hapi/release/info.proto - hapi/release/modules.proto hapi/release/release.proto hapi/release/status.proto hapi/release/test_run.proto @@ -17,17 +16,6 @@ It is generated from these files: It has these top-level messages: Hook Info - Result - VersionReleaseRequest - VersionReleaseResponse - InstallReleaseRequest - InstallReleaseResponse - DeleteReleaseRequest - DeleteReleaseResponse - UpgradeReleaseRequest - UpgradeReleaseResponse - RollbackReleaseRequest - RollbackReleaseResponse Release Status TestRun diff --git a/pkg/proto/hapi/release/info.pb.go b/pkg/proto/hapi/release/info.pb.go index fd57fecf9..9485ad058 100644 --- a/pkg/proto/hapi/release/info.pb.go +++ b/pkg/proto/hapi/release/info.pb.go @@ -73,7 +73,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 80c3dd4d7..47b321b50 100644 --- a/pkg/proto/hapi/release/release.pb.go +++ b/pkg/proto/hapi/release/release.pb.go @@ -40,7 +40,7 @@ type Release struct { func (m *Release) Reset() { *m = Release{} } func (m *Release) String() string { return proto.CompactTextString(m) } func (*Release) ProtoMessage() {} -func (*Release) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} } +func (*Release) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } func (m *Release) GetName() string { if m != nil { @@ -102,11 +102,11 @@ func init() { proto.RegisterType((*Release)(nil), "hapi.release.Release") } -func init() { proto.RegisterFile("hapi/release/release.proto", fileDescriptor3) } +func init() { proto.RegisterFile("hapi/release/release.proto", fileDescriptor2) } -var fileDescriptor3 = []byte{ +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 d2e89d692..0098207a7 100644 --- a/pkg/proto/hapi/release/status.pb.go +++ b/pkg/proto/hapi/release/status.pb.go @@ -51,7 +51,7 @@ var Status_Code_value = map[string]int32{ func (x Status_Code) String() string { return proto.EnumName(Status_Code_name, int32(x)) } -func (Status_Code) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{0, 0} } +func (Status_Code) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{0, 0} } // Status defines the status of a release. type Status struct { @@ -67,7 +67,7 @@ type Status struct { func (m *Status) Reset() { *m = Status{} } func (m *Status) String() string { return proto.CompactTextString(m) } func (*Status) ProtoMessage() {} -func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} } +func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} } func (m *Status) GetCode() Status_Code { if m != nil { @@ -102,11 +102,11 @@ func init() { proto.RegisterEnum("hapi.release.Status_Code", Status_Code_name, Status_Code_value) } -func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor4) } +func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor3) } -var fileDescriptor4 = []byte{ +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 b680f5a22..79fce4ab4 100644 --- a/pkg/proto/hapi/release/test_run.pb.go +++ b/pkg/proto/hapi/release/test_run.pb.go @@ -36,7 +36,7 @@ var TestRun_Status_value = map[string]int32{ func (x TestRun_Status) String() string { return proto.EnumName(TestRun_Status_name, int32(x)) } -func (TestRun_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor5, []int{0, 0} } +func (TestRun_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{0, 0} } type TestRun struct { Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` @@ -49,7 +49,7 @@ type TestRun struct { func (m *TestRun) Reset() { *m = TestRun{} } func (m *TestRun) String() string { return proto.CompactTextString(m) } func (*TestRun) ProtoMessage() {} -func (*TestRun) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} } +func (*TestRun) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} } func (m *TestRun) GetName() string { if m != nil { @@ -91,11 +91,11 @@ func init() { proto.RegisterEnum("hapi.release.TestRun_Status", TestRun_Status_name, TestRun_Status_value) } -func init() { proto.RegisterFile("hapi/release/test_run.proto", fileDescriptor5) } +func init() { proto.RegisterFile("hapi/release/test_run.proto", fileDescriptor4) } -var fileDescriptor5 = []byte{ +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 a7e7cde17..f168bf1d2 100644 --- a/pkg/proto/hapi/release/test_suite.pb.go +++ b/pkg/proto/hapi/release/test_suite.pb.go @@ -27,7 +27,7 @@ type TestSuite struct { func (m *TestSuite) Reset() { *m = TestSuite{} } func (m *TestSuite) String() string { return proto.CompactTextString(m) } func (*TestSuite) ProtoMessage() {} -func (*TestSuite) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} } +func (*TestSuite) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} } func (m *TestSuite) GetStartedAt() *google_protobuf.Timestamp { if m != nil { @@ -54,11 +54,11 @@ func init() { proto.RegisterType((*TestSuite)(nil), "hapi.release.TestSuite") } -func init() { proto.RegisterFile("hapi/release/test_suite.proto", fileDescriptor6) } +func init() { proto.RegisterFile("hapi/release/test_suite.proto", fileDescriptor5) } -var fileDescriptor6 = []byte{ +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/release/modules.pb.go b/pkg/proto/hapi/rudder/rudder.pb.go similarity index 51% rename from pkg/proto/hapi/release/modules.pb.go rename to pkg/proto/hapi/rudder/rudder.pb.go index fa627f42b..e5c9f66b1 100644 --- a/pkg/proto/hapi/release/modules.pb.go +++ b/pkg/proto/hapi/rudder/rudder.pb.go @@ -1,12 +1,35 @@ // Code generated by protoc-gen-go. -// source: hapi/release/modules.proto +// source: hapi/rudder/rudder.proto // DO NOT EDIT! -package release +/* +Package rudder is a generated protocol buffer package. + +It is generated from these files: + hapi/rudder/rudder.proto + +It has these top-level messages: + Result + VersionReleaseRequest + VersionReleaseResponse + InstallReleaseRequest + InstallReleaseResponse + DeleteReleaseRequest + DeleteReleaseResponse + UpgradeReleaseRequest + UpgradeReleaseResponse + RollbackReleaseRequest + RollbackReleaseResponse + ReleaseStatusRequest + ReleaseStatusResponse +*/ +package rudder import proto "github.com/golang/protobuf/proto" import fmt "fmt" import math "math" +import hapi_release3 "k8s.io/helm/pkg/proto/hapi/release" +import hapi_release5 "k8s.io/helm/pkg/proto/hapi/release" import ( context "golang.org/x/net/context" @@ -18,6 +41,12 @@ var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + type Result_Status int32 const ( @@ -47,7 +76,7 @@ var Result_Status_value = map[string]int32{ func (x Result_Status) String() string { return proto.EnumName(Result_Status_name, int32(x)) } -func (Result_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{0, 0} } +func (Result_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} } type Result struct { Info string `protobuf:"bytes,1,opt,name=info" json:"info,omitempty"` @@ -57,7 +86,7 @@ type Result struct { func (m *Result) Reset() { *m = Result{} } func (m *Result) String() string { return proto.CompactTextString(m) } func (*Result) ProtoMessage() {} -func (*Result) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } +func (*Result) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } type VersionReleaseRequest struct { } @@ -65,7 +94,7 @@ type VersionReleaseRequest struct { func (m *VersionReleaseRequest) Reset() { *m = VersionReleaseRequest{} } func (m *VersionReleaseRequest) String() string { return proto.CompactTextString(m) } func (*VersionReleaseRequest) ProtoMessage() {} -func (*VersionReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} } +func (*VersionReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } type VersionReleaseResponse struct { Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` @@ -75,18 +104,18 @@ type VersionReleaseResponse struct { func (m *VersionReleaseResponse) Reset() { *m = VersionReleaseResponse{} } func (m *VersionReleaseResponse) String() string { return proto.CompactTextString(m) } func (*VersionReleaseResponse) ProtoMessage() {} -func (*VersionReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} } +func (*VersionReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } type InstallReleaseRequest struct { - Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` } func (m *InstallReleaseRequest) Reset() { *m = InstallReleaseRequest{} } func (m *InstallReleaseRequest) String() string { return proto.CompactTextString(m) } func (*InstallReleaseRequest) ProtoMessage() {} -func (*InstallReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} } +func (*InstallReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } -func (m *InstallReleaseRequest) GetRelease() *Release { +func (m *InstallReleaseRequest) GetRelease() *hapi_release5.Release { if m != nil { return m.Release } @@ -94,16 +123,16 @@ func (m *InstallReleaseRequest) GetRelease() *Release { } type InstallReleaseResponse struct { - Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` - Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` + Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` } func (m *InstallReleaseResponse) Reset() { *m = InstallReleaseResponse{} } func (m *InstallReleaseResponse) String() string { return proto.CompactTextString(m) } func (*InstallReleaseResponse) ProtoMessage() {} -func (*InstallReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} } +func (*InstallReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } -func (m *InstallReleaseResponse) GetRelease() *Release { +func (m *InstallReleaseResponse) GetRelease() *hapi_release5.Release { if m != nil { return m.Release } @@ -118,15 +147,15 @@ func (m *InstallReleaseResponse) GetResult() *Result { } type DeleteReleaseRequest struct { - Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` } func (m *DeleteReleaseRequest) Reset() { *m = DeleteReleaseRequest{} } func (m *DeleteReleaseRequest) String() string { return proto.CompactTextString(m) } func (*DeleteReleaseRequest) ProtoMessage() {} -func (*DeleteReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} } +func (*DeleteReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } -func (m *DeleteReleaseRequest) GetRelease() *Release { +func (m *DeleteReleaseRequest) GetRelease() *hapi_release5.Release { if m != nil { return m.Release } @@ -134,16 +163,16 @@ func (m *DeleteReleaseRequest) GetRelease() *Release { } type DeleteReleaseResponse struct { - Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` - Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` + Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` } func (m *DeleteReleaseResponse) Reset() { *m = DeleteReleaseResponse{} } func (m *DeleteReleaseResponse) String() string { return proto.CompactTextString(m) } func (*DeleteReleaseResponse) ProtoMessage() {} -func (*DeleteReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} } +func (*DeleteReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } -func (m *DeleteReleaseResponse) GetRelease() *Release { +func (m *DeleteReleaseResponse) GetRelease() *hapi_release5.Release { if m != nil { return m.Release } @@ -158,26 +187,26 @@ func (m *DeleteReleaseResponse) GetResult() *Result { } type UpgradeReleaseRequest struct { - Current *Release `protobuf:"bytes,1,opt,name=current" json:"current,omitempty"` - Target *Release `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` - Timeout int64 `protobuf:"varint,3,opt,name=Timeout" json:"Timeout,omitempty"` - Wait bool `protobuf:"varint,4,opt,name=Wait" json:"Wait,omitempty"` - Recreate bool `protobuf:"varint,5,opt,name=Recreate" json:"Recreate,omitempty"` + Current *hapi_release5.Release `protobuf:"bytes,1,opt,name=current" json:"current,omitempty"` + Target *hapi_release5.Release `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` + Timeout int64 `protobuf:"varint,3,opt,name=Timeout" json:"Timeout,omitempty"` + Wait bool `protobuf:"varint,4,opt,name=Wait" json:"Wait,omitempty"` + Recreate bool `protobuf:"varint,5,opt,name=Recreate" json:"Recreate,omitempty"` } func (m *UpgradeReleaseRequest) Reset() { *m = UpgradeReleaseRequest{} } func (m *UpgradeReleaseRequest) String() string { return proto.CompactTextString(m) } func (*UpgradeReleaseRequest) ProtoMessage() {} -func (*UpgradeReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} } +func (*UpgradeReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } -func (m *UpgradeReleaseRequest) GetCurrent() *Release { +func (m *UpgradeReleaseRequest) GetCurrent() *hapi_release5.Release { if m != nil { return m.Current } return nil } -func (m *UpgradeReleaseRequest) GetTarget() *Release { +func (m *UpgradeReleaseRequest) GetTarget() *hapi_release5.Release { if m != nil { return m.Target } @@ -185,16 +214,16 @@ func (m *UpgradeReleaseRequest) GetTarget() *Release { } type UpgradeReleaseResponse struct { - Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` - Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` + Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` } func (m *UpgradeReleaseResponse) Reset() { *m = UpgradeReleaseResponse{} } func (m *UpgradeReleaseResponse) String() string { return proto.CompactTextString(m) } func (*UpgradeReleaseResponse) ProtoMessage() {} -func (*UpgradeReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} } +func (*UpgradeReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } -func (m *UpgradeReleaseResponse) GetRelease() *Release { +func (m *UpgradeReleaseResponse) GetRelease() *hapi_release5.Release { if m != nil { return m.Release } @@ -209,26 +238,26 @@ func (m *UpgradeReleaseResponse) GetResult() *Result { } type RollbackReleaseRequest struct { - Current *Release `protobuf:"bytes,1,opt,name=current" json:"current,omitempty"` - Target *Release `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` - Timeout int64 `protobuf:"varint,3,opt,name=Timeout" json:"Timeout,omitempty"` - Wait bool `protobuf:"varint,4,opt,name=Wait" json:"Wait,omitempty"` - Recreate bool `protobuf:"varint,5,opt,name=Recreate" json:"Recreate,omitempty"` + Current *hapi_release5.Release `protobuf:"bytes,1,opt,name=current" json:"current,omitempty"` + Target *hapi_release5.Release `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` + Timeout int64 `protobuf:"varint,3,opt,name=Timeout" json:"Timeout,omitempty"` + Wait bool `protobuf:"varint,4,opt,name=Wait" json:"Wait,omitempty"` + Recreate bool `protobuf:"varint,5,opt,name=Recreate" json:"Recreate,omitempty"` } func (m *RollbackReleaseRequest) Reset() { *m = RollbackReleaseRequest{} } func (m *RollbackReleaseRequest) String() string { return proto.CompactTextString(m) } func (*RollbackReleaseRequest) ProtoMessage() {} -func (*RollbackReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} } +func (*RollbackReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } -func (m *RollbackReleaseRequest) GetCurrent() *Release { +func (m *RollbackReleaseRequest) GetCurrent() *hapi_release5.Release { if m != nil { return m.Current } return nil } -func (m *RollbackReleaseRequest) GetTarget() *Release { +func (m *RollbackReleaseRequest) GetTarget() *hapi_release5.Release { if m != nil { return m.Target } @@ -236,16 +265,16 @@ func (m *RollbackReleaseRequest) GetTarget() *Release { } type RollbackReleaseResponse struct { - Release *Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` - Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` + Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` } func (m *RollbackReleaseResponse) Reset() { *m = RollbackReleaseResponse{} } func (m *RollbackReleaseResponse) String() string { return proto.CompactTextString(m) } func (*RollbackReleaseResponse) ProtoMessage() {} -func (*RollbackReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} } +func (*RollbackReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } -func (m *RollbackReleaseResponse) GetRelease() *Release { +func (m *RollbackReleaseResponse) GetRelease() *hapi_release5.Release { if m != nil { return m.Release } @@ -259,19 +288,61 @@ func (m *RollbackReleaseResponse) GetResult() *Result { return nil } +type ReleaseStatusRequest struct { + Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` +} + +func (m *ReleaseStatusRequest) Reset() { *m = ReleaseStatusRequest{} } +func (m *ReleaseStatusRequest) String() string { return proto.CompactTextString(m) } +func (*ReleaseStatusRequest) ProtoMessage() {} +func (*ReleaseStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } + +func (m *ReleaseStatusRequest) GetRelease() *hapi_release5.Release { + if m != nil { + return m.Release + } + return nil +} + +type ReleaseStatusResponse struct { + Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` + Info *hapi_release3.Info `protobuf:"bytes,2,opt,name=info" json:"info,omitempty"` +} + +func (m *ReleaseStatusResponse) Reset() { *m = ReleaseStatusResponse{} } +func (m *ReleaseStatusResponse) String() string { return proto.CompactTextString(m) } +func (*ReleaseStatusResponse) ProtoMessage() {} +func (*ReleaseStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } + +func (m *ReleaseStatusResponse) GetRelease() *hapi_release5.Release { + if m != nil { + return m.Release + } + return nil +} + +func (m *ReleaseStatusResponse) GetInfo() *hapi_release3.Info { + if m != nil { + return m.Info + } + return nil +} + func init() { - proto.RegisterType((*Result)(nil), "hapi.release.Result") - proto.RegisterType((*VersionReleaseRequest)(nil), "hapi.release.VersionReleaseRequest") - proto.RegisterType((*VersionReleaseResponse)(nil), "hapi.release.VersionReleaseResponse") - proto.RegisterType((*InstallReleaseRequest)(nil), "hapi.release.InstallReleaseRequest") - proto.RegisterType((*InstallReleaseResponse)(nil), "hapi.release.InstallReleaseResponse") - proto.RegisterType((*DeleteReleaseRequest)(nil), "hapi.release.DeleteReleaseRequest") - proto.RegisterType((*DeleteReleaseResponse)(nil), "hapi.release.DeleteReleaseResponse") - proto.RegisterType((*UpgradeReleaseRequest)(nil), "hapi.release.UpgradeReleaseRequest") - proto.RegisterType((*UpgradeReleaseResponse)(nil), "hapi.release.UpgradeReleaseResponse") - proto.RegisterType((*RollbackReleaseRequest)(nil), "hapi.release.RollbackReleaseRequest") - proto.RegisterType((*RollbackReleaseResponse)(nil), "hapi.release.RollbackReleaseResponse") - proto.RegisterEnum("hapi.release.Result_Status", Result_Status_name, Result_Status_value) + proto.RegisterType((*Result)(nil), "hapi.services.rudder.Result") + proto.RegisterType((*VersionReleaseRequest)(nil), "hapi.services.rudder.VersionReleaseRequest") + proto.RegisterType((*VersionReleaseResponse)(nil), "hapi.services.rudder.VersionReleaseResponse") + proto.RegisterType((*InstallReleaseRequest)(nil), "hapi.services.rudder.InstallReleaseRequest") + proto.RegisterType((*InstallReleaseResponse)(nil), "hapi.services.rudder.InstallReleaseResponse") + proto.RegisterType((*DeleteReleaseRequest)(nil), "hapi.services.rudder.DeleteReleaseRequest") + proto.RegisterType((*DeleteReleaseResponse)(nil), "hapi.services.rudder.DeleteReleaseResponse") + proto.RegisterType((*UpgradeReleaseRequest)(nil), "hapi.services.rudder.UpgradeReleaseRequest") + proto.RegisterType((*UpgradeReleaseResponse)(nil), "hapi.services.rudder.UpgradeReleaseResponse") + proto.RegisterType((*RollbackReleaseRequest)(nil), "hapi.services.rudder.RollbackReleaseRequest") + proto.RegisterType((*RollbackReleaseResponse)(nil), "hapi.services.rudder.RollbackReleaseResponse") + proto.RegisterType((*ReleaseStatusRequest)(nil), "hapi.services.rudder.ReleaseStatusRequest") + proto.RegisterType((*ReleaseStatusResponse)(nil), "hapi.services.rudder.ReleaseStatusResponse") + proto.RegisterEnum("hapi.services.rudder.Result_Status", Result_Status_name, Result_Status_value) } // Reference imports to suppress errors if they are not otherwise used. @@ -294,6 +365,8 @@ type ReleaseModuleServiceClient interface { RollbackRelease(ctx context.Context, in *RollbackReleaseRequest, opts ...grpc.CallOption) (*RollbackReleaseResponse, error) // UpgradeRelease updates release content. UpgradeRelease(ctx context.Context, in *UpgradeReleaseRequest, opts ...grpc.CallOption) (*UpgradeReleaseResponse, error) + // ReleaseStatus retrieves release status. + ReleaseStatus(ctx context.Context, in *ReleaseStatusRequest, opts ...grpc.CallOption) (*ReleaseStatusResponse, error) } type releaseModuleServiceClient struct { @@ -306,7 +379,7 @@ func NewReleaseModuleServiceClient(cc *grpc.ClientConn) ReleaseModuleServiceClie func (c *releaseModuleServiceClient) Version(ctx context.Context, in *VersionReleaseRequest, opts ...grpc.CallOption) (*VersionReleaseResponse, error) { out := new(VersionReleaseResponse) - err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/Version", in, out, c.cc, opts...) + err := grpc.Invoke(ctx, "/hapi.services.rudder.ReleaseModuleService/Version", in, out, c.cc, opts...) if err != nil { return nil, err } @@ -315,7 +388,7 @@ func (c *releaseModuleServiceClient) Version(ctx context.Context, in *VersionRel func (c *releaseModuleServiceClient) InstallRelease(ctx context.Context, in *InstallReleaseRequest, opts ...grpc.CallOption) (*InstallReleaseResponse, error) { out := new(InstallReleaseResponse) - err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/InstallRelease", in, out, c.cc, opts...) + err := grpc.Invoke(ctx, "/hapi.services.rudder.ReleaseModuleService/InstallRelease", in, out, c.cc, opts...) if err != nil { return nil, err } @@ -324,7 +397,7 @@ func (c *releaseModuleServiceClient) InstallRelease(ctx context.Context, in *Ins func (c *releaseModuleServiceClient) DeleteRelease(ctx context.Context, in *DeleteReleaseRequest, opts ...grpc.CallOption) (*DeleteReleaseResponse, error) { out := new(DeleteReleaseResponse) - err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/DeleteRelease", in, out, c.cc, opts...) + err := grpc.Invoke(ctx, "/hapi.services.rudder.ReleaseModuleService/DeleteRelease", in, out, c.cc, opts...) if err != nil { return nil, err } @@ -333,7 +406,7 @@ func (c *releaseModuleServiceClient) DeleteRelease(ctx context.Context, in *Dele func (c *releaseModuleServiceClient) RollbackRelease(ctx context.Context, in *RollbackReleaseRequest, opts ...grpc.CallOption) (*RollbackReleaseResponse, error) { out := new(RollbackReleaseResponse) - err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/RollbackRelease", in, out, c.cc, opts...) + err := grpc.Invoke(ctx, "/hapi.services.rudder.ReleaseModuleService/RollbackRelease", in, out, c.cc, opts...) if err != nil { return nil, err } @@ -342,7 +415,16 @@ func (c *releaseModuleServiceClient) RollbackRelease(ctx context.Context, in *Ro func (c *releaseModuleServiceClient) UpgradeRelease(ctx context.Context, in *UpgradeReleaseRequest, opts ...grpc.CallOption) (*UpgradeReleaseResponse, error) { out := new(UpgradeReleaseResponse) - err := grpc.Invoke(ctx, "/hapi.release.ReleaseModuleService/UpgradeRelease", in, out, c.cc, opts...) + err := grpc.Invoke(ctx, "/hapi.services.rudder.ReleaseModuleService/UpgradeRelease", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *releaseModuleServiceClient) ReleaseStatus(ctx context.Context, in *ReleaseStatusRequest, opts ...grpc.CallOption) (*ReleaseStatusResponse, error) { + out := new(ReleaseStatusResponse) + err := grpc.Invoke(ctx, "/hapi.services.rudder.ReleaseModuleService/ReleaseStatus", in, out, c.cc, opts...) if err != nil { return nil, err } @@ -361,6 +443,8 @@ type ReleaseModuleServiceServer interface { RollbackRelease(context.Context, *RollbackReleaseRequest) (*RollbackReleaseResponse, error) // UpgradeRelease updates release content. UpgradeRelease(context.Context, *UpgradeReleaseRequest) (*UpgradeReleaseResponse, error) + // ReleaseStatus retrieves release status. + ReleaseStatus(context.Context, *ReleaseStatusRequest) (*ReleaseStatusResponse, error) } func RegisterReleaseModuleServiceServer(s *grpc.Server, srv ReleaseModuleServiceServer) { @@ -377,7 +461,7 @@ func _ReleaseModuleService_Version_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/hapi.release.ReleaseModuleService/Version", + FullMethod: "/hapi.services.rudder.ReleaseModuleService/Version", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ReleaseModuleServiceServer).Version(ctx, req.(*VersionReleaseRequest)) @@ -395,7 +479,7 @@ func _ReleaseModuleService_InstallRelease_Handler(srv interface{}, ctx context.C } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/hapi.release.ReleaseModuleService/InstallRelease", + FullMethod: "/hapi.services.rudder.ReleaseModuleService/InstallRelease", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ReleaseModuleServiceServer).InstallRelease(ctx, req.(*InstallReleaseRequest)) @@ -413,7 +497,7 @@ func _ReleaseModuleService_DeleteRelease_Handler(srv interface{}, ctx context.Co } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/hapi.release.ReleaseModuleService/DeleteRelease", + FullMethod: "/hapi.services.rudder.ReleaseModuleService/DeleteRelease", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ReleaseModuleServiceServer).DeleteRelease(ctx, req.(*DeleteReleaseRequest)) @@ -431,7 +515,7 @@ func _ReleaseModuleService_RollbackRelease_Handler(srv interface{}, ctx context. } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/hapi.release.ReleaseModuleService/RollbackRelease", + FullMethod: "/hapi.services.rudder.ReleaseModuleService/RollbackRelease", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ReleaseModuleServiceServer).RollbackRelease(ctx, req.(*RollbackReleaseRequest)) @@ -449,7 +533,7 @@ func _ReleaseModuleService_UpgradeRelease_Handler(srv interface{}, ctx context.C } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/hapi.release.ReleaseModuleService/UpgradeRelease", + FullMethod: "/hapi.services.rudder.ReleaseModuleService/UpgradeRelease", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ReleaseModuleServiceServer).UpgradeRelease(ctx, req.(*UpgradeReleaseRequest)) @@ -457,8 +541,26 @@ func _ReleaseModuleService_UpgradeRelease_Handler(srv interface{}, ctx context.C return interceptor(ctx, in, info, handler) } +func _ReleaseModuleService_ReleaseStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReleaseStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ReleaseModuleServiceServer).ReleaseStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hapi.services.rudder.ReleaseModuleService/ReleaseStatus", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ReleaseModuleServiceServer).ReleaseStatus(ctx, req.(*ReleaseStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _ReleaseModuleService_serviceDesc = grpc.ServiceDesc{ - ServiceName: "hapi.release.ReleaseModuleService", + ServiceName: "hapi.services.rudder.ReleaseModuleService", HandlerType: (*ReleaseModuleServiceServer)(nil), Methods: []grpc.MethodDesc{ { @@ -481,46 +583,54 @@ var _ReleaseModuleService_serviceDesc = grpc.ServiceDesc{ MethodName: "UpgradeRelease", Handler: _ReleaseModuleService_UpgradeRelease_Handler, }, + { + MethodName: "ReleaseStatus", + Handler: _ReleaseModuleService_ReleaseStatus_Handler, + }, }, Streams: []grpc.StreamDesc{}, - Metadata: fileDescriptor2, -} - -func init() { proto.RegisterFile("hapi/release/modules.proto", fileDescriptor2) } - -var fileDescriptor2 = []byte{ - // 523 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x55, 0xc1, 0x6e, 0xd3, 0x40, - 0x10, 0x8d, 0xe3, 0x36, 0xa9, 0x27, 0x14, 0xac, 0x55, 0x9c, 0x5a, 0x3e, 0x45, 0x5b, 0x90, 0x72, - 0x80, 0x44, 0x0a, 0x57, 0x2e, 0x90, 0x86, 0x16, 0x21, 0x5c, 0x69, 0x4d, 0x5a, 0xa9, 0x12, 0x12, - 0xdb, 0x74, 0x08, 0x16, 0x1b, 0x3b, 0xac, 0xd7, 0x81, 0xdf, 0x83, 0xcf, 0xe1, 0x2b, 0x90, 0x1d, - 0xbb, 0xaa, 0x17, 0xd3, 0x0a, 0x21, 0x45, 0xea, 0x29, 0x33, 0x9e, 0x97, 0xb7, 0x33, 0xcf, 0xb3, - 0xcf, 0xe0, 0x7d, 0xe6, 0xab, 0x70, 0x24, 0x51, 0x20, 0x4f, 0x70, 0xb4, 0x8c, 0xaf, 0x52, 0x81, - 0xc9, 0x70, 0x25, 0x63, 0x15, 0x93, 0x07, 0x59, 0x6d, 0x58, 0xd4, 0xbc, 0x2a, 0xb2, 0xf8, 0xdd, - 0x20, 0xa9, 0x80, 0x16, 0xc3, 0x24, 0x15, 0x8a, 0x10, 0xd8, 0x09, 0xa3, 0x4f, 0xb1, 0x6b, 0xf4, - 0x8d, 0x81, 0xc5, 0xf2, 0x98, 0xd8, 0x60, 0x8a, 0x78, 0xe1, 0x36, 0xfb, 0xe6, 0xc0, 0x62, 0x59, - 0x48, 0x5f, 0x40, 0x2b, 0x50, 0x5c, 0xa5, 0x09, 0xe9, 0x40, 0x7b, 0xe6, 0xbf, 0xf5, 0x4f, 0xcf, - 0x7d, 0xbb, 0x91, 0x25, 0xc1, 0x6c, 0x32, 0x99, 0x06, 0x81, 0x6d, 0x90, 0x7d, 0xb0, 0x66, 0xfe, - 0xe4, 0xe4, 0xa5, 0x7f, 0x3c, 0x3d, 0xb2, 0x9b, 0xc4, 0x82, 0xdd, 0x29, 0x63, 0xa7, 0xcc, 0x36, - 0xe9, 0x01, 0x38, 0x67, 0x28, 0x93, 0x30, 0x8e, 0xd8, 0xa6, 0x0b, 0x86, 0x5f, 0x53, 0x4c, 0x14, - 0x7d, 0x0d, 0x3d, 0xbd, 0x90, 0xac, 0xe2, 0x28, 0xc1, 0xac, 0xad, 0x88, 0x2f, 0xb1, 0x6c, 0x2b, - 0x8b, 0x89, 0x0b, 0xed, 0xf5, 0x06, 0xed, 0x36, 0xf3, 0xc7, 0x65, 0x4a, 0x4f, 0xc0, 0x79, 0x13, - 0x25, 0x8a, 0x0b, 0x51, 0x3d, 0x80, 0x8c, 0xa0, 0x5d, 0x0c, 0x9e, 0x33, 0x75, 0xc6, 0xce, 0xf0, - 0xa6, 0x46, 0xc3, 0x12, 0x5e, 0xa2, 0xe8, 0x37, 0xe8, 0xe9, 0x4c, 0x45, 0x47, 0xff, 0x4a, 0x45, - 0x9e, 0x42, 0x4b, 0xe6, 0x1a, 0xe7, 0xdd, 0x76, 0xc6, 0x5d, 0x1d, 0x9f, 0xd5, 0x58, 0x81, 0xa1, - 0xc7, 0xd0, 0x3d, 0x42, 0x81, 0x0a, 0xff, 0x77, 0x82, 0x35, 0x38, 0x1a, 0xd1, 0x76, 0x06, 0xf8, - 0x61, 0x80, 0x33, 0x5b, 0x2d, 0x24, 0xbf, 0xaa, 0x19, 0x61, 0x9e, 0x4a, 0x89, 0x91, 0xba, 0xe3, - 0xe0, 0x02, 0x45, 0x9e, 0x41, 0x4b, 0x71, 0xb9, 0xc0, 0xf2, 0xe0, 0xbf, 0xe0, 0x0b, 0x50, 0xb6, - 0x17, 0xef, 0xc3, 0x25, 0xc6, 0xa9, 0x72, 0xcd, 0xbe, 0x31, 0x30, 0x59, 0x99, 0x66, 0x5b, 0x74, - 0xce, 0x43, 0xe5, 0xee, 0xf4, 0x8d, 0xc1, 0x1e, 0xcb, 0x63, 0xe2, 0xc1, 0x1e, 0xc3, 0xb9, 0x44, - 0xae, 0xd0, 0xdd, 0xcd, 0x9f, 0x5f, 0xe7, 0xd9, 0xdb, 0xd7, 0x47, 0xd8, 0x8e, 0x78, 0x3f, 0x0d, - 0xe8, 0xb1, 0x58, 0x88, 0x4b, 0x3e, 0xff, 0x72, 0x6f, 0xd5, 0xfb, 0x0e, 0x07, 0x7f, 0xcc, 0xb0, - 0x15, 0xf9, 0xc6, 0xbf, 0x4c, 0xe8, 0x16, 0x14, 0xef, 0x72, 0x47, 0x0c, 0x50, 0xae, 0xc3, 0x39, - 0x92, 0x33, 0x68, 0x17, 0x06, 0x43, 0x0e, 0xab, 0x0c, 0xb5, 0x86, 0xe4, 0x3d, 0xbe, 0x1d, 0xb4, - 0x99, 0x86, 0x36, 0xc8, 0x07, 0x78, 0x58, 0xb5, 0x09, 0x9d, 0xbe, 0xd6, 0x8e, 0x74, 0xfa, 0x7a, - 0xa7, 0xa1, 0x0d, 0x72, 0x01, 0xfb, 0x95, 0x3b, 0x4c, 0x68, 0xf5, 0x8f, 0x75, 0x4e, 0xe1, 0x1d, - 0xde, 0x8a, 0xb9, 0xe6, 0xfe, 0x08, 0x8f, 0xb4, 0xb7, 0x44, 0xb4, 0xb6, 0xea, 0x17, 0xd1, 0x7b, - 0x72, 0x07, 0xea, 0xa6, 0x38, 0xd5, 0x5b, 0xa4, 0x8b, 0x53, 0x6b, 0x13, 0xba, 0x38, 0xf5, 0x17, - 0x91, 0x36, 0x5e, 0x59, 0x17, 0xe5, 0x96, 0x5c, 0xb6, 0xf2, 0xaf, 0xd9, 0xf3, 0xdf, 0x01, 0x00, - 0x00, 0xff, 0xff, 0x6c, 0xb6, 0x1e, 0x06, 0x15, 0x07, 0x00, 0x00, + Metadata: fileDescriptor0, +} + +func init() { proto.RegisterFile("hapi/rudder/rudder.proto", fileDescriptor0) } + +var fileDescriptor0 = []byte{ + // 584 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xd1, 0x8e, 0xd2, 0x40, + 0x14, 0xa5, 0xcb, 0x52, 0xe0, 0x92, 0x55, 0x32, 0xd9, 0x42, 0xd3, 0xf8, 0x40, 0xfa, 0x60, 0x88, + 0xeb, 0x96, 0x04, 0x7d, 0xf4, 0x45, 0x59, 0xdc, 0xdd, 0x18, 0xd9, 0x64, 0x2a, 0x6e, 0xe2, 0x5b, + 0x17, 0x2e, 0x58, 0x2d, 0x6d, 0x9d, 0x4e, 0xf7, 0x51, 0xfd, 0x1a, 0xff, 0x43, 0xbf, 0xcc, 0xb4, + 0xd3, 0x12, 0x5b, 0xa7, 0x11, 0xd7, 0x84, 0xc4, 0xa7, 0xce, 0xf4, 0x1e, 0xee, 0x9c, 0x73, 0x7a, + 0xe7, 0x04, 0xd0, 0xdf, 0x3b, 0xa1, 0x3b, 0x62, 0xf1, 0x72, 0x89, 0x2c, 0x7b, 0x58, 0x21, 0x0b, + 0x78, 0x40, 0x8e, 0x93, 0x8a, 0x15, 0x21, 0xbb, 0x75, 0x17, 0x18, 0x59, 0xa2, 0x66, 0xf4, 0x05, + 0x1e, 0x3d, 0x74, 0x22, 0x1c, 0xb9, 0xfe, 0x2a, 0x10, 0x70, 0xc3, 0x28, 0x14, 0xb2, 0xa7, 0xa8, + 0x99, 0x1e, 0xa8, 0x14, 0xa3, 0xd8, 0xe3, 0x84, 0xc0, 0x61, 0xf2, 0x1b, 0x5d, 0x19, 0x28, 0xc3, + 0x36, 0x4d, 0xd7, 0xa4, 0x0b, 0x75, 0x2f, 0x58, 0xeb, 0x07, 0x83, 0xfa, 0xb0, 0x4d, 0x93, 0xa5, + 0xf9, 0x0c, 0x54, 0x9b, 0x3b, 0x3c, 0x8e, 0x48, 0x07, 0x9a, 0xf3, 0xd9, 0xab, 0xd9, 0xd5, 0xf5, + 0xac, 0x5b, 0x4b, 0x36, 0xf6, 0x7c, 0x32, 0x99, 0xda, 0x76, 0x57, 0x21, 0x47, 0xd0, 0x9e, 0xcf, + 0x26, 0x17, 0xcf, 0x67, 0xe7, 0xd3, 0xb3, 0xee, 0x01, 0x69, 0x43, 0x63, 0x4a, 0xe9, 0x15, 0xed, + 0xd6, 0xcd, 0x3e, 0x68, 0x6f, 0x91, 0x45, 0x6e, 0xe0, 0x53, 0xc1, 0x82, 0xe2, 0xa7, 0x18, 0x23, + 0x6e, 0xbe, 0x84, 0x5e, 0xb9, 0x10, 0x85, 0x81, 0x1f, 0x61, 0x42, 0xcb, 0x77, 0x36, 0x98, 0xd3, + 0x4a, 0xd6, 0x44, 0x87, 0xe6, 0xad, 0x40, 0xeb, 0x07, 0xe9, 0xeb, 0x7c, 0x6b, 0x5e, 0x80, 0x76, + 0xe9, 0x47, 0xdc, 0xf1, 0xbc, 0xe2, 0x01, 0x64, 0x04, 0xcd, 0x4c, 0x78, 0xda, 0xa9, 0x33, 0xd6, + 0xac, 0xd4, 0xc4, 0xdc, 0x8d, 0x1c, 0x9e, 0xa3, 0xcc, 0x2f, 0xd0, 0x2b, 0x77, 0xca, 0x18, 0xfd, + 0x6d, 0x2b, 0xf2, 0x14, 0x54, 0x96, 0x7a, 0x9c, 0xb2, 0xed, 0x8c, 0x1f, 0x58, 0xb2, 0xef, 0x67, + 0x89, 0xef, 0x40, 0x33, 0xac, 0x79, 0x0e, 0xc7, 0x67, 0xe8, 0x21, 0xc7, 0x7f, 0x55, 0xf2, 0x19, + 0xb4, 0x52, 0xa3, 0xfd, 0x0a, 0xf9, 0xae, 0x80, 0x36, 0x0f, 0xd7, 0xcc, 0x59, 0x4a, 0xa4, 0x2c, + 0x62, 0xc6, 0xd0, 0xe7, 0x7f, 0x20, 0x90, 0xa1, 0xc8, 0x29, 0xa8, 0xdc, 0x61, 0x6b, 0xcc, 0x09, + 0x54, 0xe0, 0x33, 0x50, 0x32, 0x27, 0x6f, 0xdc, 0x0d, 0x06, 0x31, 0xd7, 0xeb, 0x03, 0x65, 0x58, + 0xa7, 0xf9, 0x36, 0x99, 0xaa, 0x6b, 0xc7, 0xe5, 0xfa, 0xe1, 0x40, 0x19, 0xb6, 0x68, 0xba, 0x26, + 0x06, 0xb4, 0x28, 0x2e, 0x18, 0x3a, 0x1c, 0xf5, 0x46, 0xfa, 0x7e, 0xbb, 0x4f, 0xa6, 0xa1, 0x2c, + 0x61, 0xbf, 0x26, 0xfe, 0x50, 0xa0, 0x47, 0x03, 0xcf, 0xbb, 0x71, 0x16, 0x1f, 0xff, 0x5b, 0x17, + 0xbf, 0x2a, 0xd0, 0xff, 0x4d, 0xc4, 0xde, 0x6f, 0x55, 0xd6, 0x49, 0xc4, 0xd8, 0x9d, 0x6f, 0x55, + 0x08, 0x5a, 0xa9, 0xd1, 0x5d, 0x85, 0x3c, 0xcc, 0x82, 0x57, 0xc8, 0x20, 0x45, 0xf4, 0xa5, 0xbf, + 0x0a, 0x44, 0x18, 0x8f, 0xbf, 0x35, 0xb6, 0xdc, 0x5f, 0x07, 0xcb, 0xd8, 0x43, 0x5b, 0x48, 0x25, + 0x2b, 0x68, 0x66, 0xe1, 0x49, 0x4e, 0xe4, 0x26, 0x48, 0x43, 0xd7, 0x78, 0xbc, 0x1b, 0x58, 0xe8, + 0x32, 0x6b, 0x64, 0x03, 0xf7, 0x8a, 0x91, 0x58, 0x75, 0x9c, 0x34, 0x82, 0xab, 0x8e, 0x93, 0xa7, + 0xac, 0x59, 0x23, 0x1f, 0xe0, 0xa8, 0x90, 0x5b, 0xe4, 0x91, 0xbc, 0x81, 0x2c, 0x25, 0x8d, 0x93, + 0x9d, 0xb0, 0xdb, 0xb3, 0x42, 0xb8, 0x5f, 0x1a, 0x4c, 0x52, 0x41, 0x57, 0x7e, 0x09, 0x8d, 0xd3, + 0x1d, 0xd1, 0xbf, 0x9a, 0x59, 0x4c, 0x94, 0x2a, 0x33, 0xa5, 0xd1, 0x59, 0x65, 0xa6, 0x3c, 0xa4, + 0x84, 0x99, 0x85, 0x71, 0xad, 0x32, 0x53, 0x76, 0x39, 0xaa, 0xcc, 0x94, 0xce, 0xbf, 0x59, 0x7b, + 0xd1, 0x7a, 0xa7, 0x0a, 0xc4, 0x8d, 0x9a, 0xfe, 0xc9, 0x78, 0xf2, 0x33, 0x00, 0x00, 0xff, 0xff, + 0x52, 0x0c, 0xa8, 0x50, 0xcb, 0x08, 0x00, 0x00, } diff --git a/pkg/proto/hapi/services/tiller.pb.go b/pkg/proto/hapi/services/tiller.pb.go index d3f8676fc..6e3cdb36f 100644 --- a/pkg/proto/hapi/services/tiller.pb.go +++ b/pkg/proto/hapi/services/tiller.pb.go @@ -1342,6 +1342,7 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("hapi/services/tiller.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ +<<<<<<< b2afe5ec3cb08ec6ff5ca4200bd954d33154c948 // 1170 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xdb, 0x6e, 0xe3, 0x44, 0x18, 0xae, 0xe3, 0x1c, 0xff, 0x1e, 0x48, 0xa7, 0x27, 0xd7, 0x02, 0x54, 0x8c, 0xa0, 0xd9, 0x85, diff --git a/pkg/proto/hapi/version/version.pb.go b/pkg/proto/hapi/version/version.pb.go index b8a711561..e3d8a7096 100644 --- a/pkg/proto/hapi/version/version.pb.go +++ b/pkg/proto/hapi/version/version.pb.go @@ -69,7 +69,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/rudder/client.go b/pkg/rudder/client.go index 694095ef8..220418cb4 100644 --- a/pkg/rudder/client.go +++ b/pkg/rudder/client.go @@ -22,7 +22,7 @@ import ( "golang.org/x/net/context" "google.golang.org/grpc" - "k8s.io/helm/pkg/proto/hapi/release" + rudderAPI "k8s.io/helm/pkg/proto/hapi/rudder" ) // GrpcPort specifies port on which rudder will spawn a server @@ -33,7 +33,7 @@ const ( var grpcAddr = fmt.Sprintf("127.0.0.1:%d", GrpcPort) // InstallRelease calls Rudder InstallRelease method which should create provided release -func InstallRelease(rel *release.InstallReleaseRequest) (*release.InstallReleaseResponse, error) { +func InstallRelease(rel *rudderAPI.InstallReleaseRequest) (*rudderAPI.InstallReleaseResponse, error) { //TODO(mkwiek): parametrize this conn, err := grpc.Dial(grpcAddr, grpc.WithInsecure()) if err != nil { @@ -41,28 +41,28 @@ func InstallRelease(rel *release.InstallReleaseRequest) (*release.InstallRelease } defer conn.Close() - client := release.NewReleaseModuleServiceClient(conn) + client := rudderAPI.NewReleaseModuleServiceClient(conn) return client.InstallRelease(context.Background(), rel) } // UpgradeRelease calls Rudder UpgradeRelease method which should perform update -func UpgradeRelease(req *release.UpgradeReleaseRequest) (*release.UpgradeReleaseResponse, error) { +func UpgradeRelease(req *rudderAPI.UpgradeReleaseRequest) (*rudderAPI.UpgradeReleaseResponse, error) { conn, err := grpc.Dial(grpcAddr, grpc.WithInsecure()) if err != nil { return nil, err } defer conn.Close() - client := release.NewReleaseModuleServiceClient(conn) + client := rudderAPI.NewReleaseModuleServiceClient(conn) return client.UpgradeRelease(context.Background(), req) } // RollbackRelease calls Rudder RollbackRelease method which should perform update -func RollbackRelease(req *release.RollbackReleaseRequest) (*release.RollbackReleaseResponse, error) { +func RollbackRelease(req *rudderAPI.RollbackReleaseRequest) (*rudderAPI.RollbackReleaseResponse, error) { conn, err := grpc.Dial(grpcAddr, grpc.WithInsecure()) if err != nil { return nil, err } defer conn.Close() - client := release.NewReleaseModuleServiceClient(conn) + client := rudderAPI.NewReleaseModuleServiceClient(conn) return client.RollbackRelease(context.Background(), req) } diff --git a/pkg/tiller/release_modules.go b/pkg/tiller/release_modules.go index 755e7a66f..5e18af15f 100644 --- a/pkg/tiller/release_modules.go +++ b/pkg/tiller/release_modules.go @@ -20,6 +20,7 @@ import ( "bytes" "k8s.io/helm/pkg/proto/hapi/release" + rudderAPI "k8s.io/helm/pkg/proto/hapi/rudder" "k8s.io/helm/pkg/proto/hapi/services" "k8s.io/helm/pkg/rudder" "k8s.io/helm/pkg/tiller/environment" @@ -58,14 +59,14 @@ type RemoteReleaseModule struct{} // Create calls rudder.InstallRelease func (m *RemoteReleaseModule) Create(r *release.Release, req *services.InstallReleaseRequest, env *environment.Environment) error { - request := &release.InstallReleaseRequest{Release: r} + request := &rudderAPI.InstallReleaseRequest{Release: r} _, err := rudder.InstallRelease(request) return err } // Update calls rudder.UpgradeRelease func (m *RemoteReleaseModule) Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error { - upgrade := &release.UpgradeReleaseRequest{ + upgrade := &rudderAPI.UpgradeReleaseRequest{ Current: current, Target: target, Recreate: req.Recreate, @@ -78,7 +79,7 @@ func (m *RemoteReleaseModule) Update(current, target *release.Release, req *serv // Rollback calls rudder.Rollback func (m *RemoteReleaseModule) Rollback(current, target *release.Release, req *services.RollbackReleaseRequest, env *environment.Environment) error { - rollback := &release.RollbackReleaseRequest{ + rollback := &rudderAPI.RollbackReleaseRequest{ Current: current, Target: target, Recreate: req.Recreate, From 5937e1a214811180575e350c9073971f9d3bdf6d Mon Sep 17 00:00:00 2001 From: Maciej Kwiek Date: Thu, 23 Mar 2017 14:05:42 +0100 Subject: [PATCH 10/12] ReleaseServer.ReleaseModule has Status method Both local and remote Release module implement release status check. --- cmd/rudder/rudder.go | 9 +++++++-- pkg/rudder/client.go | 11 +++++++++++ pkg/tiller/release_modules.go | 11 +++++++++++ pkg/tiller/release_server.go | 3 +-- 4 files changed, 30 insertions(+), 4 deletions(-) diff --git a/cmd/rudder/rudder.go b/cmd/rudder/rudder.go index a0832d5d7..dfdc498b3 100644 --- a/cmd/rudder/rudder.go +++ b/cmd/rudder/rudder.go @@ -94,8 +94,13 @@ func (r *ReleaseModuleServiceServer) UpgradeRelease(ctx context.Context, in *rud return &rudderAPI.UpgradeReleaseResponse{}, err } -func (r *ReleaseModuleServiceServer) ReleaseStatus(context.Context, *rudderAPI.ReleaseStatusRequest) (*rudderAPI.ReleaseStatusResponse, error) { +func (r *ReleaseModuleServiceServer) ReleaseStatus(ctx context.Context, in *rudderAPI.ReleaseStatusRequest) (*rudderAPI.ReleaseStatusResponse, error) { grpclog.Print("status") - return &rudderAPI.ReleaseStatusResponse{}, nil + resp, err := kubeClient.Get(in.Release.Namespace, bytes.NewBufferString(in.Release.Manifest)) + in.Release.Info.Status.Resources = resp + return &rudderAPI.ReleaseStatusResponse{ + Release: in.Release, + Info: in.Release.Info, + }, err } diff --git a/pkg/rudder/client.go b/pkg/rudder/client.go index 220418cb4..b9fa1283a 100644 --- a/pkg/rudder/client.go +++ b/pkg/rudder/client.go @@ -66,3 +66,14 @@ func RollbackRelease(req *rudderAPI.RollbackReleaseRequest) (*rudderAPI.Rollback client := rudderAPI.NewReleaseModuleServiceClient(conn) return client.RollbackRelease(context.Background(), req) } + +// ReleaseStatus calls Rudder ReleaseStatus method which should perform update +func ReleaseStatus(req *rudderAPI.ReleaseStatusRequest) (*rudderAPI.ReleaseStatusResponse, error) { + conn, err := grpc.Dial(grpcAddr, grpc.WithInsecure()) + if err != nil { + return nil, err + } + defer conn.Close() + client := rudderAPI.NewReleaseModuleServiceClient(conn) + return client.ReleaseStatus(context.Background(), req) +} diff --git a/pkg/tiller/release_modules.go b/pkg/tiller/release_modules.go index 5e18af15f..d85ca3d9b 100644 --- a/pkg/tiller/release_modules.go +++ b/pkg/tiller/release_modules.go @@ -31,6 +31,7 @@ type ReleaseModule interface { Create(r *release.Release, req *services.InstallReleaseRequest, env *environment.Environment) error Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error Rollback(current, target *release.Release, req *services.RollbackReleaseRequest, env *environment.Environment) error + Status(r *release.Release, req *services.GetReleaseStatusRequest, env *environment.Environment) (string, error) } // LocalReleaseModule is a local implementation of ReleaseModule @@ -54,6 +55,10 @@ func (m *LocalReleaseModule) Rollback(current, target *release.Release, req *ser return env.KubeClient.Update(target.Namespace, c, t, req.Recreate, req.Timeout, req.Wait) } +func (m *LocalReleaseModule) Status(r *release.Release, req *services.GetReleaseStatusRequest, env *environment.Environment) (string, error) { + return env.KubeClient.Get(r.Namespace, bytes.NewBufferString(r.Manifest)) +} + // RemoteReleaseModule is a ReleaseModule which calls Rudder service to operate on a release type RemoteReleaseModule struct{} @@ -89,3 +94,9 @@ func (m *RemoteReleaseModule) Rollback(current, target *release.Release, req *se _, err := rudder.RollbackRelease(rollback) return err } + +func (m *RemoteReleaseModule) Status(r *release.Release, req *services.GetReleaseStatusRequest, env *environment.Environment) (string, error) { + statusRequest := &rudderAPI.ReleaseStatusRequest{Release: r} + resp, err := rudder.ReleaseStatus(statusRequest) + return resp.Info.Status.Resources, err +} diff --git a/pkg/tiller/release_server.go b/pkg/tiller/release_server.go index 962b8bd90..63090e2a9 100644 --- a/pkg/tiller/release_server.go +++ b/pkg/tiller/release_server.go @@ -262,8 +262,7 @@ func (s *ReleaseServer) GetReleaseStatus(c ctx.Context, req *services.GetRelease // Ok, we got the status of the release as we had jotted down, now we need to match the // manifest we stashed away with reality from the cluster. - kubeCli := s.env.KubeClient - resp, err := kubeCli.Get(rel.Namespace, bytes.NewBufferString(rel.Manifest)) + resp, err := s.ReleaseModule.Status(rel, req, s.env) if sc == release.Status_DELETED || sc == release.Status_FAILED { // Skip errors if this is already deleted or failed. return statusResp, nil From 1c9ae5577d1d3012ae78f375a9d583a4e50d85c6 Mon Sep 17 00:00:00 2001 From: Maciej Kwiek Date: Wed, 5 Apr 2017 14:58:41 +0200 Subject: [PATCH 11/12] Basic Rudder Delete implementation Extracted delete specific code from ReleaseServer to external function which is called from both Local and Remote ReleaseModules. Made getVersionSet function from tiller package exported. --- cmd/rudder/rudder.go | 46 ++++++++++++++++--- pkg/proto/hapi/services/tiller.pb.go | 1 - pkg/rudder/client.go | 12 +++++ pkg/tiller/release_modules.go | 68 +++++++++++++++++++++++++++- pkg/tiller/release_server.go | 50 +++++--------------- pkg/tiller/release_server_test.go | 11 +++-- 6 files changed, 138 insertions(+), 50 deletions(-) diff --git a/cmd/rudder/rudder.go b/cmd/rudder/rudder.go index dfdc498b3..be403c45e 100644 --- a/cmd/rudder/rudder.go +++ b/cmd/rudder/rudder.go @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -package main // import "k8s.io/helm/cmd/rudder" +package main import ( "bytes" @@ -24,16 +24,26 @@ import ( "golang.org/x/net/context" "google.golang.org/grpc" "google.golang.org/grpc/grpclog" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" "k8s.io/helm/pkg/kube" rudderAPI "k8s.io/helm/pkg/proto/hapi/rudder" "k8s.io/helm/pkg/rudder" + "k8s.io/helm/pkg/tiller" "k8s.io/helm/pkg/version" ) -var kubeClient = kube.New(nil) +var kubeClient *kube.Client +var clientset internalclientset.Interface func main() { + var err error + kubeClient = kube.New(nil) + clientset, err = kubeClient.ClientSet() + if err != nil { + grpclog.Fatalf("Cannot initialize Kubernetes connection: %s", err) + } + lis, err := net.Listen("tcp", fmt.Sprintf(":%d", rudder.GrpcPort)) if err != nil { grpclog.Fatalf("failed to listen: %v", err) @@ -64,18 +74,42 @@ func (r *ReleaseModuleServiceServer) InstallRelease(ctx context.Context, in *rud b := bytes.NewBufferString(in.Release.Manifest) err := kubeClient.Create(in.Release.Namespace, b, 500, false) if err != nil { - grpclog.Printf("error when creating release: %s", err) + grpclog.Printf("error when creating release: %v", err) } return &rudderAPI.InstallReleaseResponse{}, err } -// DeleteRelease is not implemented +// DeleteRelease deletes a provided release func (r *ReleaseModuleServiceServer) DeleteRelease(ctx context.Context, in *rudderAPI.DeleteReleaseRequest) (*rudderAPI.DeleteReleaseResponse, error) { grpclog.Print("delete") - return nil, nil + + resp := &rudderAPI.DeleteReleaseResponse{} + rel := in.Release + vs, err := tiller.GetVersionSet(clientset.Discovery()) + if err != nil { + return resp, fmt.Errorf("Could not get apiVersions from Kubernetes: %v", err) + } + + kept, errs := tiller.DeleteRelease(rel, vs, kubeClient) + rel.Manifest = kept + + allErrors := "" + for _, e := range errs { + allErrors = allErrors + "\n" + e.Error() + } + + if len(allErrors) > 0 { + err = fmt.Errorf(allErrors) + } else { + err = nil + } + + return &rudderAPI.DeleteReleaseResponse{ + Release: rel, + }, err } -// RollbackRelease is not implemented +// RollbackRelease rolls back the release func (r *ReleaseModuleServiceServer) RollbackRelease(ctx context.Context, in *rudderAPI.RollbackReleaseRequest) (*rudderAPI.RollbackReleaseResponse, error) { grpclog.Print("rollback") c := bytes.NewBufferString(in.Current.Manifest) diff --git a/pkg/proto/hapi/services/tiller.pb.go b/pkg/proto/hapi/services/tiller.pb.go index 6e3cdb36f..d3f8676fc 100644 --- a/pkg/proto/hapi/services/tiller.pb.go +++ b/pkg/proto/hapi/services/tiller.pb.go @@ -1342,7 +1342,6 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("hapi/services/tiller.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ -<<<<<<< b2afe5ec3cb08ec6ff5ca4200bd954d33154c948 // 1170 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xdb, 0x6e, 0xe3, 0x44, 0x18, 0xae, 0xe3, 0x1c, 0xff, 0x1e, 0x48, 0xa7, 0x27, 0xd7, 0x02, 0x54, 0x8c, 0xa0, 0xd9, 0x85, diff --git a/pkg/rudder/client.go b/pkg/rudder/client.go index b9fa1283a..219bb010a 100644 --- a/pkg/rudder/client.go +++ b/pkg/rudder/client.go @@ -77,3 +77,15 @@ func ReleaseStatus(req *rudderAPI.ReleaseStatusRequest) (*rudderAPI.ReleaseStatu client := rudderAPI.NewReleaseModuleServiceClient(conn) return client.ReleaseStatus(context.Background(), req) } + +// DeleteRelease calls Rudder DeleteRelease method which should uninstall provided release +func DeleteRelease(rel *rudderAPI.DeleteReleaseRequest) (*rudderAPI.DeleteReleaseResponse, error) { + conn, err := grpc.Dial(grpcAddr, grpc.WithInsecure()) + if err != nil { + return nil, err + } + + defer conn.Close() + client := rudderAPI.NewReleaseModuleServiceClient(conn) + return client.DeleteRelease(context.Background(), rel) +} diff --git a/pkg/tiller/release_modules.go b/pkg/tiller/release_modules.go index d85ca3d9b..620ec56dc 100644 --- a/pkg/tiller/release_modules.go +++ b/pkg/tiller/release_modules.go @@ -18,10 +18,19 @@ package tiller import ( "bytes" + "errors" + "fmt" + "log" + "strings" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" + + "k8s.io/helm/pkg/chartutil" + "k8s.io/helm/pkg/kube" "k8s.io/helm/pkg/proto/hapi/release" rudderAPI "k8s.io/helm/pkg/proto/hapi/rudder" "k8s.io/helm/pkg/proto/hapi/services" + relutil "k8s.io/helm/pkg/releaseutil" "k8s.io/helm/pkg/rudder" "k8s.io/helm/pkg/tiller/environment" ) @@ -32,10 +41,13 @@ type ReleaseModule interface { Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error Rollback(current, target *release.Release, req *services.RollbackReleaseRequest, env *environment.Environment) error Status(r *release.Release, req *services.GetReleaseStatusRequest, env *environment.Environment) (string, error) + Delete(r *release.Release, req *services.UninstallReleaseRequest, env *environment.Environment) (string, []error) } // LocalReleaseModule is a local implementation of ReleaseModule -type LocalReleaseModule struct{} +type LocalReleaseModule struct { + clientset internalclientset.Interface +} // Create creates a release via kubeclient from provided environment func (m *LocalReleaseModule) Create(r *release.Release, req *services.InstallReleaseRequest, env *environment.Environment) error { @@ -59,6 +71,15 @@ func (m *LocalReleaseModule) Status(r *release.Release, req *services.GetRelease return env.KubeClient.Get(r.Namespace, bytes.NewBufferString(r.Manifest)) } +// Delete deletes the release and returns manifests that were kept in the deletion process +func (m *LocalReleaseModule) Delete(rel *release.Release, req *services.UninstallReleaseRequest, env *environment.Environment) (kept string, errs []error) { + vs, err := GetVersionSet(m.clientset.Discovery()) + if err != nil { + return rel.Manifest, []error{fmt.Errorf("Could not get apiVersions from Kubernetes: %v", err)} + } + return DeleteRelease(rel, vs, env.KubeClient) +} + // RemoteReleaseModule is a ReleaseModule which calls Rudder service to operate on a release type RemoteReleaseModule struct{} @@ -100,3 +121,48 @@ func (m *RemoteReleaseModule) Status(r *release.Release, req *services.GetReleas resp, err := rudder.ReleaseStatus(statusRequest) return resp.Info.Status.Resources, err } + +// Delete calls rudder.DeleteRelease +func (m *RemoteReleaseModule) Delete(r *release.Release, req *services.UninstallReleaseRequest, env *environment.Environment) (string, []error) { + deleteRequest := &rudderAPI.DeleteReleaseRequest{Release: r} + resp, err := rudder.DeleteRelease(deleteRequest) + if err != nil { + return resp.Release.Manifest, []error{err} + } + return resp.Release.Manifest, []error{} +} + +// DeleteRelease is a helper that allows Rudder to delete a release without exposing most of Tiller inner functions +func DeleteRelease(rel *release.Release, vs chartutil.VersionSet, kubeClient environment.KubeClient) (kept string, errs []error) { + manifests := relutil.SplitManifests(rel.Manifest) + _, files, err := sortManifests(manifests, vs, UninstallOrder) + if err != nil { + // We could instead just delete everything in no particular order. + // FIXME: One way to delete at this point would be to try a label-based + // deletion. The problem with this is that we could get a false positive + // and delete something that was not legitimately part of this release. + return rel.Manifest, []error{fmt.Errorf("corrupted release record. You must manually delete the resources: %s", err)} + } + + filesToKeep, filesToDelete := filterManifestsToKeep(files) + if len(filesToKeep) > 0 { + kept = summarizeKeptManifests(filesToKeep) + } + + errs = []error{} + for _, file := range filesToDelete { + b := bytes.NewBufferString(strings.TrimSpace(file.content)) + if b.Len() == 0 { + continue + } + if err := kubeClient.Delete(rel.Namespace, b); err != nil { + log.Printf("uninstall: Failed deletion of %q: %s", rel.Name, err) + if err == kube.ErrNoObjectsVisited { + // Rewrite the message from "no objects visited" + err = errors.New("object not found, skipping delete") + } + errs = append(errs, err) + } + } + return kept, errs +} diff --git a/pkg/tiller/release_server.go b/pkg/tiller/release_server.go index 63090e2a9..adc4ddf3c 100644 --- a/pkg/tiller/release_server.go +++ b/pkg/tiller/release_server.go @@ -33,7 +33,6 @@ import ( "k8s.io/helm/pkg/chartutil" "k8s.io/helm/pkg/hooks" - "k8s.io/helm/pkg/kube" "k8s.io/helm/pkg/proto/hapi/chart" "k8s.io/helm/pkg/proto/hapi/release" "k8s.io/helm/pkg/proto/hapi/services" @@ -93,7 +92,9 @@ func NewReleaseServer(env *environment.Environment, clientset internalclientset. if useRemote { releaseModule = &RemoteReleaseModule{} } else { - releaseModule = &LocalReleaseModule{} + releaseModule = &LocalReleaseModule{ + clientset: clientset, + } } return &ReleaseServer{ @@ -681,7 +682,7 @@ func capabilities(disc discovery.DiscoveryInterface) (*chartutil.Capabilities, e if err != nil { return nil, err } - vs, err := getVersionSet(disc) + vs, err := GetVersionSet(disc) if err != nil { return nil, fmt.Errorf("Could not get apiVersions from Kubernetes: %s", err) } @@ -769,7 +770,8 @@ func (s *ReleaseServer) prepareRelease(req *services.InstallReleaseRequest) (*re return rel, err } -func getVersionSet(client discovery.ServerGroupsInterface) (chartutil.VersionSet, error) { +// GetVersionSet retrieves a set of available k8s API versions +func GetVersionSet(client discovery.ServerGroupsInterface) (chartutil.VersionSet, error) { groups, err := client.ServerGroups() if err != nil { return chartutil.DefaultVersionSet, err @@ -1050,47 +1052,19 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR } } - vs, err := getVersionSet(s.clientset.Discovery()) - if err != nil { - return nil, fmt.Errorf("Could not get apiVersions from Kubernetes: %s", err) - } - // 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) } - manifests := relutil.SplitManifests(rel.Manifest) - _, files, err := sortManifests(manifests, vs, UninstallOrder) - if err != nil { - // We could instead just delete everything in no particular order. - // FIXME: One way to delete at this point would be to try a label-based - // deletion. The problem with this is that we could get a false positive - // and delete something that was not legitimately part of this release. - return nil, fmt.Errorf("corrupted release record. You must manually delete the resources: %s", err) - } + kept, errs := s.ReleaseModule.Delete(rel, req, s.env) + res.Info = kept - filesToKeep, filesToDelete := filterManifestsToKeep(files) - if len(filesToKeep) > 0 { - res.Info = summarizeKeptManifests(filesToKeep) - } - - // Collect the errors, and return them later. - es := []string{} - for _, file := range filesToDelete { - b := bytes.NewBufferString(strings.TrimSpace(file.content)) - if b.Len() == 0 { - continue - } - if err := s.env.KubeClient.Delete(rel.Namespace, b); err != nil { - log.Printf("uninstall: Failed deletion of %q: %s", req.Name, err) - if err == kube.ErrNoObjectsVisited { - // Rewrite the message from "no objects visited" - err = errors.New("object not found, skipping delete") - } - es = append(es, err.Error()) - } + es := make([]string, 0, len(errs)) + for _, e := range errs { + log.Printf("error: %v", e) + es = append(es, e.Error()) } if !req.DisableHooks { diff --git a/pkg/tiller/release_server_test.go b/pkg/tiller/release_server_test.go index e34d68e98..fd09fa47b 100644 --- a/pkg/tiller/release_server_test.go +++ b/pkg/tiller/release_server_test.go @@ -98,10 +98,13 @@ data: ` func rsFixture() *ReleaseServer { + clientset := fake.NewSimpleClientset() return &ReleaseServer{ - ReleaseModule: &LocalReleaseModule{}, - env: MockEnvironment(), - clientset: fake.NewSimpleClientset(), + ReleaseModule: &LocalReleaseModule{ + clientset: clientset, + }, + env: MockEnvironment(), + clientset: clientset, } } @@ -207,7 +210,7 @@ func TestValidName(t *testing.T) { func TestGetVersionSet(t *testing.T) { rs := rsFixture() - vs, err := getVersionSet(rs.clientset.Discovery()) + vs, err := GetVersionSet(rs.clientset.Discovery()) if err != nil { t.Error(err) } From d9f72deb0d03da2f5e5179479007022c711f38ae Mon Sep 17 00:00:00 2001 From: Maciej Kwiek Date: Mon, 24 Apr 2017 13:22:02 +0200 Subject: [PATCH 12/12] Add comments to exported Rudder methods Added make target Lowered docker image sizes Updated ruder.pb.go --- Makefile | 9 +++- cmd/rudder/rudder.go | 4 +- pkg/proto/hapi/rudder/rudder.pb.go | 76 ++++++++++++++++++++++++++++-- pkg/tiller/release_modules.go | 4 ++ rootfs/Dockerfile.experimental | 2 +- rootfs/Dockerfile.rudder | 2 +- 6 files changed, 87 insertions(+), 10 deletions(-) diff --git a/Makefile b/Makefile index 86d9b76e9..dbe8e0334 100644 --- a/Makefile +++ b/Makefile @@ -61,15 +61,20 @@ docker-binary: BINDIR = ./rootfs docker-binary: GOFLAGS += -a -installsuffix cgo docker-binary: GOOS=linux GOARCH=amd64 CGO_ENABLED=0 $(GO) build -o $(BINDIR)/tiller $(GOFLAGS) -tags '$(TAGS)' -ldflags '$(LDFLAGS)' k8s.io/helm/cmd/tiller - GOOS=linux GOARCH=amd64 CGO_ENABLED=0 $(GO) build -o $(BINDIR)/rudder $(GOFLAGS) -tags '$(TAGS)' -ldflags '$(LDFLAGS)' k8s.io/helm/cmd/rudder .PHONY: docker-build docker-build: check-docker docker-binary docker build --rm -t ${IMAGE} rootfs docker tag ${IMAGE} ${MUTABLE_IMAGE} +.PHONY: docker-binary-rudder +docker-binary-rudder: BINDIR = ./rootfs +docker-binary-rudder: GOFLAGS += -a -installsuffix cgo +docker-binary-rudder: + GOOS=linux GOARCH=amd64 CGO_ENABLED=0 $(GO) build -o $(BINDIR)/rudder $(GOFLAGS) -tags '$(TAGS)' -ldflags '$(LDFLAGS)' k8s.io/helm/cmd/rudder + .PHONY: docker-build-experimental -docker-build-experimental: check-docker docker-binary +docker-build-experimental: check-docker docker-binary docker-binary-rudder docker build --rm -t ${IMAGE} rootfs -f rootfs/Dockerfile.experimental docker tag ${IMAGE} ${MUTABLE_IMAGE} docker build --rm -t ${IMAGE_RUDDER} rootfs -f rootfs/Dockerfile.rudder diff --git a/cmd/rudder/rudder.go b/cmd/rudder/rudder.go index be403c45e..0a5a97bff 100644 --- a/cmd/rudder/rudder.go +++ b/cmd/rudder/rudder.go @@ -59,7 +59,7 @@ func main() { // ReleaseModuleServiceServer provides implementation for rudderAPI.ReleaseModuleServiceServer type ReleaseModuleServiceServer struct{} -// Version is not yet implemented +// Version returns Rudder version based on helm version func (r *ReleaseModuleServiceServer) Version(ctx context.Context, in *rudderAPI.VersionReleaseRequest) (*rudderAPI.VersionReleaseResponse, error) { grpclog.Print("version") return &rudderAPI.VersionReleaseResponse{ @@ -100,8 +100,6 @@ func (r *ReleaseModuleServiceServer) DeleteRelease(ctx context.Context, in *rudd if len(allErrors) > 0 { err = fmt.Errorf(allErrors) - } else { - err = nil } return &rudderAPI.DeleteReleaseResponse{ diff --git a/pkg/proto/hapi/rudder/rudder.pb.go b/pkg/proto/hapi/rudder/rudder.pb.go index e5c9f66b1..af5577678 100644 --- a/pkg/proto/hapi/rudder/rudder.pb.go +++ b/pkg/proto/hapi/rudder/rudder.pb.go @@ -88,6 +88,20 @@ func (m *Result) String() string { return proto.CompactTextString(m) func (*Result) ProtoMessage() {} func (*Result) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } +func (m *Result) GetInfo() string { + if m != nil { + return m.Info + } + return "" +} + +func (m *Result) GetLog() []string { + if m != nil { + return m.Log + } + return nil +} + type VersionReleaseRequest struct { } @@ -106,6 +120,20 @@ func (m *VersionReleaseResponse) String() string { return proto.Compa func (*VersionReleaseResponse) ProtoMessage() {} func (*VersionReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } +func (m *VersionReleaseResponse) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *VersionReleaseResponse) GetVersion() string { + if m != nil { + return m.Version + } + return "" +} + type InstallReleaseRequest struct { Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` } @@ -213,6 +241,27 @@ func (m *UpgradeReleaseRequest) GetTarget() *hapi_release5.Release { return nil } +func (m *UpgradeReleaseRequest) GetTimeout() int64 { + if m != nil { + return m.Timeout + } + return 0 +} + +func (m *UpgradeReleaseRequest) GetWait() bool { + if m != nil { + return m.Wait + } + return false +} + +func (m *UpgradeReleaseRequest) GetRecreate() bool { + if m != nil { + return m.Recreate + } + return false +} + type UpgradeReleaseResponse struct { Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` @@ -264,6 +313,27 @@ func (m *RollbackReleaseRequest) GetTarget() *hapi_release5.Release { return nil } +func (m *RollbackReleaseRequest) GetTimeout() int64 { + if m != nil { + return m.Timeout + } + return 0 +} + +func (m *RollbackReleaseRequest) GetWait() bool { + if m != nil { + return m.Wait + } + return false +} + +func (m *RollbackReleaseRequest) GetRecreate() bool { + if m != nil { + return m.Recreate + } + return false +} + type RollbackReleaseResponse struct { Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"` Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"` @@ -351,7 +421,7 @@ var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion3 +const _ = grpc.SupportPackageIsVersion4 // Client API for ReleaseModuleService service @@ -589,14 +659,14 @@ var _ReleaseModuleService_serviceDesc = grpc.ServiceDesc{ }, }, Streams: []grpc.StreamDesc{}, - Metadata: fileDescriptor0, + Metadata: "hapi/rudder/rudder.proto", } func init() { proto.RegisterFile("hapi/rudder/rudder.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ // 584 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xd1, 0x8e, 0xd2, 0x40, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x56, 0xd1, 0x8e, 0xd2, 0x40, 0x14, 0xa5, 0xcb, 0x52, 0xe0, 0x92, 0x55, 0x32, 0xd9, 0x42, 0xd3, 0xf8, 0x40, 0xfa, 0x60, 0x88, 0xeb, 0x96, 0x04, 0x7d, 0xf4, 0x45, 0x59, 0xdc, 0xdd, 0x18, 0xd9, 0x64, 0x2a, 0x6e, 0xe2, 0x5b, 0x17, 0x2e, 0x58, 0x2d, 0x6d, 0x9d, 0x4e, 0xf7, 0x51, 0xfd, 0x1a, 0xff, 0x43, 0xbf, 0xcc, 0xb4, diff --git a/pkg/tiller/release_modules.go b/pkg/tiller/release_modules.go index 620ec56dc..e13b26de9 100644 --- a/pkg/tiller/release_modules.go +++ b/pkg/tiller/release_modules.go @@ -55,18 +55,21 @@ func (m *LocalReleaseModule) Create(r *release.Release, req *services.InstallRel return env.KubeClient.Create(r.Namespace, b, req.Timeout, req.Wait) } +// Update performs an update from current to target release func (m *LocalReleaseModule) Update(current, target *release.Release, req *services.UpdateReleaseRequest, env *environment.Environment) error { c := bytes.NewBufferString(current.Manifest) t := bytes.NewBufferString(target.Manifest) return env.KubeClient.Update(target.Namespace, c, t, req.Recreate, req.Timeout, req.Wait) } +// Rollback performs a rollback from current to target release func (m *LocalReleaseModule) Rollback(current, target *release.Release, req *services.RollbackReleaseRequest, env *environment.Environment) error { c := bytes.NewBufferString(current.Manifest) t := bytes.NewBufferString(target.Manifest) return env.KubeClient.Update(target.Namespace, c, t, req.Recreate, req.Timeout, req.Wait) } +// Status returns kubectl-like formatted status of release objects func (m *LocalReleaseModule) Status(r *release.Release, req *services.GetReleaseStatusRequest, env *environment.Environment) (string, error) { return env.KubeClient.Get(r.Namespace, bytes.NewBufferString(r.Manifest)) } @@ -116,6 +119,7 @@ func (m *RemoteReleaseModule) Rollback(current, target *release.Release, req *se return err } +// Status returns status retrieved from rudder.ReleaseStatus func (m *RemoteReleaseModule) Status(r *release.Release, req *services.GetReleaseStatusRequest, env *environment.Environment) (string, error) { statusRequest := &rudderAPI.ReleaseStatusRequest{Release: r} resp, err := rudder.ReleaseStatus(statusRequest) diff --git a/rootfs/Dockerfile.experimental b/rootfs/Dockerfile.experimental index 0528471e6..8f3bce3c0 100644 --- a/rootfs/Dockerfile.experimental +++ b/rootfs/Dockerfile.experimental @@ -16,7 +16,7 @@ FROM alpine:3.3 ENV HOME /tmp -COPY . / +COPY tiller /tiller EXPOSE 44134 diff --git a/rootfs/Dockerfile.rudder b/rootfs/Dockerfile.rudder index d39d0ebdb..7821096c5 100644 --- a/rootfs/Dockerfile.rudder +++ b/rootfs/Dockerfile.rudder @@ -16,7 +16,7 @@ FROM alpine:3.3 ENV HOME /tmp -COPY . / +COPY rudder /rudder EXPOSE 10001