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

Made changes to protobuf, edited client to stream logs

Browse Source
pull/2342/head
John Welsh 9 years ago
parent 5af676cda1
commit 03e00ec645
16 changed files with 294 additions and 118 deletions
Show Stats Download Patch File Download Diff File

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

@ -55,6 +55,10 @@ service ReleaseService {
rpc GetReleaseContent(GetReleaseContentRequest) returns (GetReleaseContentResponse) {
}
// GetReleaseLogs returns a stream of logging information from the release
rpc GetReleaseLogs(GetReleaseLogsRequest) returns (stream GetReleaseLogsResponse) {
}
// UpdateRelease updates release content.
rpc UpdateRelease(UpdateReleaseRequest) returns (UpdateReleaseResponse) {
}
@ -182,6 +186,20 @@ message GetReleaseContentResponse {
hapi.release.Release release = 1;
}
message GetReleaseLogsRequest {
// Name is the name of the release
string name = 1;
// Version is the version of the release
int32 version = 2;
}
message GetReleaseLogsResponse {
// Source is the name of the release that generated the log
string source = 1;
// Log is a single log line
string log = 2;
}
// UpdateReleaseRequest updates a release.
message UpdateReleaseRequest {
// The name of the release

19
cmd/helm/install.go
Unescape View File

@ -177,6 +177,23 @@ func newInstallCmd(c helm.Interface, out io.Writer) *cobra.Command {
return cmd
}
func streamLogs(client helm.Interface, rlsName string, done <-chan struct{}) error {
logs, err := client.ReleaseLogs(rlsName, done)
if err != nil {
return err
}
go func() {
select {
case log := <-logs:
fmt.Println(log.Log)
case <-done:
return
}
}()
return nil
}
func (i *installCmd) run() error {
if settings.FlagDebug {
fmt.Fprintf(i.out, "CHART PATH: %s\n", i.chartPath)
@ -211,6 +228,8 @@ func (i *installCmd) run() error {
checkDependencies(chartRequested, req, i.out)
}
done := make(chan struct{})
streamLogs(i.client, i.name, done)
res, err := i.client.InstallReleaseFromChart(
chartRequested,
i.namespace,

45
pkg/helm/client.go
Unescape View File

@ -27,6 +27,7 @@ import (
"k8s.io/helm/pkg/chartutil"
"k8s.io/helm/pkg/proto/hapi/chart"
rls "k8s.io/helm/pkg/proto/hapi/services"
"fmt"
)
// Client manages client side of the helm-tiller protocol
@ -215,6 +216,14 @@ func (h *Client) RollbackRelease(rlsName string, opts ...RollbackOption) (*rls.R
return h.rollback(ctx, req)
}
// ReleaseLogs returns a channel streaming log data from the release
func (h *Client) ReleaseLogs(rlsName string, done <-chan struct{}) (<-chan *rls.GetReleaseLogsResponse, error) {
ctx := NewContext()
req := &rls.GetReleaseLogsRequest{Name: rlsName}
return h.logs(ctx, req, done)
}
// ReleaseStatus returns the given release's status.
func (h *Client) ReleaseStatus(rlsName string, opts ...StatusOption) (*rls.GetReleaseStatusResponse, error) {
for _, opt := range opts {
@ -376,6 +385,42 @@ func (h *Client) status(ctx context.Context, req *rls.GetReleaseStatusRequest) (
return rlc.GetReleaseStatus(ctx, req)
}
// Executes tiller.GetReleaseLogs RPC.
func (h *Client) logs(ctx context.Context, req *rls.GetReleaseLogsRequest, done <-chan struct{}) (<-chan *rls.GetReleaseLogsResponse, error) {
c, err := h.connect(ctx)
if err != nil {
return nil, err
}
rlc := rls.NewReleaseServiceClient(c)
s, err := rlc.GetReleaseLogs(ctx, req)
if err != nil {
return nil, err
}
out := make(chan *rls.GetReleaseLogsResponse)
go func() {
defer close(out)
defer c.Close()
select {
case rs := s.Recv():
if err == io.EOF {
return
}
if err != nil {
fmt.Println("gRPC error streaming logs: ", grpc.ErrorDesc(err))
return
}
out <- rs
case <-done:
return
}
}()
return out, nil
}
// Executes tiller.GetReleaseContent RPC.
func (h *Client) content(ctx context.Context, req *rls.GetReleaseContentRequest) (*rls.GetReleaseContentResponse, error) {
c, err := h.connect(ctx)

1
pkg/helm/interface.go
Unescape View File

@ -28,6 +28,7 @@ type Interface interface {
InstallReleaseFromChart(chart *chart.Chart, namespace string, opts ...InstallOption) (*rls.InstallReleaseResponse, error)
DeleteRelease(rlsName string, opts ...DeleteOption) (*rls.UninstallReleaseResponse, error)
ReleaseStatus(rlsName string, opts ...StatusOption) (*rls.GetReleaseStatusResponse, error)
ReleaseLogs(rlsName string, done <-chan struct{}) (<-chan *rls.GetReleaseLogsResponse, error)
UpdateRelease(rlsName, chStr string, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error)
UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error)
RollbackRelease(rlsName string, opts ...RollbackOption) (*rls.RollbackReleaseResponse, error)

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

@ -101,7 +101,7 @@ func init() { proto.RegisterFile("hapi/chart/chart.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 242 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0xc3, 0x30,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0xc3, 0x30,
0x10, 0x86, 0x15, 0x4a, 0x0a, 0x1c, 0x2c, 0x58, 0x08, 0x4c, 0xa7, 0x8a, 0x09, 0x75, 0x70, 0x50,
0x11, 0x0f, 0x00, 0xcc, 0x2c, 0x16, 0x13, 0xdb, 0xb5, 0xb9, 0xa4, 0x91, 0x52, 0x3b, 0xaa, 0x5d,
0xa4, 0xbe, 0x3b, 0x03, 0xea, 0xd9, 0xa6, 0x09, 0xea, 0x12, 0x29, 0xf7, 0x7d, 0xff, 0xe5, 0xbf,

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

@ -50,7 +50,7 @@ func init() { proto.RegisterFile("hapi/chart/config.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 182 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0xc8,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0xc8,
0xd4, 0x4f, 0xce, 0x48, 0x2c, 0x2a, 0xd1, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2b, 0x28,
0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x02, 0x49, 0xe8, 0x81, 0x25, 0x94, 0x16, 0x30, 0x72, 0xb1, 0x39,
0x83, 0x25, 0x85, 0x04, 0xb8, 0x98, 0x8b, 0x12, 0xcb, 0x25, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83,

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

@ -106,7 +106,7 @@ func init() { proto.RegisterFile("hapi/chart/metadata.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 354 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x92, 0x5f, 0x4b, 0xe3, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x5f, 0x4b, 0xe3, 0x40,
0x14, 0xc5, 0x37, 0x9b, 0xe6, 0xdf, 0xcd, 0x76, 0xb7, 0x0c, 0x4b, 0x99, 0x5d, 0x44, 0x42, 0xf1,
0x21, 0x4f, 0x29, 0x28, 0x88, 0xcf, 0x82, 0xf8, 0xa0, 0x6d, 0x25, 0xf8, 0x07, 0x7c, 0x1b, 0x93,
0x4b, 0x3b, 0xd8, 0xcc, 0x84, 0xc9, 0xa8, 0xf8, 0x7d, 0xfd, 0x20, 0x32, 0x93, 0xa4, 0x8d, 0xe0,

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

@ -37,7 +37,7 @@ func init() { proto.RegisterFile("hapi/chart/template.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 107 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0x48, 0x2c, 0xc8,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0x48, 0x2c, 0xc8,
0xd4, 0x4f, 0xce, 0x48, 0x2c, 0x2a, 0xd1, 0x2f, 0x49, 0xcd, 0x2d, 0xc8, 0x49, 0x2c, 0x49, 0xd5,
0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x02, 0x49, 0xe9, 0x81, 0xa5, 0x94, 0x8c, 0xb8, 0x38,
0x42, 0xa0, 0xb2, 0x42, 0x42, 0x5c, 0x2c, 0x79, 0x89, 0xb9, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a,

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

@ -125,7 +125,7 @@ func init() { proto.RegisterFile("hapi/release/hook.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 371 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x90, 0xdf, 0x8e, 0x93, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xdf, 0x8e, 0x93, 0x40,
0x14, 0x87, 0x65, 0x5b, 0xa0, 0x3d, 0x5d, 0xd7, 0x71, 0x62, 0x74, 0xd2, 0x1b, 0xc9, 0x5e, 0x71,
0x35, 0x98, 0x35, 0x3e, 0x00, 0xdb, 0x1d, 0x75, 0xb3, 0x84, 0x36, 0x03, 0xc4, 0xc4, 0x1b, 0xc2,
0xc6, 0x69, 0x21, 0x2d, 0x0c, 0x29, 0x53, 0x7d, 0x33, 0x9f, 0xc4, 0x07, 0x32, 0x33, 0xfc, 0x89,

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

@ -22,7 +22,7 @@ type Info struct {
// Deleted tracks when this object was deleted.
Deleted *google_protobuf.Timestamp `protobuf:"bytes,4,opt,name=deleted" json:"deleted,omitempty"`
// Description is human-friendly "log entry" about this release.
Description string `protobuf:"bytes,5,opt,name=Description" json:"Description,omitempty"`
Description string `protobuf:"bytes,5,opt,name=Description,json=description" json:"Description,omitempty"`
}
func (m *Info) Reset() { *m = Info{} }
@ -65,20 +65,20 @@ func init() {
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,
0x10, 0x85, 0x95, 0x52, 0x5a, 0xd5, 0x6d, 0x19, 0x2c, 0x24, 0x42, 0x16, 0x22, 0xa6, 0x0e, 0xc8,
// 236 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x31, 0x4f, 0xc3, 0x30,
0x10, 0x85, 0x95, 0x52, 0x5a, 0xd5, 0x69, 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,
0x63, 0x57, 0xdf, 0xd2, 0x99, 0xc6, 0x83, 0x05, 0x19, 0xa0, 0x31, 0x9d, 0x46, 0xe1, 0x3c, 0x12,
0xf2, 0xc5, 0x01, 0x88, 0x0c, 0xaa, 0x9b, 0x2d, 0xe2, 0xd6, 0x42, 0x13, 0xd9, 0x66, 0xaf, 0x1b,
0x32, 0x3b, 0x08, 0x24, 0x77, 0x2e, 0xc5, 0xab, 0xeb, 0x23, 0x4f, 0x20, 0x49, 0xfb, 0x90, 0xd0,
0xed, 0xef, 0x88, 0x8d, 0x5f, 0x3b, 0x8d, 0xfc, 0x8e, 0x4d, 0x12, 0x28, 0x8b, 0xba, 0x58, 0xcd,
0xef, 0x2f, 0xc5, 0xf0, 0x0f, 0xf1, 0x16, 0x59, 0x9b, 0x33, 0xfc, 0x99, 0x5d, 0x68, 0xe3, 0x03,
0x7d, 0x2a, 0x70, 0x16, 0x7f, 0x40, 0x95, 0xa3, 0xd8, 0xaa, 0x44, 0xda, 0x22, 0xfa, 0x2d, 0xe2,
0xbd, 0xdf, 0xd2, 0x2e, 0x63, 0x63, 0x9d, 0x0b, 0xfc, 0x89, 0x2d, 0xad, 0x1c, 0x1a, 0xce, 0x4e,
0x1a, 0x16, 0x87, 0xc2, 0xbf, 0xe0, 0x91, 0x4d, 0x15, 0x58, 0x20, 0x50, 0xe5, 0xf8, 0x64, 0xb5,
0x8f, 0xf2, 0x9a, 0xcd, 0xd7, 0x10, 0xbe, 0xbc, 0x71, 0x64, 0xb0, 0x2b, 0xcf, 0xeb, 0x62, 0x35,
0x6b, 0x87, 0x4f, 0x2f, 0xb3, 0x8f, 0x69, 0xbe, 0x7a, 0x33, 0x89, 0xa6, 0x87, 0xbf, 0x00, 0x00,
0x00, 0xff, 0xff, 0x1a, 0x52, 0x8f, 0x9c, 0x89, 0x01, 0x00, 0x00,
0xfb, 0x3a, 0xf0, 0x2f, 0xf8, 0xc9, 0xa8, 0xb6, 0x03, 0x65, 0xea, 0xea, 0xef, 0xbd, 0xcf, 0xef,
0xd8, 0xc5, 0xa7, 0x74, 0xa6, 0xf5, 0x60, 0x41, 0x06, 0x68, 0x4d, 0xaf, 0x51, 0x38, 0x8f, 0x84,
0x7c, 0xbe, 0x07, 0x22, 0x83, 0xfa, 0x6a, 0x83, 0xb8, 0xb1, 0xd0, 0x46, 0xb6, 0xde, 0xe9, 0x96,
0xcc, 0x16, 0x02, 0xc9, 0xad, 0x4b, 0xf1, 0xfa, 0xf2, 0x9f, 0x27, 0x90, 0xa4, 0x5d, 0x48, 0xe8,
0xfa, 0x7b, 0xc4, 0xc6, 0xcf, 0xbd, 0x46, 0x7e, 0xc3, 0x26, 0x09, 0x54, 0x45, 0x53, 0x2c, 0xcb,
0xdb, 0x73, 0x71, 0xf8, 0x87, 0x78, 0x89, 0xac, 0xcb, 0x19, 0xfe, 0xc8, 0xce, 0xb4, 0xf1, 0x81,
0xde, 0x15, 0x38, 0x8b, 0x5f, 0xa0, 0xaa, 0x51, 0x6c, 0xd5, 0x22, 0x6d, 0x11, 0xc3, 0x16, 0xf1,
0x3a, 0x6c, 0xe9, 0x16, 0xb1, 0xb1, 0xca, 0x05, 0xfe, 0xc0, 0x16, 0x56, 0x1e, 0x1a, 0x4e, 0x8e,
0x1a, 0xe6, 0xfb, 0xc2, 0xaf, 0xe0, 0x9e, 0x4d, 0x15, 0x58, 0x20, 0x50, 0xd5, 0xf8, 0x68, 0x75,
0x88, 0xf2, 0x86, 0x95, 0x2b, 0x08, 0x1f, 0xde, 0x38, 0x32, 0xd8, 0x57, 0xa7, 0x4d, 0xb1, 0x9c,
0x75, 0xa5, 0xfa, 0x7b, 0x7a, 0x9a, 0xbd, 0x4d, 0xf3, 0xd5, 0xeb, 0x49, 0x34, 0xdd, 0xfd, 0x04,
0x00, 0x00, 0xff, 0xff, 0x1e, 0x2a, 0x57, 0x7d, 0x89, 0x01, 0x00, 0x00,
}

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

@ -78,7 +78,7 @@ func init() { proto.RegisterFile("hapi/release/release.proto", fileDescriptor2)
var fileDescriptor2 = []byte{
// 256 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x90, 0xbf, 0x4e, 0xc3, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xbf, 0x4e, 0xc3, 0x40,
0x0c, 0xc6, 0x95, 0x36, 0x7f, 0x1a, 0xc3, 0x82, 0x07, 0xb0, 0x22, 0x86, 0x88, 0x01, 0x22, 0x86,
0x54, 0x82, 0x37, 0x80, 0x05, 0xd6, 0x1b, 0xd9, 0x8e, 0xe8, 0x42, 0x4e, 0xa5, 0xe7, 0x28, 0x17,
0xf1, 0x2c, 0x3c, 0x2e, 0xba, 0x3f, 0x85, 0x94, 0x2e, 0x4e, 0xec, 0xdf, 0xa7, 0xcf, 0xdf, 0x19,

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

@ -85,7 +85,7 @@ func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 291 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x54, 0x90, 0xdf, 0x6a, 0xc2, 0x30,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xdf, 0x6a, 0xc2, 0x30,
0x14, 0xc6, 0x57, 0xad, 0x3a, 0x8f, 0x22, 0x21, 0x1b, 0xac, 0xca, 0x06, 0xc5, 0xab, 0xde, 0xac,
0x05, 0xf7, 0x04, 0xdb, 0x12, 0x87, 0xac, 0x54, 0x69, 0x2b, 0xfb, 0x73, 0x53, 0xaa, 0x9e, 0x39,
0xa1, 0x34, 0xd2, 0x24, 0x17, 0x7b, 0x88, 0xbd, 0xf3, 0x68, 0x2b, 0x74, 0x5e, 0x7e, 0xf9, 0xfd,

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

@ -74,7 +74,7 @@ func init() { proto.RegisterFile("hapi/release/test_run.proto", fileDescriptor4)
var fileDescriptor4 = []byte{
// 265 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0x41, 0x4b, 0xfb, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x41, 0x4b, 0xfb, 0x40,
0x14, 0xc4, 0xff, 0xc9, 0xbf, 0x26, 0x64, 0x53, 0x24, 0xec, 0x29, 0x54, 0xc1, 0xd0, 0x53, 0x4e,
0xbb, 0x50, 0xbd, 0x78, 0xf0, 0x10, 0x4b, 0x05, 0x51, 0x22, 0x6c, 0x1a, 0x04, 0x2f, 0x65, 0xab,
0xaf, 0x35, 0x90, 0x64, 0x43, 0xf6, 0xe5, 0x8b, 0xf8, 0x89, 0x65, 0x93, 0xad, 0x78, 0xf3, 0xf6,

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

@ -58,7 +58,7 @@ func init() { proto.RegisterFile("hapi/release/test_suite.proto", fileDescriptor
var fileDescriptor5 = []byte{
// 207 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0xc1, 0x4a, 0x86, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0xc1, 0x4a, 0x86, 0x40,
0x14, 0x85, 0x31, 0x21, 0x71, 0x74, 0x35, 0x10, 0x88, 0x11, 0x49, 0x2b, 0x57, 0x33, 0x60, 0xab,
0x16, 0x2d, 0xec, 0x11, 0xcc, 0x55, 0x1b, 0x19, 0xeb, 0x66, 0xc2, 0xe8, 0x0c, 0x73, 0xef, 0xbc,
0x5a, 0xcf, 0x17, 0xea, 0x18, 0x41, 0x8b, 0x7f, 0xfd, 0x7d, 0xe7, 0x9c, 0x7b, 0xd9, 0xdd, 0x97,

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

@ -16,6 +16,8 @@ It has these top-level messages:
GetReleaseStatusResponse
GetReleaseContentRequest
GetReleaseContentResponse
GetReleaseLogsRequest
GetReleaseLogsResponse
UpdateReleaseRequest
UpdateReleaseResponse
RollbackReleaseRequest
@ -238,6 +240,30 @@ func (m *GetReleaseContentResponse) GetRelease() *hapi_release5.Release {
return nil
}
type GetReleaseLogsRequest struct {
// Name is the name of the release
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Version is the version of the release
Version int32 `protobuf:"varint,2,opt,name=version" json:"version,omitempty"`
}
func (m *GetReleaseLogsRequest) Reset() { *m = GetReleaseLogsRequest{} }
func (m *GetReleaseLogsRequest) String() string { return proto.CompactTextString(m) }
func (*GetReleaseLogsRequest) ProtoMessage() {}
func (*GetReleaseLogsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
type GetReleaseLogsResponse struct {
// Source is the name of the release that generated the log
Source string `protobuf:"bytes,1,opt,name=source" json:"source,omitempty"`
// Log is a single log line
Log string `protobuf:"bytes,2,opt,name=log" json:"log,omitempty"`
}
func (m *GetReleaseLogsResponse) Reset() { *m = GetReleaseLogsResponse{} }
func (m *GetReleaseLogsResponse) String() string { return proto.CompactTextString(m) }
func (*GetReleaseLogsResponse) ProtoMessage() {}
func (*GetReleaseLogsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
// UpdateReleaseRequest updates a release.
type UpdateReleaseRequest struct {
// The name of the release
@ -267,7 +293,7 @@ type UpdateReleaseRequest struct {
func (m *UpdateReleaseRequest) Reset() { *m = UpdateReleaseRequest{} }
func (m *UpdateReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateReleaseRequest) ProtoMessage() {}
func (*UpdateReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
func (*UpdateReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
func (m *UpdateReleaseRequest) GetChart() *hapi_chart3.Chart {
if m != nil {
@ -291,7 +317,7 @@ type UpdateReleaseResponse struct {
func (m *UpdateReleaseResponse) Reset() { *m = UpdateReleaseResponse{} }
func (m *UpdateReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateReleaseResponse) ProtoMessage() {}
func (*UpdateReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
func (*UpdateReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
func (m *UpdateReleaseResponse) GetRelease() *hapi_release5.Release {
if m != nil {
@ -321,7 +347,7 @@ type RollbackReleaseRequest struct {
func (m *RollbackReleaseRequest) Reset() { *m = RollbackReleaseRequest{} }
func (m *RollbackReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*RollbackReleaseRequest) ProtoMessage() {}
func (*RollbackReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
func (*RollbackReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
// RollbackReleaseResponse is the response to an update request.
type RollbackReleaseResponse struct {
@ -331,7 +357,7 @@ type RollbackReleaseResponse struct {
func (m *RollbackReleaseResponse) Reset() { *m = RollbackReleaseResponse{} }
func (m *RollbackReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*RollbackReleaseResponse) ProtoMessage() {}
func (*RollbackReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
func (*RollbackReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
func (m *RollbackReleaseResponse) GetRelease() *hapi_release5.Release {
if m != nil {
@ -370,7 +396,7 @@ type InstallReleaseRequest struct {
func (m *InstallReleaseRequest) Reset() { *m = InstallReleaseRequest{} }
func (m *InstallReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*InstallReleaseRequest) ProtoMessage() {}
func (*InstallReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
func (*InstallReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
func (m *InstallReleaseRequest) GetChart() *hapi_chart3.Chart {
if m != nil {
@ -394,7 +420,7 @@ type InstallReleaseResponse struct {
func (m *InstallReleaseResponse) Reset() { *m = InstallReleaseResponse{} }
func (m *InstallReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*InstallReleaseResponse) ProtoMessage() {}
func (*InstallReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
func (*InstallReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
func (m *InstallReleaseResponse) GetRelease() *hapi_release5.Release {
if m != nil {
@ -418,7 +444,7 @@ type UninstallReleaseRequest struct {
func (m *UninstallReleaseRequest) Reset() { *m = UninstallReleaseRequest{} }
func (m *UninstallReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*UninstallReleaseRequest) ProtoMessage() {}
func (*UninstallReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
func (*UninstallReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
// UninstallReleaseResponse represents a successful response to an uninstall request.
type UninstallReleaseResponse struct {
@ -431,7 +457,7 @@ type UninstallReleaseResponse struct {
func (m *UninstallReleaseResponse) Reset() { *m = UninstallReleaseResponse{} }
func (m *UninstallReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*UninstallReleaseResponse) ProtoMessage() {}
func (*UninstallReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
func (*UninstallReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
func (m *UninstallReleaseResponse) GetRelease() *hapi_release5.Release {
if m != nil {
@ -447,16 +473,16 @@ type GetVersionRequest struct {
func (m *GetVersionRequest) Reset() { *m = GetVersionRequest{} }
func (m *GetVersionRequest) String() string { return proto.CompactTextString(m) }
func (*GetVersionRequest) ProtoMessage() {}
func (*GetVersionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
func (*GetVersionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
type GetVersionResponse struct {
Version *hapi_version.Version `protobuf:"bytes,1,opt,name=Version" json:"Version,omitempty"`
Version *hapi_version.Version `protobuf:"bytes,1,opt,name=Version,json=version" json:"Version,omitempty"`
}
func (m *GetVersionResponse) Reset() { *m = GetVersionResponse{} }
func (m *GetVersionResponse) String() string { return proto.CompactTextString(m) }
func (*GetVersionResponse) ProtoMessage() {}
func (*GetVersionResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
func (*GetVersionResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
func (m *GetVersionResponse) GetVersion() *hapi_version.Version {
if m != nil {
@ -476,7 +502,7 @@ type GetHistoryRequest struct {
func (m *GetHistoryRequest) Reset() { *m = GetHistoryRequest{} }
func (m *GetHistoryRequest) String() string { return proto.CompactTextString(m) }
func (*GetHistoryRequest) ProtoMessage() {}
func (*GetHistoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
func (*GetHistoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
// GetHistoryResponse is received in response to a GetHistory rpc.
type GetHistoryResponse struct {
@ -486,7 +512,7 @@ type GetHistoryResponse struct {
func (m *GetHistoryResponse) Reset() { *m = GetHistoryResponse{} }
func (m *GetHistoryResponse) String() string { return proto.CompactTextString(m) }
func (*GetHistoryResponse) ProtoMessage() {}
func (*GetHistoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
func (*GetHistoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
func (m *GetHistoryResponse) GetReleases() []*hapi_release5.Release {
if m != nil {
@ -508,7 +534,7 @@ type TestReleaseRequest struct {
func (m *TestReleaseRequest) Reset() { *m = TestReleaseRequest{} }
func (m *TestReleaseRequest) String() string { return proto.CompactTextString(m) }
func (*TestReleaseRequest) ProtoMessage() {}
func (*TestReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
func (*TestReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
// TestReleaseResponse represents a message from executing a test
type TestReleaseResponse struct {
@ -518,7 +544,7 @@ type TestReleaseResponse struct {
func (m *TestReleaseResponse) Reset() { *m = TestReleaseResponse{} }
func (m *TestReleaseResponse) String() string { return proto.CompactTextString(m) }
func (*TestReleaseResponse) ProtoMessage() {}
func (*TestReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
func (*TestReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
func init() {
proto.RegisterType((*ListReleasesRequest)(nil), "hapi.services.tiller.ListReleasesRequest")
@ -528,6 +554,8 @@ func init() {
proto.RegisterType((*GetReleaseStatusResponse)(nil), "hapi.services.tiller.GetReleaseStatusResponse")
proto.RegisterType((*GetReleaseContentRequest)(nil), "hapi.services.tiller.GetReleaseContentRequest")
proto.RegisterType((*GetReleaseContentResponse)(nil), "hapi.services.tiller.GetReleaseContentResponse")
proto.RegisterType((*GetReleaseLogsRequest)(nil), "hapi.services.tiller.GetReleaseLogsRequest")
proto.RegisterType((*GetReleaseLogsResponse)(nil), "hapi.services.tiller.GetReleaseLogsResponse")
proto.RegisterType((*UpdateReleaseRequest)(nil), "hapi.services.tiller.UpdateReleaseRequest")
proto.RegisterType((*UpdateReleaseResponse)(nil), "hapi.services.tiller.UpdateReleaseResponse")
proto.RegisterType((*RollbackReleaseRequest)(nil), "hapi.services.tiller.RollbackReleaseRequest")
@ -566,6 +594,8 @@ type ReleaseServiceClient interface {
GetReleaseStatus(ctx context.Context, in *GetReleaseStatusRequest, opts ...grpc.CallOption) (*GetReleaseStatusResponse, error)
// GetReleaseContent retrieves the release content (chart + value) for the specified release.
GetReleaseContent(ctx context.Context, in *GetReleaseContentRequest, opts ...grpc.CallOption) (*GetReleaseContentResponse, error)
// GetReleaseLogs returns a stream of logging information from the release
GetReleaseLogs(ctx context.Context, in *GetReleaseLogsRequest, opts ...grpc.CallOption) (ReleaseService_GetReleaseLogsClient, error)
// UpdateRelease updates release content.
UpdateRelease(ctx context.Context, in *UpdateReleaseRequest, opts ...grpc.CallOption) (*UpdateReleaseResponse, error)
// InstallRelease requests installation of a chart as a new release.
@ -640,6 +670,38 @@ func (c *releaseServiceClient) GetReleaseContent(ctx context.Context, in *GetRel
return out, nil
}
func (c *releaseServiceClient) GetReleaseLogs(ctx context.Context, in *GetReleaseLogsRequest, opts ...grpc.CallOption) (ReleaseService_GetReleaseLogsClient, error) {
stream, err := grpc.NewClientStream(ctx, &_ReleaseService_serviceDesc.Streams[1], c.cc, "/hapi.services.tiller.ReleaseService/GetReleaseLogs", opts...)
if err != nil {
return nil, err
}
x := &releaseServiceGetReleaseLogsClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type ReleaseService_GetReleaseLogsClient interface {
Recv() (*GetReleaseLogsResponse, error)
grpc.ClientStream
}
type releaseServiceGetReleaseLogsClient struct {
grpc.ClientStream
}
func (x *releaseServiceGetReleaseLogsClient) Recv() (*GetReleaseLogsResponse, error) {
m := new(GetReleaseLogsResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *releaseServiceClient) UpdateRelease(ctx context.Context, in *UpdateReleaseRequest, opts ...grpc.CallOption) (*UpdateReleaseResponse, error) {
out := new(UpdateReleaseResponse)
err := grpc.Invoke(ctx, "/hapi.services.tiller.ReleaseService/UpdateRelease", in, out, c.cc, opts...)
@ -695,7 +757,7 @@ func (c *releaseServiceClient) GetHistory(ctx context.Context, in *GetHistoryReq
}
func (c *releaseServiceClient) RunReleaseTest(ctx context.Context, in *TestReleaseRequest, opts ...grpc.CallOption) (ReleaseService_RunReleaseTestClient, error) {
stream, err := grpc.NewClientStream(ctx, &_ReleaseService_serviceDesc.Streams[1], c.cc, "/hapi.services.tiller.ReleaseService/RunReleaseTest", opts...)
stream, err := grpc.NewClientStream(ctx, &_ReleaseService_serviceDesc.Streams[2], c.cc, "/hapi.services.tiller.ReleaseService/RunReleaseTest", opts...)
if err != nil {
return nil, err
}
@ -738,6 +800,8 @@ type ReleaseServiceServer interface {
GetReleaseStatus(context.Context, *GetReleaseStatusRequest) (*GetReleaseStatusResponse, error)
// GetReleaseContent retrieves the release content (chart + value) for the specified release.
GetReleaseContent(context.Context, *GetReleaseContentRequest) (*GetReleaseContentResponse, error)
// GetReleaseLogs returns a stream of logging information from the release
GetReleaseLogs(*GetReleaseLogsRequest, ReleaseService_GetReleaseLogsServer) error
// UpdateRelease updates release content.
UpdateRelease(context.Context, *UpdateReleaseRequest) (*UpdateReleaseResponse, error)
// InstallRelease requests installation of a chart as a new release.
@ -815,6 +879,27 @@ func _ReleaseService_GetReleaseContent_Handler(srv interface{}, ctx context.Cont
return interceptor(ctx, in, info, handler)
}
func _ReleaseService_GetReleaseLogs_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetReleaseLogsRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(ReleaseServiceServer).GetReleaseLogs(m, &releaseServiceGetReleaseLogsServer{stream})
}
type ReleaseService_GetReleaseLogsServer interface {
Send(*GetReleaseLogsResponse) error
grpc.ServerStream
}
type releaseServiceGetReleaseLogsServer struct {
grpc.ServerStream
}
func (x *releaseServiceGetReleaseLogsServer) Send(m *GetReleaseLogsResponse) error {
return x.ServerStream.SendMsg(m)
}
func _ReleaseService_UpdateRelease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateReleaseRequest)
if err := dec(in); err != nil {
@ -987,6 +1072,11 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{
Handler: _ReleaseService_ListReleases_Handler,
ServerStreams: true,
},
{
StreamName: "GetReleaseLogs",
Handler: _ReleaseService_GetReleaseLogs_Handler,
ServerStreams: true,
},
{
StreamName: "RunReleaseTest",
Handler: _ReleaseService_RunReleaseTest_Handler,
@ -999,79 +1089,82 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("hapi/services/tiller.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 1170 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x57, 0xdb, 0x6e, 0xe3, 0x44,
0x18, 0xae, 0xe3, 0x1c, 0xff, 0x1e, 0x48, 0xa7, 0x27, 0xd7, 0x02, 0x54, 0x8c, 0xa0, 0xd9, 0x85,
0x4d, 0x21, 0x5c, 0x21, 0x21, 0xa4, 0x6e, 0x37, 0x6a, 0x0b, 0xa5, 0x2b, 0x39, 0xdb, 0x45, 0x42,
0x88, 0xc8, 0x4d, 0x26, 0xad, 0x59, 0xc7, 0x13, 0x3c, 0xe3, 0xb2, 0xbd, 0xe5, 0x8e, 0x47, 0xe1,
0x2d, 0x78, 0x01, 0x78, 0x01, 0x5e, 0x06, 0x79, 0x0e, 0x6e, 0xc6, 0xb5, 0x5b, 0x6f, 0x6e, 0x62,
0xcf, 0xfc, 0xe7, 0xef, 0xff, 0xfd, 0xcd, 0x04, 0xec, 0x6b, 0x6f, 0xe6, 0x1f, 0x50, 0x1c, 0xdd,
0xf8, 0x23, 0x4c, 0x0f, 0x98, 0x1f, 0x04, 0x38, 0xea, 0xce, 0x22, 0xc2, 0x08, 0xda, 0x4c, 0x64,
0x5d, 0x25, 0xeb, 0x0a, 0x99, 0xbd, 0xcd, 0x2d, 0x46, 0xd7, 0x5e, 0xc4, 0xc4, 0xaf, 0xd0, 0xb6,
0x77, 0xe6, 0xf7, 0x49, 0x38, 0xf1, 0xaf, 0xa4, 0x40, 0x84, 0x88, 0x70, 0x80, 0x3d, 0x8a, 0xd5,
0x53, 0x33, 0x52, 0x32, 0x3f, 0x9c, 0x10, 0x29, 0xd8, 0xd5, 0x04, 0x94, 0x79, 0x2c, 0xa6, 0x9a,
0xbf, 0x1b, 0x1c, 0x51, 0x9f, 0x84, 0xea, 0x29, 0x64, 0xce, 0xdf, 0x15, 0xd8, 0x38, 0xf3, 0x29,
0x73, 0x85, 0x21, 0x75, 0xf1, 0x6f, 0x31, 0xa6, 0x0c, 0x6d, 0x42, 0x2d, 0xf0, 0xa7, 0x3e, 0xb3,
0x8c, 0x3d, 0xa3, 0x63, 0xba, 0x62, 0x81, 0xb6, 0xa1, 0x4e, 0x26, 0x13, 0x8a, 0x99, 0x55, 0xd9,
0x33, 0x3a, 0x2d, 0x57, 0xae, 0xd0, 0xb7, 0xd0, 0xa0, 0x24, 0x62, 0xc3, 0xcb, 0x5b, 0xcb, 0xdc,
0x33, 0x3a, 0x6b, 0xbd, 0x4f, 0xba, 0x79, 0x50, 0x74, 0x93, 0x48, 0x03, 0x12, 0xb1, 0x6e, 0xf2,
0xf3, 0xfc, 0xd6, 0xad, 0x53, 0xfe, 0x4c, 0xfc, 0x4e, 0xfc, 0x80, 0xe1, 0xc8, 0xaa, 0x0a, 0xbf,
0x62, 0x85, 0x8e, 0x01, 0xb8, 0x5f, 0x12, 0x8d, 0x71, 0x64, 0xd5, 0xb8, 0xeb, 0x4e, 0x09, 0xd7,
0x2f, 0x13, 0x7d, 0xb7, 0x45, 0xd5, 0x2b, 0xfa, 0x06, 0x56, 0x04, 0x24, 0xc3, 0x11, 0x19, 0x63,
0x6a, 0xd5, 0xf7, 0xcc, 0xce, 0x5a, 0x6f, 0x57, 0xb8, 0x52, 0x08, 0x0f, 0x04, 0x68, 0x47, 0x64,
0x8c, 0xdd, 0x65, 0xa1, 0x9e, 0xbc, 0x53, 0xf4, 0x3e, 0xb4, 0x42, 0x6f, 0x8a, 0xe9, 0xcc, 0x1b,
0x61, 0xab, 0xc1, 0x33, 0xbc, 0xdb, 0x70, 0x7e, 0x81, 0xa6, 0x0a, 0xee, 0xf4, 0xa0, 0x2e, 0x4a,
0x43, 0xcb, 0xd0, 0xb8, 0x38, 0xff, 0xfe, 0xfc, 0xe5, 0x8f, 0xe7, 0xed, 0x25, 0xd4, 0x84, 0xea,
0xf9, 0xe1, 0x0f, 0xfd, 0xb6, 0x81, 0xd6, 0x61, 0xf5, 0xec, 0x70, 0xf0, 0x6a, 0xe8, 0xf6, 0xcf,
0xfa, 0x87, 0x83, 0xfe, 0x8b, 0x76, 0xc5, 0xf9, 0x10, 0x5a, 0x69, 0xce, 0xa8, 0x01, 0xe6, 0xe1,
0xe0, 0x48, 0x98, 0xbc, 0xe8, 0x0f, 0x8e, 0xda, 0x86, 0xf3, 0xa7, 0x01, 0x9b, 0x7a, 0x8b, 0xe8,
0x8c, 0x84, 0x14, 0x27, 0x3d, 0x1a, 0x91, 0x38, 0x4c, 0x7b, 0xc4, 0x17, 0x08, 0x41, 0x35, 0xc4,
0x6f, 0x55, 0x87, 0xf8, 0x7b, 0xa2, 0xc9, 0x08, 0xf3, 0x02, 0xde, 0x1d, 0xd3, 0x15, 0x0b, 0xf4,
0x25, 0x34, 0x65, 0xe9, 0xd4, 0xaa, 0xee, 0x99, 0x9d, 0xe5, 0xde, 0x96, 0x0e, 0x88, 0x8c, 0xe8,
0xa6, 0x6a, 0xce, 0x31, 0xec, 0x1c, 0x63, 0x95, 0x89, 0xc0, 0x4b, 0x4d, 0x4c, 0x12, 0xd7, 0x9b,
0x62, 0x9e, 0x4c, 0x12, 0xd7, 0x9b, 0x62, 0x64, 0x41, 0x43, 0x8e, 0x1b, 0x4f, 0xa7, 0xe6, 0xaa,
0xa5, 0xc3, 0xc0, 0xba, 0xef, 0x48, 0xd6, 0x95, 0xe7, 0xe9, 0x53, 0xa8, 0x26, 0xc3, 0xce, 0xdd,
0x2c, 0xf7, 0x90, 0x9e, 0xe7, 0x69, 0x38, 0x21, 0x2e, 0x97, 0xeb, 0xad, 0x32, 0xb3, 0xad, 0x3a,
0x99, 0x8f, 0x7a, 0x44, 0x42, 0x86, 0x43, 0xb6, 0x58, 0xfe, 0x67, 0xb0, 0x9b, 0xe3, 0x49, 0x16,
0x70, 0x00, 0x0d, 0x99, 0x1a, 0xf7, 0x56, 0x88, 0xab, 0xd2, 0x72, 0xfe, 0xa9, 0xc0, 0xe6, 0xc5,
0x6c, 0xec, 0x31, 0xac, 0x44, 0x0f, 0x24, 0xb5, 0x0f, 0x35, 0x4e, 0x1a, 0x12, 0x8b, 0x75, 0xe1,
0x5b, 0x30, 0xcb, 0x51, 0xf2, 0xeb, 0x0a, 0x39, 0x7a, 0x0a, 0xf5, 0x1b, 0x2f, 0x88, 0x31, 0xe5,
0x40, 0xa4, 0xa8, 0x49, 0x4d, 0xce, 0x38, 0xae, 0xd4, 0x40, 0x3b, 0xd0, 0x18, 0x47, 0xb7, 0xc3,
0x28, 0x0e, 0xf9, 0x27, 0xd8, 0x74, 0xeb, 0xe3, 0xe8, 0xd6, 0x8d, 0x43, 0xf4, 0x31, 0xac, 0x8e,
0x7d, 0xea, 0x5d, 0x06, 0x78, 0x78, 0x4d, 0xc8, 0x1b, 0xca, 0xbf, 0xc2, 0xa6, 0xbb, 0x22, 0x37,
0x4f, 0x92, 0x3d, 0x64, 0x27, 0x93, 0x34, 0x8a, 0xb0, 0xc7, 0xb0, 0x55, 0xe7, 0xf2, 0x74, 0x9d,
0x60, 0xc8, 0xfc, 0x29, 0x26, 0x31, 0xe3, 0x9f, 0x8e, 0xe9, 0xaa, 0x25, 0xfa, 0x08, 0x56, 0x22,
0x4c, 0x31, 0x1b, 0xca, 0x2c, 0x9b, 0xdc, 0x72, 0x99, 0xef, 0xbd, 0x16, 0x69, 0x21, 0xa8, 0xfe,
0xee, 0xf9, 0xcc, 0x6a, 0x71, 0x11, 0x7f, 0x17, 0x66, 0x31, 0xc5, 0xca, 0x0c, 0x94, 0x59, 0x4c,
0xb1, 0x30, 0x73, 0x4e, 0x60, 0x2b, 0x03, 0xe7, 0xa2, 0x9d, 0xf9, 0xd7, 0x80, 0x6d, 0x97, 0x04,
0xc1, 0xa5, 0x37, 0x7a, 0x53, 0xa2, 0x37, 0x73, 0x30, 0x56, 0x1e, 0x86, 0xd1, 0xcc, 0x81, 0x71,
0x6e, 0xdc, 0xaa, 0xda, 0xb8, 0x69, 0x00, 0xd7, 0x8a, 0x01, 0xae, 0xeb, 0x00, 0x2b, 0xf4, 0x1a,
0x77, 0xe8, 0x39, 0xdf, 0xc1, 0xce, 0xbd, 0x7a, 0x16, 0x05, 0xe7, 0xaf, 0x0a, 0x6c, 0x9d, 0x86,
0x94, 0x79, 0x41, 0x90, 0xc1, 0x26, 0x9d, 0x51, 0xa3, 0xf4, 0x8c, 0x56, 0xde, 0x65, 0x46, 0x4d,
0x0d, 0x5c, 0xd5, 0x89, 0xea, 0x5c, 0x27, 0x4a, 0xcd, 0xad, 0xc6, 0x16, 0xf5, 0x0c, 0x5b, 0xa0,
0x0f, 0x00, 0xc4, 0xa0, 0x71, 0xe7, 0x02, 0xc4, 0x16, 0xdf, 0x39, 0x97, 0xe4, 0xa0, 0x70, 0x6f,
0xe6, 0xe3, 0x3e, 0x37, 0xb5, 0xce, 0x29, 0x6c, 0x67, 0xa1, 0x5a, 0x14, 0xf6, 0x3f, 0x0c, 0xd8,
0xb9, 0x08, 0xfd, 0x5c, 0xe0, 0xf3, 0x86, 0xf2, 0x1e, 0x14, 0x95, 0x1c, 0x28, 0x36, 0xa1, 0x36,
0x8b, 0xa3, 0x2b, 0x2c, 0xa1, 0x15, 0x8b, 0xf9, 0x1a, 0xab, 0x5a, 0x8d, 0xce, 0x10, 0xac, 0xfb,
0x39, 0x2c, 0x58, 0x51, 0x92, 0x75, 0xca, 0xee, 0x2d, 0xc1, 0xe4, 0xce, 0x06, 0xac, 0x1f, 0x63,
0xf6, 0x5a, 0x7c, 0x00, 0xb2, 0x3c, 0xa7, 0x0f, 0x68, 0x7e, 0xf3, 0x2e, 0x9e, 0xdc, 0xd2, 0xe3,
0xa9, 0xab, 0x8e, 0xd2, 0x57, 0x5a, 0xce, 0xd7, 0xdc, 0xf7, 0x89, 0x4f, 0x19, 0x89, 0x6e, 0x1f,
0x82, 0xae, 0x0d, 0xe6, 0xd4, 0x7b, 0x2b, 0xc9, 0x3f, 0x79, 0x75, 0x8e, 0x79, 0x06, 0xa9, 0xa9,
0xcc, 0x60, 0xfe, 0x28, 0x35, 0xca, 0x1d, 0xa5, 0x3f, 0x03, 0x7a, 0x85, 0xd3, 0x53, 0xfd, 0x91,
0x53, 0x48, 0x35, 0xa1, 0xa2, 0x0f, 0x9a, 0x05, 0x8d, 0x51, 0x80, 0xbd, 0x30, 0x9e, 0xc9, 0xb6,
0xa9, 0xa5, 0xb3, 0x0f, 0x1b, 0x9a, 0x77, 0x99, 0x67, 0x52, 0x0f, 0xbd, 0x92, 0xde, 0x93, 0xd7,
0xde, 0x7f, 0x4d, 0x58, 0x53, 0xc7, 0xb0, 0xb8, 0x52, 0x21, 0x1f, 0x56, 0xe6, 0xef, 0x1b, 0xe8,
0x49, 0xf1, 0x8d, 0x2b, 0x73, 0x6d, 0xb4, 0x9f, 0x96, 0x51, 0x15, 0xb9, 0x38, 0x4b, 0x5f, 0x18,
0x88, 0x42, 0x3b, 0x7b, 0x0d, 0x40, 0xcf, 0xf2, 0x7d, 0x14, 0xdc, 0x3b, 0xec, 0x6e, 0x59, 0x75,
0x15, 0x16, 0xdd, 0xf0, 0xee, 0xeb, 0x67, 0x37, 0x7a, 0xd4, 0x8d, 0x7e, 0x5d, 0xb0, 0x0f, 0x4a,
0xeb, 0xa7, 0x71, 0x7f, 0x85, 0x55, 0xed, 0x54, 0x42, 0x05, 0x68, 0xe5, 0xdd, 0x04, 0xec, 0xcf,
0x4a, 0xe9, 0xa6, 0xb1, 0xa6, 0xb0, 0xa6, 0xd3, 0x0d, 0x2a, 0x70, 0x90, 0xcb, 0xdf, 0xf6, 0xe7,
0xe5, 0x94, 0xd3, 0x70, 0x14, 0xda, 0x59, 0x36, 0x28, 0xea, 0x63, 0x01, 0x73, 0x15, 0xf5, 0xb1,
0x88, 0x64, 0x9c, 0x25, 0xe4, 0x01, 0xdc, 0x91, 0x01, 0xda, 0x2f, 0x6c, 0x88, 0xce, 0x21, 0x76,
0xe7, 0x71, 0xc5, 0x34, 0xc4, 0x0c, 0xde, 0xcb, 0x9c, 0x96, 0xa8, 0x00, 0x9a, 0xfc, 0x4b, 0x82,
0xfd, 0xac, 0xa4, 0x76, 0xa6, 0x28, 0xc9, 0x2f, 0x0f, 0x14, 0xa5, 0x93, 0xd7, 0x03, 0x45, 0x65,
0xa8, 0xca, 0x59, 0x42, 0x3e, 0xac, 0xb9, 0x71, 0x28, 0x43, 0x27, 0x2c, 0x81, 0x0a, 0xac, 0xef,
0xf3, 0x93, 0xfd, 0xa4, 0x84, 0xe6, 0xdd, 0xf7, 0xfd, 0x1c, 0x7e, 0x6a, 0x2a, 0xd5, 0xcb, 0x3a,
0xff, 0xc7, 0xf9, 0xd5, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x30, 0x80, 0xed, 0x18, 0x42, 0x0f,
0x00, 0x00,
// 1226 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xdd, 0x6e, 0xe3, 0x44,
0x14, 0xae, 0xe3, 0xfc, 0x9e, 0x76, 0x43, 0x76, 0xb6, 0x4d, 0x5d, 0x0b, 0x50, 0x31, 0x82, 0x66,
0x77, 0xd9, 0x14, 0xc2, 0x15, 0x12, 0x42, 0x6a, 0xbb, 0x51, 0x5b, 0x28, 0x5d, 0xc9, 0xd9, 0x2e,
0x12, 0x42, 0x44, 0x6e, 0x32, 0x69, 0xcd, 0x3a, 0x9e, 0xe0, 0x19, 0x97, 0xed, 0x2d, 0x77, 0x3c,
0x0a, 0x6f, 0xc1, 0x03, 0x00, 0xcf, 0x84, 0x3c, 0x3f, 0x8e, 0xed, 0xda, 0xad, 0xc9, 0x4d, 0x3c,
0x33, 0xe7, 0xcc, 0xf9, 0xf9, 0xce, 0xe9, 0x37, 0xa7, 0x60, 0x5e, 0x3b, 0x0b, 0x77, 0x9f, 0xe2,
0xe0, 0xc6, 0x9d, 0x60, 0xba, 0xcf, 0x5c, 0xcf, 0xc3, 0x41, 0x7f, 0x11, 0x10, 0x46, 0xd0, 0x66,
0x24, 0xeb, 0x2b, 0x59, 0x5f, 0xc8, 0xcc, 0x2e, 0xbf, 0x31, 0xb9, 0x76, 0x02, 0x26, 0x7e, 0x85,
0xb6, 0xb9, 0x9d, 0x3c, 0x27, 0xfe, 0xcc, 0xbd, 0x92, 0x02, 0xe1, 0x22, 0xc0, 0x1e, 0x76, 0x28,
0x56, 0xdf, 0xd4, 0x25, 0x25, 0x73, 0xfd, 0x19, 0x91, 0x82, 0x9d, 0x94, 0x80, 0x32, 0x87, 0x85,
0x34, 0x65, 0xef, 0x06, 0x07, 0xd4, 0x25, 0xbe, 0xfa, 0x0a, 0x99, 0xf5, 0x57, 0x05, 0x9e, 0x9c,
0xb9, 0x94, 0xd9, 0xe2, 0x22, 0xb5, 0xf1, 0xaf, 0x21, 0xa6, 0x0c, 0x6d, 0x42, 0xcd, 0x73, 0xe7,
0x2e, 0x33, 0xb4, 0x5d, 0xad, 0xa7, 0xdb, 0x62, 0x83, 0xba, 0x50, 0x27, 0xb3, 0x19, 0xc5, 0xcc,
0xa8, 0xec, 0x6a, 0xbd, 0x96, 0x2d, 0x77, 0xe8, 0x1b, 0x68, 0x50, 0x12, 0xb0, 0xf1, 0xe5, 0xad,
0xa1, 0xef, 0x6a, 0xbd, 0xf6, 0xe0, 0x93, 0x7e, 0x1e, 0x14, 0xfd, 0xc8, 0xd3, 0x88, 0x04, 0xac,
0x1f, 0xfd, 0x1c, 0xde, 0xda, 0x75, 0xca, 0xbf, 0x91, 0xdd, 0x99, 0xeb, 0x31, 0x1c, 0x18, 0x55,
0x61, 0x57, 0xec, 0xd0, 0x31, 0x00, 0xb7, 0x4b, 0x82, 0x29, 0x0e, 0x8c, 0x1a, 0x37, 0xdd, 0x2b,
0x61, 0xfa, 0x55, 0xa4, 0x6f, 0xb7, 0xa8, 0x5a, 0xa2, 0xaf, 0x61, 0x43, 0x40, 0x32, 0x9e, 0x90,
0x29, 0xa6, 0x46, 0x7d, 0x57, 0xef, 0xb5, 0x07, 0x3b, 0xc2, 0x94, 0x42, 0x78, 0x24, 0x40, 0x3b,
0x22, 0x53, 0x6c, 0xaf, 0x0b, 0xf5, 0x68, 0x4d, 0xd1, 0xfb, 0xd0, 0xf2, 0x9d, 0x39, 0xa6, 0x0b,
0x67, 0x82, 0x8d, 0x06, 0x8f, 0x70, 0x79, 0x60, 0xfd, 0x0c, 0x4d, 0xe5, 0xdc, 0x1a, 0x40, 0x5d,
0xa4, 0x86, 0xd6, 0xa1, 0x71, 0x71, 0xfe, 0xdd, 0xf9, 0xab, 0x1f, 0xce, 0x3b, 0x6b, 0xa8, 0x09,
0xd5, 0xf3, 0x83, 0xef, 0x87, 0x1d, 0x0d, 0x3d, 0x86, 0x47, 0x67, 0x07, 0xa3, 0xd7, 0x63, 0x7b,
0x78, 0x36, 0x3c, 0x18, 0x0d, 0x5f, 0x76, 0x2a, 0xd6, 0x87, 0xd0, 0x8a, 0x63, 0x46, 0x0d, 0xd0,
0x0f, 0x46, 0x47, 0xe2, 0xca, 0xcb, 0xe1, 0xe8, 0xa8, 0xa3, 0x59, 0x7f, 0x68, 0xb0, 0x99, 0x2e,
0x11, 0x5d, 0x10, 0x9f, 0xe2, 0xa8, 0x46, 0x13, 0x12, 0xfa, 0x71, 0x8d, 0xf8, 0x06, 0x21, 0xa8,
0xfa, 0xf8, 0x9d, 0xaa, 0x10, 0x5f, 0x47, 0x9a, 0x8c, 0x30, 0xc7, 0xe3, 0xd5, 0xd1, 0x6d, 0xb1,
0x41, 0x5f, 0x40, 0x53, 0xa6, 0x4e, 0x8d, 0xea, 0xae, 0xde, 0x5b, 0x1f, 0x6c, 0xa5, 0x01, 0x91,
0x1e, 0xed, 0x58, 0xcd, 0x3a, 0x86, 0xed, 0x63, 0xac, 0x22, 0x11, 0x78, 0xa9, 0x8e, 0x89, 0xfc,
0x3a, 0x73, 0xcc, 0x83, 0x89, 0xfc, 0x3a, 0x73, 0x8c, 0x0c, 0x68, 0xc8, 0x76, 0xe3, 0xe1, 0xd4,
0x6c, 0xb5, 0xb5, 0x18, 0x18, 0x77, 0x0d, 0xc9, 0xbc, 0xf2, 0x2c, 0x7d, 0x0a, 0xd5, 0xa8, 0xd9,
0xb9, 0x99, 0xf5, 0x01, 0x4a, 0xc7, 0x79, 0xea, 0xcf, 0x88, 0xcd, 0xe5, 0xe9, 0x52, 0xe9, 0xd9,
0x52, 0x9d, 0x24, 0xbd, 0x1e, 0x11, 0x9f, 0x61, 0x9f, 0xad, 0x16, 0xff, 0x19, 0xec, 0xe4, 0x58,
0x92, 0x09, 0xec, 0x43, 0x43, 0x86, 0xc6, 0xad, 0x15, 0xe2, 0xaa, 0xb4, 0xac, 0x21, 0x6c, 0x2d,
0xad, 0x9d, 0x91, 0xab, 0x15, 0x41, 0x3d, 0x84, 0x6e, 0xd6, 0x8c, 0x8c, 0xa8, 0x0b, 0x75, 0x4a,
0xc2, 0x60, 0xa2, 0x2c, 0xc9, 0x1d, 0xea, 0x80, 0xee, 0x91, 0x2b, 0xd9, 0x2b, 0xd1, 0xd2, 0xfa,
0xa7, 0x02, 0x9b, 0x17, 0x8b, 0xa9, 0xc3, 0xb0, 0x8a, 0xf2, 0x9e, 0x50, 0xf6, 0xa0, 0xc6, 0xf9,
0x4b, 0x96, 0xe5, 0xb1, 0x48, 0x53, 0x90, 0xdc, 0x51, 0xf4, 0x6b, 0x0b, 0x39, 0x7a, 0x06, 0xf5,
0x1b, 0xc7, 0x0b, 0x31, 0xe5, 0x35, 0x89, 0x0b, 0x28, 0x35, 0x39, 0xf9, 0xd9, 0x52, 0x03, 0x6d,
0x43, 0x63, 0x1a, 0xdc, 0x8e, 0x83, 0xd0, 0xe7, 0x6c, 0xd0, 0xb4, 0xeb, 0xd3, 0xe0, 0xd6, 0x0e,
0x7d, 0xf4, 0x31, 0x3c, 0x9a, 0xba, 0xd4, 0xb9, 0xf4, 0xf0, 0xf8, 0x9a, 0x90, 0xb7, 0x94, 0x13,
0x42, 0xd3, 0xde, 0x90, 0x87, 0x27, 0xd1, 0x19, 0x32, 0xa3, 0xa6, 0x9e, 0x04, 0xd8, 0x61, 0xd8,
0xa8, 0x73, 0x79, 0xbc, 0x8f, 0x90, 0x63, 0xee, 0x1c, 0x93, 0x90, 0xf1, 0xbf, 0x62, 0xdd, 0x56,
0x5b, 0xf4, 0x11, 0x6c, 0x04, 0x98, 0x62, 0x36, 0x96, 0x51, 0x36, 0xf9, 0xcd, 0x75, 0x7e, 0xf6,
0x46, 0x84, 0x85, 0xa0, 0xfa, 0x9b, 0xe3, 0x32, 0xa3, 0xc5, 0x45, 0x7c, 0x2d, 0xae, 0x85, 0x14,
0xab, 0x6b, 0xa0, 0xae, 0x85, 0x14, 0x8b, 0x6b, 0xd6, 0x09, 0x6c, 0x65, 0xe0, 0x5c, 0xb5, 0x49,
0xfe, 0xd5, 0xa0, 0x6b, 0x13, 0xcf, 0xbb, 0x74, 0x26, 0x6f, 0x4b, 0xd4, 0x26, 0x01, 0x63, 0xe5,
0x7e, 0x18, 0xf5, 0x1c, 0x18, 0x13, 0x4d, 0x56, 0x4d, 0x35, 0x59, 0x0a, 0xe0, 0x5a, 0x31, 0xc0,
0xf5, 0x34, 0xc0, 0x0a, 0xbd, 0xc6, 0x12, 0x3d, 0xeb, 0x5b, 0xd8, 0xbe, 0x93, 0xcf, 0xaa, 0xe0,
0xfc, 0x59, 0x81, 0xad, 0x53, 0x9f, 0x32, 0xc7, 0xf3, 0x32, 0xd8, 0xc4, 0x3d, 0xaa, 0x95, 0xee,
0xd1, 0xca, 0xff, 0xe9, 0x51, 0x3d, 0x05, 0xae, 0xaa, 0x44, 0x35, 0x51, 0x89, 0x52, 0x7d, 0x9b,
0x22, 0xae, 0x7a, 0x86, 0xb8, 0xd0, 0x07, 0x00, 0xa2, 0xd1, 0xb8, 0x71, 0x01, 0x62, 0x8b, 0x9f,
0x9c, 0x4b, 0x4a, 0x50, 0xb8, 0x37, 0xf3, 0x71, 0x4f, 0x74, 0xad, 0x75, 0x0a, 0xdd, 0x2c, 0x54,
0xab, 0xc2, 0xfe, 0xbb, 0x06, 0xdb, 0x17, 0xbe, 0x9b, 0x0b, 0x7c, 0x5e, 0x53, 0xde, 0x81, 0xa2,
0x92, 0x03, 0xc5, 0x26, 0xd4, 0x16, 0x61, 0x70, 0x85, 0x25, 0xb4, 0x62, 0x93, 0xcc, 0xb1, 0x9a,
0xca, 0xd1, 0x1a, 0x83, 0x71, 0x37, 0x86, 0x15, 0x33, 0x8a, 0xa2, 0x8e, 0x1f, 0x9a, 0x96, 0x78,
0x54, 0xac, 0x27, 0xf0, 0xf8, 0x18, 0xb3, 0x37, 0xe2, 0x0f, 0x40, 0xa6, 0x67, 0x0d, 0x01, 0x25,
0x0f, 0x97, 0xfe, 0xe4, 0x51, 0xda, 0x9f, 0x9a, 0xba, 0x94, 0x7e, 0xcc, 0xd9, 0x5f, 0x71, 0xdb,
0x27, 0x2e, 0x65, 0x24, 0xb8, 0xbd, 0x0f, 0xba, 0x0e, 0xe8, 0x73, 0xe7, 0x9d, 0xa4, 0xfc, 0x68,
0x69, 0x1d, 0xf3, 0x08, 0xe2, 0xab, 0x32, 0x82, 0xe4, 0xab, 0xae, 0x95, 0x7b, 0xd5, 0x7f, 0x02,
0xf4, 0x1a, 0xc7, 0x03, 0xc6, 0x03, 0x6f, 0x8f, 0x2a, 0x42, 0x25, 0xdd, 0x68, 0x06, 0x34, 0x26,
0x1e, 0x76, 0xfc, 0x70, 0x21, 0xcb, 0xa6, 0xb6, 0xd6, 0x1e, 0x3c, 0x49, 0x59, 0x97, 0x71, 0x46,
0xf9, 0xd0, 0x2b, 0x69, 0x3d, 0x5a, 0x0e, 0xfe, 0x6e, 0x41, 0x5b, 0x4d, 0x04, 0x62, 0xba, 0x43,
0x2e, 0x6c, 0x24, 0x47, 0x1f, 0xf4, 0xb4, 0x78, 0xf8, 0xcb, 0x4c, 0xb0, 0xe6, 0xb3, 0x32, 0xaa,
0x22, 0x16, 0x6b, 0xed, 0x73, 0x0d, 0x51, 0xe8, 0x64, 0x27, 0x12, 0xf4, 0x22, 0xdf, 0x46, 0xc1,
0x08, 0x64, 0xf6, 0xcb, 0xaa, 0x2b, 0xb7, 0xe8, 0x86, 0x57, 0x3f, 0x3d, 0x46, 0xa0, 0x07, 0xcd,
0xa4, 0x27, 0x17, 0x73, 0xbf, 0xb4, 0x7e, 0xec, 0x97, 0x40, 0x3b, 0x3d, 0x29, 0xa0, 0xe7, 0x0f,
0x19, 0x49, 0x8c, 0x25, 0xe6, 0x67, 0xe5, 0x94, 0x13, 0xe8, 0xfe, 0x02, 0x8f, 0x52, 0xcf, 0x20,
0x2a, 0x28, 0x4f, 0xde, 0xe8, 0x61, 0x3e, 0x2f, 0xa5, 0x1b, 0x27, 0x37, 0x87, 0x76, 0x9a, 0xdf,
0x8a, 0x92, 0xcb, 0x7d, 0x30, 0x8a, 0x92, 0xcb, 0xa7, 0x4c, 0x6b, 0x2d, 0x6a, 0x9c, 0x2c, 0xfd,
0x14, 0x35, 0x4e, 0x01, 0x55, 0x16, 0x35, 0x4e, 0x11, 0xab, 0x59, 0x6b, 0xc8, 0x01, 0x58, 0xb2,
0x0f, 0xda, 0x2b, 0xac, 0x47, 0x9a, 0xb4, 0xcc, 0xde, 0xc3, 0x8a, 0xb1, 0x8b, 0x05, 0xbc, 0x97,
0x79, 0x9e, 0x51, 0x01, 0x34, 0xf9, 0x53, 0x89, 0xf9, 0xa2, 0xa4, 0x76, 0x26, 0x29, 0x49, 0x68,
0xf7, 0x24, 0x95, 0x66, 0xcb, 0x7b, 0x92, 0xca, 0x70, 0xa3, 0xb5, 0x86, 0x5c, 0x68, 0xdb, 0xa1,
0x2f, 0x5d, 0x47, 0xb4, 0x84, 0x0a, 0x6e, 0xdf, 0x25, 0x44, 0xf3, 0x69, 0x09, 0xcd, 0x65, 0xcb,
0x1f, 0xc2, 0x8f, 0x4d, 0xa5, 0x7a, 0x59, 0xe7, 0xff, 0x6d, 0x7f, 0xf9, 0x5f, 0x00, 0x00, 0x00,
0xff, 0xff, 0x33, 0x5c, 0xa4, 0xea, 0x3e, 0x10, 0x00, 0x00,
}

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

@ -48,7 +48,7 @@ func init() { proto.RegisterFile("hapi/version/version.proto", fileDescriptor0)
var fileDescriptor0 = []byte{
// 151 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xca, 0x48, 0x2c, 0xc8,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xca, 0x48, 0x2c, 0xc8,
0xd4, 0x2f, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0x83, 0xd1, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9,
0x42, 0x3c, 0x20, 0x39, 0x3d, 0xa8, 0x98, 0x52, 0x3a, 0x17, 0x7b, 0x18, 0x84, 0x29, 0x24, 0xce,
0xc5, 0x5e, 0x9c, 0x9a, 0x1b, 0x5f, 0x96, 0x5a, 0x24, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0xc4,

Write Preview
Loading…
Cancel
Save