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

TEST: add option to dump logs during helm test

Browse Source 
Signed-off-by: Jeff Knurek <j.knurek@travelaudience.com>
pull/6167/head
Jeff Knurek 6 years ago
parent e04fa72f6f
commit 653541d145
8 changed files with 182 additions and 113 deletions
Show Stats Download Patch File Download Diff File

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

@ -350,6 +350,8 @@ message TestReleaseRequest {
bool cleanup = 3;
// parallel specifies whether or not to run test pods in parallel
bool parallel = 4;
// logs specifies whether or not to dump the logs from the test pods
bool logs = 5;
}
// TestReleaseResponse represents a message from executing a test

3
cmd/helm/release_testing.go
Unescape View File

@ -40,6 +40,7 @@ type releaseTestCmd struct {
timeout int64
cleanup bool
parallel bool
logs bool
}
func newReleaseTestCmd(c helm.Interface, out io.Writer) *cobra.Command {
@ -69,6 +70,7 @@ func newReleaseTestCmd(c helm.Interface, out io.Writer) *cobra.Command {
f.Int64Var(&rlsTest.timeout, "timeout", 300, "Time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks)")
f.BoolVar(&rlsTest.cleanup, "cleanup", false, "Delete test pods upon completion")
f.BoolVar(&rlsTest.parallel, "parallel", false, "Run test pods in parallel")
f.BoolVar(&rlsTest.logs, "logs", false, "Dump the logs from test pods (this runs after all tests are complete, but before any cleanup")
// set defaults from environment
settings.InitTLS(f)
@ -82,6 +84,7 @@ func (t *releaseTestCmd) run() (err error) {
helm.ReleaseTestTimeout(t.timeout),
helm.ReleaseTestCleanup(t.cleanup),
helm.ReleaseTestParallel(t.parallel),
helm.ReleaseTestLogs(t.logs),
)
testErr := &testErr{}

7
pkg/helm/option.go
Unescape View File

@ -234,6 +234,13 @@ func ReleaseTestParallel(parallel bool) ReleaseTestOption {
}
}
// ReleaseTestLogs is a boolean value representing whether to dump the logs from test pods
func ReleaseTestLogs(logs bool) ReleaseTestOption {
return func(opts *options) {
opts.testReq.Logs = logs
}
}
// RollbackTimeout specifies the number of seconds before kubernetes calls timeout
func RollbackTimeout(timeout int64) RollbackOption {
return func(opts *options) {

18
pkg/kube/client.go
Unescape View File

@ -929,6 +929,24 @@ func (c *Client) watchPodUntilComplete(timeout time.Duration, info *resource.Inf
return err
}
// GetPodLogs takes pod name and namespace and returns the current logs (streaming is NOT enabled).
func (c *Client) GetPodLogs(name, ns string) (string, error) {
client, _ := c.KubernetesClientSet()
req := client.CoreV1().Pods(ns).GetLogs(name, &v1.PodLogOptions{})
podLogs, err := req.Stream()
if err != nil {
return "", fmt.Errorf("error in opening log stream, got: %s", err)
}
defer podLogs.Close()
buf := new(bytes.Buffer)
_, err = io.Copy(buf, podLogs)
if err != nil {
return "", fmt.Errorf("error in copy information from log stream to buf, got: %s", err)
}
return buf.String(), nil
}
func isPodComplete(event watch.Event) (bool, error) {
o, ok := event.Object.(*v1.Pod)
if !ok {

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

@ -53,7 +53,7 @@ func (x ListSort_SortBy) String() string {
return proto.EnumName(ListSort_SortBy_name, int32(x))
}
func (ListSort_SortBy) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{1, 0}
return fileDescriptor_tiller_4fda016196f30239, []int{1, 0}
}
// SortOrder defines sort orders to augment sorting operations.
@ -77,7 +77,7 @@ func (x ListSort_SortOrder) String() string {
return proto.EnumName(ListSort_SortOrder_name, int32(x))
}
func (ListSort_SortOrder) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{1, 1}
return fileDescriptor_tiller_4fda016196f30239, []int{1, 1}
}
// ListReleasesRequest requests a list of releases.
@ -114,7 +114,7 @@ func (m *ListReleasesRequest) Reset() { *m = ListReleasesRequest{} }
func (m *ListReleasesRequest) String() string { return proto.CompactTextString(m) }
func (*ListReleasesRequest) ProtoMessage() {}
func (*ListReleasesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{0}
return fileDescriptor_tiller_4fda016196f30239, []int{0}
}
func (m *ListReleasesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListReleasesRequest.Unmarshal(m, b)
@ -194,7 +194,7 @@ func (m *ListSort) Reset() { *m = ListSort{} }
func (m *ListSort) String() string { return proto.CompactTextString(m) }
func (*ListSort) ProtoMessage() {}
func (*ListSort) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{1}
return fileDescriptor_tiller_4fda016196f30239, []int{1}
}
func (m *ListSort) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListSort.Unmarshal(m, b)
@ -234,7 +234,7 @@ func (m *ListReleasesResponse) Reset() { *m = ListReleasesResponse{} }
func (m *ListReleasesResponse) String() string { return proto.CompactTextString(m) }
func (*ListReleasesResponse) ProtoMessage() {}
func (*ListReleasesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{2}
return fileDescriptor_tiller_4fda016196f30239, []int{2}
}
func (m *ListReleasesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListReleasesResponse.Unmarshal(m, b)
@ -297,7 +297,7 @@ func (m *GetReleaseStatusRequest) Reset() { *m = GetReleaseStatusRequest
func (m *GetReleaseStatusRequest) String() string { return proto.CompactTextString(m) }
func (*GetReleaseStatusRequest) ProtoMessage() {}
func (*GetReleaseStatusRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{3}
return fileDescriptor_tiller_4fda016196f30239, []int{3}
}
func (m *GetReleaseStatusRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetReleaseStatusRequest.Unmarshal(m, b)
@ -348,7 +348,7 @@ func (m *GetReleaseStatusResponse) Reset() { *m = GetReleaseStatusRespon
func (m *GetReleaseStatusResponse) String() string { return proto.CompactTextString(m) }
func (*GetReleaseStatusResponse) ProtoMessage() {}
func (*GetReleaseStatusResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{4}
return fileDescriptor_tiller_4fda016196f30239, []int{4}
}
func (m *GetReleaseStatusResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetReleaseStatusResponse.Unmarshal(m, b)
@ -404,7 +404,7 @@ func (m *GetReleaseContentRequest) Reset() { *m = GetReleaseContentReque
func (m *GetReleaseContentRequest) String() string { return proto.CompactTextString(m) }
func (*GetReleaseContentRequest) ProtoMessage() {}
func (*GetReleaseContentRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{5}
return fileDescriptor_tiller_4fda016196f30239, []int{5}
}
func (m *GetReleaseContentRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetReleaseContentRequest.Unmarshal(m, b)
@ -451,7 +451,7 @@ func (m *GetReleaseContentResponse) Reset() { *m = GetReleaseContentResp
func (m *GetReleaseContentResponse) String() string { return proto.CompactTextString(m) }
func (*GetReleaseContentResponse) ProtoMessage() {}
func (*GetReleaseContentResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{6}
return fileDescriptor_tiller_4fda016196f30239, []int{6}
}
func (m *GetReleaseContentResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetReleaseContentResponse.Unmarshal(m, b)
@ -519,7 +519,7 @@ func (m *UpdateReleaseRequest) Reset() { *m = UpdateReleaseRequest{} }
func (m *UpdateReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateReleaseRequest) ProtoMessage() {}
func (*UpdateReleaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{7}
return fileDescriptor_tiller_4fda016196f30239, []int{7}
}
func (m *UpdateReleaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateReleaseRequest.Unmarshal(m, b)
@ -649,7 +649,7 @@ func (m *UpdateReleaseResponse) Reset() { *m = UpdateReleaseResponse{} }
func (m *UpdateReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateReleaseResponse) ProtoMessage() {}
func (*UpdateReleaseResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{8}
return fileDescriptor_tiller_4fda016196f30239, []int{8}
}
func (m *UpdateReleaseResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateReleaseResponse.Unmarshal(m, b)
@ -707,7 +707,7 @@ func (m *RollbackReleaseRequest) Reset() { *m = RollbackReleaseRequest{}
func (m *RollbackReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*RollbackReleaseRequest) ProtoMessage() {}
func (*RollbackReleaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{9}
return fileDescriptor_tiller_4fda016196f30239, []int{9}
}
func (m *RollbackReleaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RollbackReleaseRequest.Unmarshal(m, b)
@ -809,7 +809,7 @@ func (m *RollbackReleaseResponse) Reset() { *m = RollbackReleaseResponse
func (m *RollbackReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*RollbackReleaseResponse) ProtoMessage() {}
func (*RollbackReleaseResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{10}
return fileDescriptor_tiller_4fda016196f30239, []int{10}
}
func (m *RollbackReleaseResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RollbackReleaseResponse.Unmarshal(m, b)
@ -874,7 +874,7 @@ func (m *InstallReleaseRequest) Reset() { *m = InstallReleaseRequest{} }
func (m *InstallReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*InstallReleaseRequest) ProtoMessage() {}
func (*InstallReleaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{11}
return fileDescriptor_tiller_4fda016196f30239, []int{11}
}
func (m *InstallReleaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InstallReleaseRequest.Unmarshal(m, b)
@ -990,7 +990,7 @@ func (m *InstallReleaseResponse) Reset() { *m = InstallReleaseResponse{}
func (m *InstallReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*InstallReleaseResponse) ProtoMessage() {}
func (*InstallReleaseResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{12}
return fileDescriptor_tiller_4fda016196f30239, []int{12}
}
func (m *InstallReleaseResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InstallReleaseResponse.Unmarshal(m, b)
@ -1038,7 +1038,7 @@ func (m *UninstallReleaseRequest) Reset() { *m = UninstallReleaseRequest
func (m *UninstallReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*UninstallReleaseRequest) ProtoMessage() {}
func (*UninstallReleaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{13}
return fileDescriptor_tiller_4fda016196f30239, []int{13}
}
func (m *UninstallReleaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UninstallReleaseRequest.Unmarshal(m, b)
@ -1108,7 +1108,7 @@ func (m *UninstallReleaseResponse) Reset() { *m = UninstallReleaseRespon
func (m *UninstallReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*UninstallReleaseResponse) ProtoMessage() {}
func (*UninstallReleaseResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{14}
return fileDescriptor_tiller_4fda016196f30239, []int{14}
}
func (m *UninstallReleaseResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UninstallReleaseResponse.Unmarshal(m, b)
@ -1153,7 +1153,7 @@ func (m *GetVersionRequest) Reset() { *m = GetVersionRequest{} }
func (m *GetVersionRequest) String() string { return proto.CompactTextString(m) }
func (*GetVersionRequest) ProtoMessage() {}
func (*GetVersionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{15}
return fileDescriptor_tiller_4fda016196f30239, []int{15}
}
func (m *GetVersionRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetVersionRequest.Unmarshal(m, b)
@ -1184,7 +1184,7 @@ func (m *GetVersionResponse) Reset() { *m = GetVersionResponse{} }
func (m *GetVersionResponse) String() string { return proto.CompactTextString(m) }
func (*GetVersionResponse) ProtoMessage() {}
func (*GetVersionResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{16}
return fileDescriptor_tiller_4fda016196f30239, []int{16}
}
func (m *GetVersionResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetVersionResponse.Unmarshal(m, b)
@ -1226,7 +1226,7 @@ func (m *GetHistoryRequest) Reset() { *m = GetHistoryRequest{} }
func (m *GetHistoryRequest) String() string { return proto.CompactTextString(m) }
func (*GetHistoryRequest) ProtoMessage() {}
func (*GetHistoryRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{17}
return fileDescriptor_tiller_4fda016196f30239, []int{17}
}
func (m *GetHistoryRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetHistoryRequest.Unmarshal(m, b)
@ -1272,7 +1272,7 @@ func (m *GetHistoryResponse) Reset() { *m = GetHistoryResponse{} }
func (m *GetHistoryResponse) String() string { return proto.CompactTextString(m) }
func (*GetHistoryResponse) ProtoMessage() {}
func (*GetHistoryResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{18}
return fileDescriptor_tiller_4fda016196f30239, []int{18}
}
func (m *GetHistoryResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetHistoryResponse.Unmarshal(m, b)
@ -1308,7 +1308,9 @@ type TestReleaseRequest struct {
// cleanup specifies whether or not to attempt pod deletion after test completes
Cleanup bool `protobuf:"varint,3,opt,name=cleanup,proto3" json:"cleanup,omitempty"`
// parallel specifies whether or not to run test pods in parallel
Parallel bool `protobuf:"varint,4,opt,name=parallel,proto3" json:"parallel,omitempty"`
Parallel bool `protobuf:"varint,4,opt,name=parallel,proto3" json:"parallel,omitempty"`
// logs specifies whether or not to dump the logs from the test pods
Logs bool `protobuf:"varint,5,opt,name=logs,proto3" json:"logs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1318,7 +1320,7 @@ func (m *TestReleaseRequest) Reset() { *m = TestReleaseRequest{} }
func (m *TestReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*TestReleaseRequest) ProtoMessage() {}
func (*TestReleaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{19}
return fileDescriptor_tiller_4fda016196f30239, []int{19}
}
func (m *TestReleaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TestReleaseRequest.Unmarshal(m, b)
@ -1366,6 +1368,13 @@ func (m *TestReleaseRequest) GetParallel() bool {
return false
}
func (m *TestReleaseRequest) GetLogs() bool {
if m != nil {
return m.Logs
}
return false
}
// TestReleaseResponse represents a message from executing a test
type TestReleaseResponse struct {
Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
@ -1379,7 +1388,7 @@ func (m *TestReleaseResponse) Reset() { *m = TestReleaseResponse{} }
func (m *TestReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*TestReleaseResponse) ProtoMessage() {}
func (*TestReleaseResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_tiller_bb72ee4a42494734, []int{20}
return fileDescriptor_tiller_4fda016196f30239, []int{20}
}
func (m *TestReleaseResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TestReleaseResponse.Unmarshal(m, b)
@ -1889,92 +1898,93 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{
Metadata: "hapi/services/tiller.proto",
}
func init() { proto.RegisterFile("hapi/services/tiller.proto", fileDescriptor_tiller_bb72ee4a42494734) }
var fileDescriptor_tiller_bb72ee4a42494734 = []byte{
// 1337 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0xdd, 0x72, 0xdb, 0x44,
0x14, 0x8e, 0x2d, 0xff, 0x1e, 0x27, 0xae, 0xbb, 0x4d, 0x13, 0xd5, 0x14, 0x26, 0x88, 0xa1, 0x75,
0x0b, 0x75, 0x20, 0x70, 0xc3, 0x0c, 0xc3, 0x4c, 0xea, 0x86, 0xa4, 0x10, 0xd2, 0x19, 0xb9, 0x2d,
0x33, 0xcc, 0x30, 0x1e, 0xc5, 0x5e, 0xb7, 0xa2, 0xb2, 0xd6, 0x68, 0x57, 0xa1, 0x79, 0x04, 0x2e,
0x79, 0x07, 0xae, 0x79, 0x06, 0x6e, 0x79, 0x06, 0x5e, 0x86, 0xd9, 0x3f, 0x45, 0x2b, 0x4b, 0xae,
0xc8, 0x4d, 0xac, 0xdd, 0x73, 0xf6, 0xfc, 0x7c, 0xdf, 0x9e, 0xb3, 0x67, 0x02, 0xfd, 0xd7, 0xde,
0xd2, 0xdf, 0xa7, 0x38, 0xba, 0xf0, 0xa7, 0x98, 0xee, 0x33, 0x3f, 0x08, 0x70, 0x34, 0x5c, 0x46,
0x84, 0x11, 0xb4, 0xcd, 0x65, 0x43, 0x2d, 0x1b, 0x4a, 0x59, 0x7f, 0x47, 0x9c, 0x98, 0xbe, 0xf6,
0x22, 0x26, 0xff, 0x4a, 0xed, 0xfe, 0x6e, 0x7a, 0x9f, 0x84, 0x73, 0xff, 0x95, 0x12, 0x48, 0x17,
0x11, 0x0e, 0xb0, 0x47, 0xb1, 0xfe, 0x35, 0x0e, 0x69, 0x99, 0x1f, 0xce, 0x89, 0x12, 0xbc, 0x67,
0x08, 0x18, 0xa6, 0x6c, 0x12, 0xc5, 0xa1, 0x12, 0xde, 0x31, 0x84, 0x94, 0x79, 0x2c, 0xa6, 0x86,
0xb3, 0x0b, 0x1c, 0x51, 0x9f, 0x84, 0xfa, 0x57, 0xca, 0x9c, 0xbf, 0xab, 0x70, 0xeb, 0xd4, 0xa7,
0xcc, 0x95, 0x07, 0xa9, 0x8b, 0x7f, 0x8d, 0x31, 0x65, 0x68, 0x1b, 0xea, 0x81, 0xbf, 0xf0, 0x99,
0x5d, 0xd9, 0xab, 0x0c, 0x2c, 0x57, 0x2e, 0xd0, 0x0e, 0x34, 0xc8, 0x7c, 0x4e, 0x31, 0xb3, 0xab,
0x7b, 0x95, 0x41, 0xdb, 0x55, 0x2b, 0xf4, 0x0d, 0x34, 0x29, 0x89, 0xd8, 0xe4, 0xfc, 0xd2, 0xb6,
0xf6, 0x2a, 0x83, 0xee, 0xc1, 0xc7, 0xc3, 0x3c, 0x9c, 0x86, 0xdc, 0xd3, 0x98, 0x44, 0x6c, 0xc8,
0xff, 0x3c, 0xbe, 0x74, 0x1b, 0x54, 0xfc, 0x72, 0xbb, 0x73, 0x3f, 0x60, 0x38, 0xb2, 0x6b, 0xd2,
0xae, 0x5c, 0xa1, 0x63, 0x00, 0x61, 0x97, 0x44, 0x33, 0x1c, 0xd9, 0x75, 0x61, 0x7a, 0x50, 0xc2,
0xf4, 0x33, 0xae, 0xef, 0xb6, 0xa9, 0xfe, 0x44, 0x5f, 0xc3, 0xa6, 0x84, 0x64, 0x32, 0x25, 0x33,
0x4c, 0xed, 0xc6, 0x9e, 0x35, 0xe8, 0x1e, 0xdc, 0x91, 0xa6, 0x34, 0xfc, 0x63, 0x09, 0xda, 0x88,
0xcc, 0xb0, 0xdb, 0x91, 0xea, 0xfc, 0x9b, 0xa2, 0xbb, 0xd0, 0x0e, 0xbd, 0x05, 0xa6, 0x4b, 0x6f,
0x8a, 0xed, 0xa6, 0x88, 0xf0, 0x6a, 0xc3, 0x09, 0xa1, 0xa5, 0x9d, 0x3b, 0x8f, 0xa1, 0x21, 0x53,
0x43, 0x1d, 0x68, 0xbe, 0x38, 0xfb, 0xfe, 0xec, 0xd9, 0x8f, 0x67, 0xbd, 0x0d, 0xd4, 0x82, 0xda,
0xd9, 0xe1, 0x0f, 0x47, 0xbd, 0x0a, 0xba, 0x09, 0x5b, 0xa7, 0x87, 0xe3, 0xe7, 0x13, 0xf7, 0xe8,
0xf4, 0xe8, 0x70, 0x7c, 0xf4, 0xa4, 0x57, 0x45, 0x5d, 0x80, 0xd1, 0xc9, 0xa1, 0xfb, 0x7c, 0x22,
0x54, 0x2c, 0xe7, 0x03, 0x68, 0x27, 0x39, 0xa0, 0x26, 0x58, 0x87, 0xe3, 0x91, 0x34, 0xf1, 0xe4,
0x68, 0x3c, 0xea, 0x55, 0x9c, 0xdf, 0x2b, 0xb0, 0x6d, 0x52, 0x46, 0x97, 0x24, 0xa4, 0x98, 0x73,
0x36, 0x25, 0x71, 0x98, 0x70, 0x26, 0x16, 0x08, 0x41, 0x2d, 0xc4, 0x6f, 0x35, 0x63, 0xe2, 0x9b,
0x6b, 0x32, 0xc2, 0xbc, 0x40, 0xb0, 0x65, 0xb9, 0x72, 0x81, 0x3e, 0x87, 0x96, 0x82, 0x82, 0xda,
0xb5, 0x3d, 0x6b, 0xd0, 0x39, 0xb8, 0x6d, 0x02, 0xa4, 0x3c, 0xba, 0x89, 0x9a, 0x73, 0x0c, 0xbb,
0xc7, 0x58, 0x47, 0x22, 0xf1, 0xd3, 0x37, 0x88, 0xfb, 0xf5, 0x16, 0x58, 0x04, 0xc3, 0xfd, 0x7a,
0x0b, 0x8c, 0x6c, 0x68, 0xaa, 0xeb, 0x27, 0xc2, 0xa9, 0xbb, 0x7a, 0xe9, 0x30, 0xb0, 0x57, 0x0d,
0xa9, 0xbc, 0xf2, 0x2c, 0xdd, 0x83, 0x1a, 0xaf, 0x0c, 0x61, 0xa6, 0x73, 0x80, 0xcc, 0x38, 0x9f,
0x86, 0x73, 0xe2, 0x0a, 0xb9, 0x49, 0x9d, 0x95, 0xa5, 0xee, 0x24, 0xed, 0x75, 0x44, 0x42, 0x86,
0x43, 0x76, 0xbd, 0xf8, 0x4f, 0xe1, 0x4e, 0x8e, 0x25, 0x95, 0xc0, 0x3e, 0x34, 0x55, 0x68, 0xc2,
0x5a, 0x21, 0xae, 0x5a, 0xcb, 0xf9, 0xc7, 0x82, 0xed, 0x17, 0xcb, 0x99, 0xc7, 0xb0, 0x16, 0xad,
0x09, 0xea, 0x3e, 0xd4, 0x45, 0x87, 0x51, 0x58, 0xdc, 0x94, 0xb6, 0x65, 0x1b, 0x1a, 0xf1, 0xbf,
0xae, 0x94, 0xa3, 0x87, 0xd0, 0xb8, 0xf0, 0x82, 0x18, 0x53, 0x01, 0x44, 0x82, 0x9a, 0xd2, 0x14,
0xed, 0xc9, 0x55, 0x1a, 0x68, 0x17, 0x9a, 0xb3, 0xe8, 0x92, 0xf7, 0x17, 0x51, 0x92, 0x2d, 0xb7,
0x31, 0x8b, 0x2e, 0xdd, 0x38, 0x44, 0x1f, 0xc1, 0xd6, 0xcc, 0xa7, 0xde, 0x79, 0x80, 0x27, 0xaf,
0x09, 0x79, 0x43, 0x45, 0x55, 0xb6, 0xdc, 0x4d, 0xb5, 0x79, 0xc2, 0xf7, 0x50, 0x9f, 0xdf, 0xa4,
0x69, 0x84, 0x3d, 0x86, 0xed, 0x86, 0x90, 0x27, 0x6b, 0x8e, 0x21, 0xf3, 0x17, 0x98, 0xc4, 0x4c,
0x94, 0x92, 0xe5, 0xea, 0x25, 0xfa, 0x10, 0x36, 0x23, 0x4c, 0x31, 0x9b, 0xa8, 0x28, 0x5b, 0xe2,
0x64, 0x47, 0xec, 0xbd, 0x94, 0x61, 0x21, 0xa8, 0xfd, 0xe6, 0xf9, 0xcc, 0x6e, 0x0b, 0x91, 0xf8,
0x96, 0xc7, 0x62, 0x8a, 0xf5, 0x31, 0xd0, 0xc7, 0x62, 0x8a, 0xd5, 0xb1, 0x6d, 0xa8, 0xcf, 0x49,
0x34, 0xc5, 0x76, 0x47, 0xc8, 0xe4, 0x02, 0xed, 0x41, 0x67, 0x86, 0xe9, 0x34, 0xf2, 0x97, 0x8c,
0x33, 0xba, 0x29, 0x30, 0x4d, 0x6f, 0xf1, 0x3c, 0x68, 0x7c, 0x7e, 0x46, 0x18, 0xa6, 0xf6, 0x96,
0xcc, 0x43, 0xaf, 0xd1, 0x3d, 0xb8, 0x31, 0x0d, 0xb0, 0x17, 0xc6, 0xcb, 0x09, 0x09, 0x27, 0x73,
0xcf, 0x0f, 0xec, 0xae, 0x50, 0xd9, 0x52, 0xdb, 0xcf, 0xc2, 0x6f, 0x3d, 0x3f, 0x70, 0x4e, 0xe0,
0x76, 0x86, 0xca, 0xeb, 0xde, 0x8a, 0xbf, 0xaa, 0xb0, 0xe3, 0x92, 0x20, 0x38, 0xf7, 0xa6, 0x6f,
0x4a, 0xdc, 0x8b, 0x14, 0x85, 0xd5, 0xf5, 0x14, 0x5a, 0x39, 0x14, 0xa6, 0xae, 0x7a, 0xcd, 0xb8,
0xea, 0x06, 0xb9, 0xf5, 0x62, 0x72, 0x1b, 0x26, 0xb9, 0x9a, 0xb9, 0x66, 0x8a, 0xb9, 0x84, 0x96,
0xd6, 0x1a, 0x5a, 0xda, 0xab, 0xb4, 0xe4, 0x40, 0x0f, 0x79, 0xd0, 0x7f, 0x07, 0xbb, 0x2b, 0x78,
0x5d, 0x17, 0xfc, 0x3f, 0x2c, 0xb8, 0xfd, 0x34, 0xa4, 0xcc, 0x0b, 0x82, 0x0c, 0xf6, 0x49, 0xfd,
0x55, 0x4a, 0xd7, 0x5f, 0xf5, 0xff, 0xd4, 0x9f, 0x65, 0x90, 0xa7, 0x99, 0xae, 0xa5, 0x98, 0x2e,
0x55, 0x93, 0x46, 0x27, 0x6c, 0x64, 0x3a, 0x21, 0x7a, 0x1f, 0x40, 0x16, 0x91, 0x30, 0x2e, 0x49,
0x6a, 0x8b, 0x9d, 0x33, 0xd5, 0xf8, 0x34, 0xaf, 0xad, 0x7c, 0x5e, 0xd3, 0x15, 0x39, 0x80, 0x9e,
0x8e, 0x67, 0x1a, 0xcd, 0x44, 0x4c, 0x8a, 0xa0, 0xae, 0xda, 0x1f, 0x45, 0x33, 0x1e, 0x55, 0x96,
0xeb, 0xce, 0xfa, 0x12, 0xdc, 0x34, 0x4b, 0xd0, 0x79, 0x0a, 0x3b, 0x59, 0x4a, 0xae, 0x4b, 0xef,
0x9f, 0x15, 0xd8, 0x7d, 0x11, 0xfa, 0xb9, 0x04, 0xe7, 0x15, 0xd7, 0x0a, 0xe4, 0xd5, 0x1c, 0xc8,
0xb7, 0xa1, 0xbe, 0x8c, 0xa3, 0x57, 0x58, 0x51, 0x28, 0x17, 0x69, 0x2c, 0x6b, 0x26, 0x96, 0x19,
0x34, 0xea, 0x2b, 0x68, 0x38, 0x13, 0xb0, 0x57, 0xa3, 0xbc, 0x66, 0xce, 0x3c, 0xaf, 0xe4, 0x0d,
0x6d, 0xcb, 0xf7, 0xd2, 0xb9, 0x05, 0x37, 0x8f, 0x31, 0x7b, 0x29, 0x4b, 0x5d, 0x01, 0xe0, 0x1c,
0x01, 0x4a, 0x6f, 0x5e, 0xf9, 0x53, 0x5b, 0xa6, 0x3f, 0x3d, 0x60, 0x6a, 0x7d, 0xad, 0xe5, 0x7c,
0x25, 0x6c, 0x9f, 0xf8, 0x94, 0x91, 0xe8, 0x72, 0x1d, 0xb8, 0x3d, 0xb0, 0x16, 0xde, 0x5b, 0xf5,
0xc4, 0xf2, 0x4f, 0xe7, 0x58, 0x44, 0x90, 0x1c, 0x55, 0x11, 0xa4, 0x07, 0x96, 0x4a, 0xb9, 0x81,
0xe5, 0x2d, 0xa0, 0xe7, 0x38, 0x99, 0x9d, 0xde, 0xf1, 0xd6, 0x6b, 0x9a, 0xaa, 0x26, 0x4d, 0x36,
0x34, 0x55, 0x9f, 0x51, 0xc4, 0xea, 0x25, 0xbf, 0xac, 0x4b, 0x2f, 0xf2, 0x82, 0x00, 0x07, 0xea,
0xd9, 0x4c, 0xd6, 0xce, 0xcf, 0x70, 0xcb, 0xf0, 0xac, 0x72, 0xe0, 0xb9, 0xd2, 0x57, 0xca, 0x33,
0xff, 0x44, 0x5f, 0x42, 0x43, 0x0e, 0x9f, 0xc2, 0x6f, 0xf7, 0xe0, 0xae, 0x99, 0x93, 0x30, 0x12,
0x87, 0x6a, 0x5a, 0x75, 0x95, 0xee, 0xc1, 0xbf, 0x2d, 0xe8, 0xea, 0xf1, 0x49, 0x8e, 0xc6, 0xc8,
0x87, 0xcd, 0xf4, 0x9c, 0x88, 0x1e, 0x14, 0x4f, 0xce, 0x99, 0xf1, 0xbf, 0xff, 0xb0, 0x8c, 0xaa,
0xcc, 0xc0, 0xd9, 0xf8, 0xac, 0x82, 0x28, 0xf4, 0xb2, 0xe3, 0x1b, 0x7a, 0x94, 0x6f, 0xa3, 0x60,
0x5e, 0xec, 0x0f, 0xcb, 0xaa, 0x6b, 0xb7, 0xe8, 0x42, 0xdc, 0x27, 0x73, 0xe6, 0x42, 0xef, 0x34,
0x63, 0x8e, 0x79, 0xfd, 0xfd, 0xd2, 0xfa, 0x89, 0xdf, 0x5f, 0x60, 0xcb, 0x78, 0xd1, 0x51, 0x01,
0x5a, 0x79, 0x13, 0x5c, 0xff, 0x93, 0x52, 0xba, 0x89, 0xaf, 0x05, 0x74, 0xcd, 0x16, 0x87, 0x0a,
0x0c, 0xe4, 0xbe, 0x4d, 0xfd, 0x4f, 0xcb, 0x29, 0x27, 0xee, 0x28, 0xf4, 0xb2, 0xfd, 0xa5, 0x88,
0xc7, 0x82, 0x6e, 0x59, 0xc4, 0x63, 0x51, 0xdb, 0x72, 0x36, 0x90, 0x07, 0x70, 0xd5, 0x5e, 0xd0,
0xfd, 0x42, 0x42, 0xcc, 0xae, 0xd4, 0x1f, 0xbc, 0x5b, 0x31, 0x71, 0xb1, 0x84, 0x1b, 0x99, 0x49,
0x00, 0x15, 0x40, 0x93, 0x3f, 0x60, 0xf5, 0x1f, 0x95, 0xd4, 0xce, 0x24, 0xa5, 0x3a, 0xd6, 0x9a,
0xa4, 0xcc, 0x76, 0xb8, 0x26, 0xa9, 0x4c, 0xf3, 0x73, 0x36, 0x90, 0x0f, 0x5d, 0x37, 0x0e, 0x95,
0x6b, 0xde, 0x16, 0x50, 0xc1, 0xe9, 0xd5, 0x8e, 0xd7, 0x7f, 0x50, 0x42, 0xf3, 0xaa, 0xbe, 0x1f,
0xc3, 0x4f, 0x2d, 0xad, 0x7a, 0xde, 0x10, 0xff, 0x39, 0xf8, 0xe2, 0xbf, 0x00, 0x00, 0x00, 0xff,
0xff, 0x20, 0xcd, 0x9e, 0x3a, 0x27, 0x11, 0x00, 0x00,
func init() { proto.RegisterFile("hapi/services/tiller.proto", fileDescriptor_tiller_4fda016196f30239) }
var fileDescriptor_tiller_4fda016196f30239 = []byte{
// 1349 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0xdd, 0x72, 0xdb, 0xc4,
0x17, 0x8f, 0x2d, 0x7f, 0x1e, 0x27, 0xae, 0xbb, 0x4d, 0x13, 0xd5, 0xff, 0xfe, 0x99, 0x20, 0x86,
0xd6, 0x2d, 0xd4, 0x81, 0xc0, 0x0d, 0x33, 0x0c, 0x33, 0xa9, 0x1b, 0x92, 0x42, 0x48, 0x67, 0x94,
0xb6, 0xcc, 0x30, 0xc3, 0x78, 0x14, 0x7b, 0x9d, 0x8a, 0xca, 0x5a, 0xa3, 0x5d, 0x85, 0xe6, 0x11,
0x98, 0xe1, 0x86, 0x77, 0xe0, 0x9a, 0x67, 0xe0, 0x96, 0x67, 0xe0, 0x65, 0x98, 0xfd, 0x52, 0xb4,
0xb2, 0xe4, 0x88, 0xdc, 0x58, 0xda, 0x3d, 0x67, 0xcf, 0xc7, 0xef, 0xb7, 0xe7, 0xe8, 0x24, 0xd0,
0x7f, 0xe3, 0x2d, 0xfc, 0x5d, 0x8a, 0xa3, 0x0b, 0x7f, 0x82, 0xe9, 0x2e, 0xf3, 0x83, 0x00, 0x47,
0xc3, 0x45, 0x44, 0x18, 0x41, 0x9b, 0x5c, 0x36, 0xd4, 0xb2, 0xa1, 0x94, 0xf5, 0xb7, 0xc4, 0x89,
0xc9, 0x1b, 0x2f, 0x62, 0xf2, 0x57, 0x6a, 0xf7, 0xb7, 0xd3, 0xfb, 0x24, 0x9c, 0xf9, 0xe7, 0x4a,
0x20, 0x5d, 0x44, 0x38, 0xc0, 0x1e, 0xc5, 0xfa, 0x69, 0x1c, 0xd2, 0x32, 0x3f, 0x9c, 0x11, 0x25,
0xf8, 0x9f, 0x21, 0x60, 0x98, 0xb2, 0x71, 0x14, 0x87, 0x4a, 0x78, 0xcf, 0x10, 0x52, 0xe6, 0xb1,
0x98, 0x1a, 0xce, 0x2e, 0x70, 0x44, 0x7d, 0x12, 0xea, 0xa7, 0x94, 0x39, 0x7f, 0x55, 0xe1, 0xce,
0xb1, 0x4f, 0x99, 0x2b, 0x0f, 0x52, 0x17, 0xff, 0x1c, 0x63, 0xca, 0xd0, 0x26, 0xd4, 0x03, 0x7f,
0xee, 0x33, 0xbb, 0xb2, 0x53, 0x19, 0x58, 0xae, 0x5c, 0xa0, 0x2d, 0x68, 0x90, 0xd9, 0x8c, 0x62,
0x66, 0x57, 0x77, 0x2a, 0x83, 0xb6, 0xab, 0x56, 0xe8, 0x2b, 0x68, 0x52, 0x12, 0xb1, 0xf1, 0xd9,
0xa5, 0x6d, 0xed, 0x54, 0x06, 0xdd, 0xbd, 0x0f, 0x87, 0x79, 0x38, 0x0d, 0xb9, 0xa7, 0x53, 0x12,
0xb1, 0x21, 0xff, 0x79, 0x7a, 0xe9, 0x36, 0xa8, 0x78, 0x72, 0xbb, 0x33, 0x3f, 0x60, 0x38, 0xb2,
0x6b, 0xd2, 0xae, 0x5c, 0xa1, 0x43, 0x00, 0x61, 0x97, 0x44, 0x53, 0x1c, 0xd9, 0x75, 0x61, 0x7a,
0x50, 0xc2, 0xf4, 0x0b, 0xae, 0xef, 0xb6, 0xa9, 0x7e, 0x45, 0x5f, 0xc2, 0xba, 0x84, 0x64, 0x3c,
0x21, 0x53, 0x4c, 0xed, 0xc6, 0x8e, 0x35, 0xe8, 0xee, 0xdd, 0x93, 0xa6, 0x34, 0xfc, 0xa7, 0x12,
0xb4, 0x11, 0x99, 0x62, 0xb7, 0x23, 0xd5, 0xf9, 0x3b, 0x45, 0xf7, 0xa1, 0x1d, 0x7a, 0x73, 0x4c,
0x17, 0xde, 0x04, 0xdb, 0x4d, 0x11, 0xe1, 0xd5, 0x86, 0x13, 0x42, 0x4b, 0x3b, 0x77, 0x9e, 0x42,
0x43, 0xa6, 0x86, 0x3a, 0xd0, 0x7c, 0x75, 0xf2, 0xed, 0xc9, 0x8b, 0xef, 0x4f, 0x7a, 0x6b, 0xa8,
0x05, 0xb5, 0x93, 0xfd, 0xef, 0x0e, 0x7a, 0x15, 0x74, 0x1b, 0x36, 0x8e, 0xf7, 0x4f, 0x5f, 0x8e,
0xdd, 0x83, 0xe3, 0x83, 0xfd, 0xd3, 0x83, 0x67, 0xbd, 0x2a, 0xea, 0x02, 0x8c, 0x8e, 0xf6, 0xdd,
0x97, 0x63, 0xa1, 0x62, 0x39, 0xef, 0x41, 0x3b, 0xc9, 0x01, 0x35, 0xc1, 0xda, 0x3f, 0x1d, 0x49,
0x13, 0xcf, 0x0e, 0x4e, 0x47, 0xbd, 0x8a, 0xf3, 0x6b, 0x05, 0x36, 0x4d, 0xca, 0xe8, 0x82, 0x84,
0x14, 0x73, 0xce, 0x26, 0x24, 0x0e, 0x13, 0xce, 0xc4, 0x02, 0x21, 0xa8, 0x85, 0xf8, 0x9d, 0x66,
0x4c, 0xbc, 0x73, 0x4d, 0x46, 0x98, 0x17, 0x08, 0xb6, 0x2c, 0x57, 0x2e, 0xd0, 0xa7, 0xd0, 0x52,
0x50, 0x50, 0xbb, 0xb6, 0x63, 0x0d, 0x3a, 0x7b, 0x77, 0x4d, 0x80, 0x94, 0x47, 0x37, 0x51, 0x73,
0x0e, 0x61, 0xfb, 0x10, 0xeb, 0x48, 0x24, 0x7e, 0xfa, 0x06, 0x71, 0xbf, 0xde, 0x1c, 0x8b, 0x60,
0xb8, 0x5f, 0x6f, 0x8e, 0x91, 0x0d, 0x4d, 0x75, 0xfd, 0x44, 0x38, 0x75, 0x57, 0x2f, 0x1d, 0x06,
0xf6, 0xb2, 0x21, 0x95, 0x57, 0x9e, 0xa5, 0x07, 0x50, 0xe3, 0x95, 0x21, 0xcc, 0x74, 0xf6, 0x90,
0x19, 0xe7, 0xf3, 0x70, 0x46, 0x5c, 0x21, 0x37, 0xa9, 0xb3, 0xb2, 0xd4, 0x1d, 0xa5, 0xbd, 0x8e,
0x48, 0xc8, 0x70, 0xc8, 0x6e, 0x16, 0xff, 0x31, 0xdc, 0xcb, 0xb1, 0xa4, 0x12, 0xd8, 0x85, 0xa6,
0x0a, 0x4d, 0x58, 0x2b, 0xc4, 0x55, 0x6b, 0x39, 0x7f, 0x5b, 0xb0, 0xf9, 0x6a, 0x31, 0xf5, 0x18,
0xd6, 0xa2, 0x15, 0x41, 0x3d, 0x84, 0xba, 0xe8, 0x30, 0x0a, 0x8b, 0xdb, 0xd2, 0xb6, 0x6c, 0x43,
0x23, 0xfe, 0xeb, 0x4a, 0x39, 0x7a, 0x0c, 0x8d, 0x0b, 0x2f, 0x88, 0x31, 0x15, 0x40, 0x24, 0xa8,
0x29, 0x4d, 0xd1, 0x9e, 0x5c, 0xa5, 0x81, 0xb6, 0xa1, 0x39, 0x8d, 0x2e, 0x79, 0x7f, 0x11, 0x25,
0xd9, 0x72, 0x1b, 0xd3, 0xe8, 0xd2, 0x8d, 0x43, 0xf4, 0x01, 0x6c, 0x4c, 0x7d, 0xea, 0x9d, 0x05,
0x78, 0xfc, 0x86, 0x90, 0xb7, 0x54, 0x54, 0x65, 0xcb, 0x5d, 0x57, 0x9b, 0x47, 0x7c, 0x0f, 0xf5,
0xf9, 0x4d, 0x9a, 0x44, 0xd8, 0x63, 0xd8, 0x6e, 0x08, 0x79, 0xb2, 0xe6, 0x18, 0x32, 0x7f, 0x8e,
0x49, 0xcc, 0x44, 0x29, 0x59, 0xae, 0x5e, 0xa2, 0xf7, 0x61, 0x3d, 0xc2, 0x14, 0xb3, 0xb1, 0x8a,
0xb2, 0x25, 0x4e, 0x76, 0xc4, 0xde, 0x6b, 0x19, 0x16, 0x82, 0xda, 0x2f, 0x9e, 0xcf, 0xec, 0xb6,
0x10, 0x89, 0x77, 0x79, 0x2c, 0xa6, 0x58, 0x1f, 0x03, 0x7d, 0x2c, 0xa6, 0x58, 0x1d, 0xdb, 0x84,
0xfa, 0x8c, 0x44, 0x13, 0x6c, 0x77, 0x84, 0x4c, 0x2e, 0xd0, 0x0e, 0x74, 0xa6, 0x98, 0x4e, 0x22,
0x7f, 0xc1, 0x38, 0xa3, 0xeb, 0x02, 0xd3, 0xf4, 0x16, 0xcf, 0x83, 0xc6, 0x67, 0x27, 0x84, 0x61,
0x6a, 0x6f, 0xc8, 0x3c, 0xf4, 0x1a, 0x3d, 0x80, 0x5b, 0x93, 0x00, 0x7b, 0x61, 0xbc, 0x18, 0x93,
0x70, 0x3c, 0xf3, 0xfc, 0xc0, 0xee, 0x0a, 0x95, 0x0d, 0xb5, 0xfd, 0x22, 0xfc, 0xda, 0xf3, 0x03,
0xe7, 0x08, 0xee, 0x66, 0xa8, 0xbc, 0xe9, 0xad, 0xf8, 0xb3, 0x0a, 0x5b, 0x2e, 0x09, 0x82, 0x33,
0x6f, 0xf2, 0xb6, 0xc4, 0xbd, 0x48, 0x51, 0x58, 0x5d, 0x4d, 0xa1, 0x95, 0x43, 0x61, 0xea, 0xaa,
0xd7, 0x8c, 0xab, 0x6e, 0x90, 0x5b, 0x2f, 0x26, 0xb7, 0x61, 0x92, 0xab, 0x99, 0x6b, 0xa6, 0x98,
0x4b, 0x68, 0x69, 0xad, 0xa0, 0xa5, 0xbd, 0x4c, 0x4b, 0x0e, 0xf4, 0x90, 0x07, 0xfd, 0x37, 0xb0,
0xbd, 0x84, 0xd7, 0x4d, 0xc1, 0xff, 0xdd, 0x82, 0xbb, 0xcf, 0x43, 0xca, 0xbc, 0x20, 0xc8, 0x60,
0x9f, 0xd4, 0x5f, 0xa5, 0x74, 0xfd, 0x55, 0xff, 0x4b, 0xfd, 0x59, 0x06, 0x79, 0x9a, 0xe9, 0x5a,
0x8a, 0xe9, 0x52, 0x35, 0x69, 0x74, 0xc2, 0x46, 0xa6, 0x13, 0xa2, 0xff, 0x03, 0xc8, 0x22, 0x12,
0xc6, 0x25, 0x49, 0x6d, 0xb1, 0x73, 0xa2, 0x1a, 0x9f, 0xe6, 0xb5, 0x95, 0xcf, 0x6b, 0xba, 0x22,
0x07, 0xd0, 0xd3, 0xf1, 0x4c, 0xa2, 0xa9, 0x88, 0x49, 0x11, 0xd4, 0x55, 0xfb, 0xa3, 0x68, 0xca,
0xa3, 0xca, 0x72, 0xdd, 0x59, 0x5d, 0x82, 0xeb, 0x66, 0x09, 0x3a, 0xcf, 0x61, 0x2b, 0x4b, 0xc9,
0x4d, 0xe9, 0xfd, 0xa3, 0x02, 0xdb, 0xaf, 0x42, 0x3f, 0x97, 0xe0, 0xbc, 0xe2, 0x5a, 0x82, 0xbc,
0x9a, 0x03, 0xf9, 0x26, 0xd4, 0x17, 0x71, 0x74, 0x8e, 0x15, 0x85, 0x72, 0x91, 0xc6, 0xb2, 0x66,
0x62, 0x99, 0x41, 0xa3, 0xbe, 0x84, 0x86, 0x33, 0x06, 0x7b, 0x39, 0xca, 0x1b, 0xe6, 0xcc, 0xf3,
0x4a, 0xbe, 0xa1, 0x6d, 0xf9, 0xbd, 0x74, 0xee, 0xc0, 0xed, 0x43, 0xcc, 0x5e, 0xcb, 0x52, 0x57,
0x00, 0x38, 0x07, 0x80, 0xd2, 0x9b, 0x57, 0xfe, 0xd4, 0x96, 0xe9, 0x4f, 0x0f, 0x98, 0x5a, 0x5f,
0x6b, 0x39, 0x5f, 0x08, 0xdb, 0x47, 0x3e, 0x65, 0x24, 0xba, 0x5c, 0x05, 0x6e, 0x0f, 0xac, 0xb9,
0xf7, 0x4e, 0x7d, 0x62, 0xf9, 0xab, 0x73, 0x28, 0x22, 0x48, 0x8e, 0xaa, 0x08, 0xd2, 0x03, 0x4b,
0xa5, 0xdc, 0xc0, 0xf2, 0x5b, 0x05, 0xd0, 0x4b, 0x9c, 0x0c, 0x4f, 0xd7, 0x7c, 0xec, 0x35, 0x4f,
0x55, 0x93, 0x27, 0x1b, 0x9a, 0xaa, 0xd1, 0x28, 0x66, 0xf5, 0x92, 0xdf, 0xd6, 0x85, 0x17, 0x79,
0x41, 0x80, 0x03, 0xf5, 0xdd, 0x4c, 0xd6, 0xdc, 0x47, 0x40, 0xce, 0x75, 0x71, 0x8a, 0x77, 0xe7,
0x47, 0xb8, 0x63, 0x44, 0xa3, 0x12, 0xe3, 0x00, 0xd0, 0x73, 0x15, 0x0d, 0x7f, 0x45, 0x9f, 0x43,
0x43, 0x4e, 0xa4, 0x22, 0x96, 0xee, 0xde, 0x7d, 0x33, 0x51, 0x61, 0x24, 0x0e, 0xd5, 0x08, 0xeb,
0x2a, 0xdd, 0xbd, 0x7f, 0x5a, 0xd0, 0xd5, 0x33, 0x95, 0x9c, 0x97, 0x91, 0x0f, 0xeb, 0xe9, 0xe1,
0x11, 0x3d, 0x2a, 0x1e, 0xa7, 0x33, 0x7f, 0x13, 0xf4, 0x1f, 0x97, 0x51, 0x95, 0x19, 0x38, 0x6b,
0x9f, 0x54, 0x10, 0x85, 0x5e, 0x76, 0xa6, 0x43, 0x4f, 0xf2, 0x6d, 0x14, 0x0c, 0x91, 0xfd, 0x61,
0x59, 0x75, 0xed, 0x16, 0x5d, 0x88, 0x4b, 0x66, 0x0e, 0x62, 0xe8, 0x5a, 0x33, 0xe6, 0xec, 0xd7,
0xdf, 0x2d, 0xad, 0x9f, 0xf8, 0xfd, 0x09, 0x36, 0x8c, 0xcf, 0x3c, 0x2a, 0x40, 0x2b, 0x6f, 0xac,
0xeb, 0x7f, 0x54, 0x4a, 0x37, 0xf1, 0x35, 0x87, 0xae, 0xd9, 0xf7, 0x50, 0x81, 0x81, 0xdc, 0x0f,
0x56, 0xff, 0xe3, 0x72, 0xca, 0x89, 0x3b, 0x0a, 0xbd, 0x6c, 0xd3, 0x29, 0xe2, 0xb1, 0xa0, 0x85,
0x16, 0xf1, 0x58, 0xd4, 0xcb, 0x9c, 0x35, 0xe4, 0x01, 0x5c, 0xf5, 0x1c, 0xf4, 0xb0, 0x90, 0x10,
0xb3, 0x55, 0xf5, 0x07, 0xd7, 0x2b, 0x26, 0x2e, 0x16, 0x70, 0x2b, 0x33, 0x1e, 0xa0, 0x02, 0x68,
0xf2, 0xa7, 0xae, 0xfe, 0x93, 0x92, 0xda, 0x99, 0xa4, 0x54, 0x1b, 0x5b, 0x91, 0x94, 0xd9, 0x23,
0x57, 0x24, 0x95, 0xe9, 0x88, 0xce, 0x1a, 0xf2, 0xa1, 0xeb, 0xc6, 0xa1, 0x72, 0xcd, 0xdb, 0x02,
0x2a, 0x38, 0xbd, 0xdc, 0x05, 0xfb, 0x8f, 0x4a, 0x68, 0x5e, 0xd5, 0xf7, 0x53, 0xf8, 0xa1, 0xa5,
0x55, 0xcf, 0x1a, 0xe2, 0xdf, 0x09, 0x9f, 0xfd, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x70, 0x3d, 0x1f,
0x9d, 0x3c, 0x11, 0x00, 0x00,
}

20
pkg/releasetesting/environment.go
Unescape View File

@ -96,7 +96,7 @@ func (env *Environment) streamError(info string) error {
}
func (env *Environment) streamFailed(name string) error {
msg := fmt.Sprintf("FAILED: %s, run `kubectl logs %s --namespace %s` for more info", name, name, env.Namespace)
msg := "FAILED: " + name
return env.streamMessage(msg, release.TestRun_FAILURE)
}
@ -126,3 +126,21 @@ func (env *Environment) DeleteTestPods(testManifests []string) {
}
}
}
func (env *Environment) GetLogs(testManifests []string) {
for _, testManifest := range testManifests {
infos, err := env.KubeClient.Build(env.Namespace, bytes.NewBufferString(testManifest))
if err != nil {
env.streamError(err.Error())
continue
}
podName := infos[0].Object.(*v1.Pod).Name
logs, err := env.KubeClient.GetPodLogs(podName, env.Namespace)
if err != nil {
env.streamError(err.Error())
continue
}
msg := fmt.Sprintf("\nPOD LOGS: %s\n%s", podName, logs)
env.streamMessage(msg, release.TestRun_UNKNOWN)
}
}

7
pkg/tiller/environment/environment.go
Unescape View File

@ -175,6 +175,8 @@ type KubeClient interface {
// and returns said phase (PodSucceeded or PodFailed qualify).
WaitAndGetCompletedPodPhase(namespace string, reader io.Reader, timeout time.Duration) (v1.PodPhase, error)
GetPodLogs(name, namespace string) (string, error)
WaitUntilCRDEstablished(reader io.Reader, timeout time.Duration) error
}
@ -255,6 +257,11 @@ func (p *PrintingKubeClient) WaitAndGetCompletedPodPhase(namespace string, reade
return v1.PodUnknown, err
}
// GetPodLogs implements KubeClient GetPodLogs.
func (p *PrintingKubeClient) GetPodLogs(name, ns string) (string, error) {
return "", nil
}
// WaitUntilCRDEstablished implements KubeClient WaitUntilCRDEstablished.
func (p *PrintingKubeClient) WaitUntilCRDEstablished(reader io.Reader, timeout time.Duration) error {
_, err := io.Copy(p.Out, reader)

4
pkg/tiller/release_testing.go
Unescape View File

@ -64,6 +64,10 @@ func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream
Results: tSuite.Results,
}
if req.Logs {
testEnv.GetLogs(tSuite.TestManifests)
}
if req.Cleanup {
testEnv.DeleteTestPods(tSuite.TestManifests)
}

Write Preview
Loading…
Cancel
Save