apitech
/
loki
mirror of https://github.com/grafana/loki
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

chore(engine): send structured errors over the wire (#20211)

Browse Source 
Signed-off-by: Robert Fratto <robertfratto@gmail.com>
pull/19939/head^2
Robert Fratto 4 weeks ago committed by GitHub
parent 87f3b590d5
commit 1272bbb384
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 556 additions and 142 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 521
      pkg/engine/internal/proto/wirepb/wirepb.pb.go
  2. 12
      pkg/engine/internal/proto/wirepb/wirepb.proto
  3. 34
      pkg/engine/internal/scheduler/wire/codec.go
  4. 3
      pkg/engine/internal/scheduler/wire/codec_test.go
  5. 37
      pkg/engine/internal/scheduler/wire/error.go
  6. 54
      pkg/engine/internal/scheduler/wire/error_test.go
  7. 2
      pkg/engine/internal/scheduler/wire/frame.go
  8. 17
      pkg/engine/internal/scheduler/wire/peer.go
  9. 18
      pkg/engine/internal/worker/worker.go

521
pkg/engine/internal/proto/wirepb/wirepb.pb.go
Unescape View File

@ -260,7 +260,7 @@ func (m *AckFrame) GetId() uint64 {
type NackFrame struct {
Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
Error *Error `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
}
func (m *NackFrame) Reset() { *m = NackFrame{} }
@ -302,10 +302,63 @@ func (m *NackFrame) GetId() uint64 {
return 0
}
func (m *NackFrame) GetError() string {
func (m *NackFrame) GetError() *Error {
if m != nil {
return m.Error
}
return nil
}
type Error struct {
// The HTTP status code of the error.
Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
// A message describing the error.
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}
func (m *Error) Reset() { *m = Error{} }
func (*Error) ProtoMessage() {}
func (*Error) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{3}
}
func (m *Error) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Error.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Error) XXX_Merge(src proto.Message) {
xxx_messageInfo_Error.Merge(m, src)
}
func (m *Error) XXX_Size() int {
return m.Size()
}
func (m *Error) XXX_DiscardUnknown() {
xxx_messageInfo_Error.DiscardUnknown(m)
}
var xxx_messageInfo_Error proto.InternalMessageInfo
func (m *Error) GetCode() int32 {
if m != nil {
return m.Code
}
return 0
}
func (m *Error) GetMessage() string {
if m != nil {
return m.Message
}
return ""
}
@ -316,7 +369,7 @@ type DiscardFrame struct {
func (m *DiscardFrame) Reset() { *m = DiscardFrame{} }
func (*DiscardFrame) ProtoMessage() {}
func (*DiscardFrame) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{3}
return fileDescriptor_9956cb67d4b0d2a4, []int{4}
}
func (m *DiscardFrame) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -370,7 +423,7 @@ type MessageFrame struct {
func (m *MessageFrame) Reset() { *m = MessageFrame{} }
func (*MessageFrame) ProtoMessage() {}
func (*MessageFrame) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{4}
return fileDescriptor_9956cb67d4b0d2a4, []int{5}
}
func (m *MessageFrame) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -551,7 +604,7 @@ type WorkerHelloMessage struct {
func (m *WorkerHelloMessage) Reset() { *m = WorkerHelloMessage{} }
func (*WorkerHelloMessage) ProtoMessage() {}
func (*WorkerHelloMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{5}
return fileDescriptor_9956cb67d4b0d2a4, []int{6}
}
func (m *WorkerHelloMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -604,7 +657,7 @@ type WorkerReadyMessage struct {
func (m *WorkerReadyMessage) Reset() { *m = WorkerReadyMessage{} }
func (*WorkerReadyMessage) ProtoMessage() {}
func (*WorkerReadyMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{6}
return fileDescriptor_9956cb67d4b0d2a4, []int{7}
}
func (m *WorkerReadyMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -648,7 +701,7 @@ type TaskAssignMessage struct {
func (m *TaskAssignMessage) Reset() { *m = TaskAssignMessage{} }
func (*TaskAssignMessage) ProtoMessage() {}
func (*TaskAssignMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{7}
return fileDescriptor_9956cb67d4b0d2a4, []int{8}
}
func (m *TaskAssignMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -707,7 +760,7 @@ type TaskCancelMessage struct {
func (m *TaskCancelMessage) Reset() { *m = TaskCancelMessage{} }
func (*TaskCancelMessage) ProtoMessage() {}
func (*TaskCancelMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{8}
return fileDescriptor_9956cb67d4b0d2a4, []int{9}
}
func (m *TaskCancelMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -747,7 +800,7 @@ type TaskFlagMessage struct {
func (m *TaskFlagMessage) Reset() { *m = TaskFlagMessage{} }
func (*TaskFlagMessage) ProtoMessage() {}
func (*TaskFlagMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{9}
return fileDescriptor_9956cb67d4b0d2a4, []int{10}
}
func (m *TaskFlagMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -793,7 +846,7 @@ type TaskStatusMessage struct {
func (m *TaskStatusMessage) Reset() { *m = TaskStatusMessage{} }
func (*TaskStatusMessage) ProtoMessage() {}
func (*TaskStatusMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{10}
return fileDescriptor_9956cb67d4b0d2a4, []int{11}
}
func (m *TaskStatusMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -840,7 +893,7 @@ type StreamBindMessage struct {
func (m *StreamBindMessage) Reset() { *m = StreamBindMessage{} }
func (*StreamBindMessage) ProtoMessage() {}
func (*StreamBindMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{11}
return fileDescriptor_9956cb67d4b0d2a4, []int{12}
}
func (m *StreamBindMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -890,7 +943,7 @@ type StreamDataMessage struct {
func (m *StreamDataMessage) Reset() { *m = StreamDataMessage{} }
func (*StreamDataMessage) ProtoMessage() {}
func (*StreamDataMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{12}
return fileDescriptor_9956cb67d4b0d2a4, []int{13}
}
func (m *StreamDataMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -935,7 +988,7 @@ type StreamStatusMessage struct {
func (m *StreamStatusMessage) Reset() { *m = StreamStatusMessage{} }
func (*StreamStatusMessage) ProtoMessage() {}
func (*StreamStatusMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{13}
return fileDescriptor_9956cb67d4b0d2a4, []int{14}
}
func (m *StreamStatusMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -994,7 +1047,7 @@ type Task struct {
func (m *Task) Reset() { *m = Task{} }
func (*Task) ProtoMessage() {}
func (*Task) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{14}
return fileDescriptor_9956cb67d4b0d2a4, []int{15}
}
func (m *Task) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1066,7 +1119,7 @@ type StreamList struct {
func (m *StreamList) Reset() { *m = StreamList{} }
func (*StreamList) ProtoMessage() {}
func (*StreamList) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{15}
return fileDescriptor_9956cb67d4b0d2a4, []int{16}
}
func (m *StreamList) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1111,7 +1164,7 @@ type Stream struct {
func (m *Stream) Reset() { *m = Stream{} }
func (*Stream) ProtoMessage() {}
func (*Stream) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{16}
return fileDescriptor_9956cb67d4b0d2a4, []int{17}
}
func (m *Stream) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1161,7 +1214,7 @@ type TaskStatus struct {
func (m *TaskStatus) Reset() { *m = TaskStatus{} }
func (*TaskStatus) ProtoMessage() {}
func (*TaskStatus) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{17}
return fileDescriptor_9956cb67d4b0d2a4, []int{18}
}
func (m *TaskStatus) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1226,7 +1279,7 @@ type ContributingTimeRange struct {
func (m *ContributingTimeRange) Reset() { *m = ContributingTimeRange{} }
func (*ContributingTimeRange) ProtoMessage() {}
func (*ContributingTimeRange) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{18}
return fileDescriptor_9956cb67d4b0d2a4, []int{19}
}
func (m *ContributingTimeRange) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1276,7 +1329,7 @@ type TaskError struct {
func (m *TaskError) Reset() { *m = TaskError{} }
func (*TaskError) ProtoMessage() {}
func (*TaskError) Descriptor() ([]byte, []int) {
return fileDescriptor_9956cb67d4b0d2a4, []int{19}
return fileDescriptor_9956cb67d4b0d2a4, []int{20}
}
func (m *TaskError) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1318,6 +1371,7 @@ func init() {
proto.RegisterType((*Frame)(nil), "loki.wire.Frame")
proto.RegisterType((*AckFrame)(nil), "loki.wire.AckFrame")
proto.RegisterType((*NackFrame)(nil), "loki.wire.NackFrame")
proto.RegisterType((*Error)(nil), "loki.wire.Error")
proto.RegisterType((*DiscardFrame)(nil), "loki.wire.DiscardFrame")
proto.RegisterType((*MessageFrame)(nil), "loki.wire.MessageFrame")
proto.RegisterType((*WorkerHelloMessage)(nil), "loki.wire.WorkerHelloMessage")
@ -1345,96 +1399,98 @@ func init() {
}
var fileDescriptor_9956cb67d4b0d2a4 = []byte{
// 1414 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4f, 0x6c, 0x1b, 0x45,
0x17, 0xf7, 0x3a, 0x76, 0x62, 0xbf, 0xb8, 0xad, 0x33, 0x4d, 0x5a, 0xcb, 0xdf, 0xf7, 0x6d, 0xa2,
0xfd, 0x90, 0x28, 0x69, 0x6b, 0xb7, 0x8d, 0x40, 0x14, 0xa4, 0x22, 0x3b, 0x76, 0x48, 0x54, 0xd7,
0x09, 0x6b, 0x97, 0x22, 0x2e, 0xd6, 0x78, 0x77, 0xb2, 0x59, 0x79, 0xbd, 0x6b, 0x76, 0xc6, 0x69,
0x23, 0x71, 0xe0, 0xc0, 0x81, 0x63, 0x0f, 0x48, 0x48, 0xdc, 0x91, 0x7a, 0xe1, 0x8a, 0xc4, 0x91,
0x5b, 0x4f, 0xa8, 0xc7, 0x8a, 0x43, 0xa1, 0xe9, 0x85, 0x63, 0x2f, 0xdc, 0xd1, 0xcc, 0xfe, 0xf1,
0x7a, 0xd7, 0x29, 0x12, 0x42, 0x29, 0x97, 0x76, 0xe7, 0xf7, 0x7e, 0xef, 0x37, 0x6f, 0xde, 0xbc,
0x79, 0x33, 0x0e, 0x5c, 0x1d, 0x0d, 0x8c, 0x2a, 0xb1, 0x0d, 0xd3, 0x26, 0x55, 0xd3, 0x66, 0xc4,
0xb5, 0xb1, 0x55, 0x1d, 0xb9, 0x0e, 0x73, 0xaa, 0xf7, 0x4d, 0x97, 0x8c, 0xfa, 0xfe, 0x7f, 0x15,
0x81, 0xa1, 0xbc, 0xe5, 0x0c, 0xcc, 0x0a, 0x87, 0xca, 0xd7, 0x0c, 0x93, 0x1d, 0x8c, 0xfb, 0x15,
0xcd, 0x19, 0x56, 0x0d, 0x17, 0xef, 0x63, 0x1b, 0x57, 0x75, 0x3a, 0x30, 0x59, 0xf5, 0x80, 0xb1,
0x91, 0xe1, 0x8e, 0xb4, 0xf0, 0xc3, 0x73, 0x2e, 0x2f, 0x1b, 0x8e, 0xe1, 0x78, 0xda, 0xfc, 0xcb,
0x47, 0x57, 0x0d, 0xc7, 0x31, 0x2c, 0xe2, 0x4d, 0xda, 0x1f, 0xef, 0x57, 0x99, 0x39, 0x24, 0x94,
0xe1, 0xe1, 0xc8, 0x27, 0xbc, 0x7d, 0x72, 0x88, 0xa3, 0x83, 0x23, 0x6a, 0x6a, 0xd8, 0x1a, 0xf5,
0x23, 0x9f, 0xbe, 0xdb, 0x5b, 0x27, 0xbb, 0x8d, 0x2d, 0x53, 0x17, 0xff, 0x78, 0x54, 0xe5, 0x67,
0x09, 0xb2, 0x5b, 0x2e, 0x1e, 0x12, 0xf4, 0x26, 0xcc, 0x61, 0x6d, 0x50, 0x92, 0xd6, 0xa4, 0x4b,
0x8b, 0x37, 0xce, 0x57, 0xc2, 0xd5, 0x56, 0x6a, 0xda, 0x40, 0x30, 0xb6, 0x53, 0x2a, 0x67, 0xa0,
0x75, 0xc8, 0xd8, 0x9c, 0x99, 0x16, 0xcc, 0xe5, 0x08, 0xb3, 0x8d, 0x27, 0x54, 0xc1, 0x41, 0x1b,
0xb0, 0xa0, 0x9b, 0x54, 0xc3, 0xae, 0x5e, 0x9a, 0x13, 0xf4, 0x8b, 0x11, 0x7a, 0xc3, 0xb3, 0x04,
0x1e, 0x01, 0x93, 0x3b, 0x0d, 0x09, 0xa5, 0xd8, 0x20, 0xa5, 0x4c, 0xc2, 0xe9, 0x8e, 0x67, 0x09,
0x9d, 0x7c, 0x66, 0x7d, 0x1e, 0x32, 0x03, 0xd3, 0xd6, 0x95, 0x32, 0xe4, 0x82, 0x80, 0xd1, 0x59,
0x48, 0x9b, 0xba, 0x58, 0x51, 0x46, 0x4d, 0x9b, 0xba, 0x72, 0x1d, 0xf2, 0x61, 0x88, 0x71, 0x23,
0x5a, 0x86, 0x2c, 0x71, 0x5d, 0xc7, 0x15, 0xeb, 0xca, 0xab, 0xde, 0x40, 0x91, 0xa1, 0x10, 0x0d,
0x33, 0x21, 0xf9, 0x47, 0x06, 0x0a, 0xd1, 0x90, 0x12, 0xb2, 0x75, 0x28, 0xdc, 0x77, 0xdc, 0x01,
0x71, 0x7b, 0x2e, 0xc1, 0xfa, 0x91, 0x9f, 0xb5, 0xff, 0x45, 0x56, 0x74, 0x4f, 0x98, 0x55, 0x6e,
0xf5, 0x95, 0xb6, 0x53, 0xea, 0xe2, 0xfd, 0x09, 0x1a, 0xd1, 0x38, 0x20, 0x96, 0xe5, 0x94, 0xe0,
0x04, 0x8d, 0x6d, 0x6e, 0x4d, 0x68, 0x08, 0x14, 0x7d, 0x00, 0x8b, 0x0c, 0xd3, 0x41, 0x0f, 0x53,
0x6a, 0x1a, 0xb6, 0xbf, 0x1b, 0xff, 0x8d, 0x48, 0x74, 0x31, 0x1d, 0xd4, 0x84, 0x71, 0xa2, 0x00,
0x2c, 0x04, 0x43, 0x01, 0x0d, 0xdb, 0x1a, 0xb1, 0xfc, 0x9d, 0x89, 0x0b, 0x6c, 0x0a, 0x63, 0x4c,
0xc0, 0x03, 0xd1, 0x4d, 0xc8, 0x0b, 0x81, 0x7d, 0x0b, 0x1b, 0xa5, 0xac, 0x70, 0x2f, 0xc7, 0xdc,
0xb7, 0x2c, 0x6c, 0x4c, 0x9c, 0x73, 0xcc, 0x87, 0xc2, 0xb9, 0x29, 0xc3, 0x6c, 0x4c, 0x4b, 0xf3,
0x33, 0xe7, 0xee, 0x08, 0x63, 0x6c, 0x6e, 0x0f, 0xe4, 0x02, 0x94, 0xb9, 0x04, 0x0f, 0x7b, 0x7d,
0xd3, 0xd6, 0x4b, 0x0b, 0x09, 0x81, 0x8e, 0xb0, 0xd6, 0x4d, 0x5b, 0x8f, 0x08, 0xd0, 0x10, 0x8c,
0x08, 0xe8, 0x98, 0xe1, 0x52, 0xee, 0x04, 0x81, 0x06, 0x66, 0x38, 0x21, 0xc0, 0x41, 0xd4, 0x84,
0x33, 0xbe, 0x80, 0xbf, 0x88, 0xbc, 0x90, 0x90, 0x13, 0x12, 0xf1, 0x65, 0x14, 0x68, 0x04, 0x0e,
0xcb, 0xbc, 0x02, 0x28, 0xb9, 0xe7, 0xa8, 0x04, 0x0b, 0xec, 0x80, 0xd7, 0x19, 0xf5, 0x2b, 0x30,
0x18, 0x2a, 0xcb, 0x01, 0x3f, 0x5a, 0x67, 0xca, 0xd7, 0x69, 0x58, 0x4a, 0xec, 0x3b, 0xfa, 0x3f,
0x64, 0x78, 0xea, 0xfc, 0x56, 0x70, 0x2e, 0x96, 0x66, 0x55, 0x18, 0x51, 0x67, 0x6a, 0x3d, 0x84,
0x96, 0xd2, 0x6b, 0x73, 0x97, 0x16, 0x6f, 0x54, 0x5e, 0x55, 0x51, 0x91, 0x15, 0x12, 0xda, 0xb4,
0x99, 0x7b, 0x14, 0x5d, 0x1d, 0xa1, 0xe8, 0x0a, 0xe4, 0x86, 0x84, 0x61, 0x91, 0xe2, 0x39, 0xa1,
0x57, 0xac, 0x84, 0x9d, 0x74, 0x9b, 0x60, 0x9d, 0xb8, 0x6a, 0xc8, 0x28, 0xdf, 0x83, 0xa5, 0x84,
0x20, 0x2a, 0xc2, 0xdc, 0x80, 0x1c, 0x89, 0xd8, 0xf3, 0x2a, 0xff, 0x44, 0x57, 0x20, 0x7b, 0x88,
0xad, 0x31, 0x11, 0x47, 0xef, 0xec, 0x8d, 0x0b, 0x33, 0x33, 0x4e, 0x54, 0x8f, 0xf4, 0x5e, 0xfa,
0x5d, 0x49, 0xf9, 0x52, 0xf2, 0xd2, 0x32, 0x55, 0xcd, 0xc8, 0x09, 0x4f, 0x36, 0xef, 0x48, 0xa2,
0x87, 0x0a, 0xa5, 0xc3, 0xeb, 0x95, 0x3d, 0xde, 0x4b, 0xef, 0xb6, 0x76, 0x1a, 0xf5, 0xad, 0xc7,
0xcf, 0x56, 0x53, 0xbf, 0x3c, 0x5b, 0xbd, 0x35, 0xe3, 0x8a, 0xe0, 0xec, 0xea, 0xe1, 0x46, 0xf5,
0xd5, 0xdd, 0xb9, 0xc2, 0x75, 0x44, 0x6f, 0x79, 0x24, 0xc1, 0xb9, 0xd8, 0xa9, 0x38, 0xf5, 0x20,
0xd0, 0x1b, 0x70, 0x46, 0xd8, 0xdd, 0xf1, 0x88, 0x99, 0x7d, 0xcb, 0xcb, 0x62, 0x4e, 0x9d, 0x06,
0x95, 0x1f, 0xfd, 0x8c, 0x4d, 0x15, 0xef, 0xe9, 0x07, 0xbb, 0x01, 0xf3, 0xfe, 0xe9, 0xf2, 0xda,
0xec, 0xca, 0xcc, 0x16, 0x51, 0xcf, 0xf0, 0x29, 0x55, 0x9f, 0xaa, 0x7c, 0x2f, 0x05, 0x75, 0x14,
0x39, 0xfe, 0xe8, 0x73, 0xc8, 0xfb, 0xf5, 0x7d, 0x7a, 0x4b, 0xc8, 0x79, 0x33, 0xee, 0xe8, 0xa8,
0x0c, 0x39, 0x97, 0x68, 0xc4, 0x3c, 0x24, 0xc1, 0x7d, 0x14, 0x8e, 0x95, 0xef, 0xc2, 0x78, 0x23,
0xdd, 0xe6, 0x35, 0xc7, 0x8b, 0x20, 0x23, 0x0e, 0x2d, 0x8f, 0xb5, 0xa0, 0x8a, 0x6f, 0xe5, 0x27,
0x09, 0xce, 0xcf, 0x68, 0x69, 0xaf, 0x39, 0xd2, 0x2b, 0x90, 0x15, 0x0d, 0xeb, 0xaf, 0xba, 0x81,
0x20, 0x29, 0xdf, 0x64, 0x20, 0xc3, 0x0b, 0x07, 0x51, 0xc8, 0x70, 0xb5, 0xd3, 0x8a, 0x57, 0x4c,
0x86, 0xfe, 0x03, 0x79, 0x46, 0x6c, 0x6c, 0x33, 0x9e, 0x29, 0xbf, 0x0c, 0x3c, 0x60, 0x47, 0x47,
0x55, 0xc8, 0xed, 0xbb, 0xd8, 0x18, 0x12, 0x9b, 0xf9, 0xb7, 0xb9, 0xff, 0x68, 0x0b, 0x9e, 0x83,
0x95, 0x3d, 0x0b, 0xdb, 0x6a, 0x48, 0x42, 0xef, 0xc0, 0x02, 0x75, 0xc6, 0xae, 0x46, 0x68, 0x29,
0x23, 0x7a, 0x6b, 0xfc, 0x02, 0xad, 0x74, 0x3c, 0xb3, 0xd7, 0x99, 0x03, 0x32, 0xba, 0x06, 0x59,
0x6a, 0xda, 0x03, 0x5a, 0xca, 0x0a, 0xaf, 0x72, 0xc2, 0x8b, 0x1b, 0x3d, 0x1f, 0x8f, 0x88, 0x6e,
0xc1, 0xd9, 0x21, 0x7e, 0xd0, 0xe3, 0xaf, 0xd9, 0x9e, 0x8b, 0x6d, 0x83, 0xf8, 0x37, 0x76, 0x29,
0x16, 0x60, 0xd7, 0x1c, 0x12, 0x95, 0xdb, 0xd5, 0xc2, 0x10, 0x3f, 0x08, 0x47, 0xe5, 0x8f, 0xa0,
0x10, 0x0d, 0x65, 0x46, 0x4f, 0xbf, 0x1c, 0xed, 0xe9, 0xd3, 0xe7, 0xdc, 0xdb, 0xc5, 0x96, 0x49,
0x59, 0xa4, 0xa5, 0x97, 0x77, 0x01, 0x26, 0x71, 0xfe, 0x03, 0x82, 0xca, 0x4d, 0x80, 0x89, 0x01,
0x5d, 0x86, 0x05, 0xaf, 0xc2, 0xf8, 0xc5, 0xcb, 0xb3, 0xb4, 0x94, 0x10, 0x50, 0x03, 0x86, 0xf2,
0xad, 0x04, 0xf3, 0x1e, 0xf6, 0xef, 0x2b, 0x2b, 0xe5, 0xa9, 0x04, 0x30, 0x69, 0x95, 0x68, 0x3d,
0x38, 0x2e, 0x92, 0x38, 0x2e, 0xcb, 0x33, 0x1a, 0x6a, 0x70, 0x58, 0x38, 0x77, 0xf2, 0x82, 0x5e,
0x4c, 0x70, 0x9b, 0xdc, 0xe6, 0xbf, 0xab, 0xf9, 0x4b, 0x45, 0xc3, 0x23, 0x36, 0x76, 0x89, 0x28,
0xde, 0x82, 0x1a, 0x0c, 0xd1, 0x27, 0x70, 0x51, 0x73, 0x6c, 0xe6, 0x9a, 0xfd, 0x31, 0x33, 0x6d,
0x23, 0x5a, 0x45, 0xde, 0x9b, 0x73, 0x2d, 0xa2, 0xbb, 0x19, 0x61, 0x4e, 0xaa, 0x69, 0x45, 0x9b,
0x05, 0x2b, 0x0f, 0x60, 0x65, 0x26, 0x1f, 0xd5, 0x21, 0x1f, 0xfe, 0xf2, 0xf2, 0xb7, 0xa2, 0x5c,
0xf1, 0x7e, 0x9b, 0x55, 0x82, 0xdf, 0x66, 0xa2, 0x58, 0x05, 0xa3, 0x9e, 0xe3, 0xbb, 0xf1, 0xf0,
0xd7, 0x55, 0x49, 0x9d, 0xb8, 0xf1, 0xa4, 0x5a, 0x84, 0xd2, 0x1e, 0x3b, 0xc0, 0xb6, 0x7f, 0x47,
0xe6, 0x38, 0xd0, 0x3d, 0xc0, 0xb6, 0x72, 0x15, 0xf2, 0x61, 0x06, 0xd0, 0x1a, 0x2c, 0xea, 0x84,
0x6a, 0xae, 0x39, 0x62, 0xa6, 0x63, 0xfb, 0x45, 0x18, 0x85, 0xd6, 0x7f, 0x90, 0x3c, 0xbe, 0xc8,
0x2e, 0xba, 0x00, 0xa8, 0x5b, 0xeb, 0xdc, 0xee, 0x75, 0xba, 0xb5, 0x6e, 0xb3, 0xb7, 0xd3, 0xfe,
0xb8, 0xd6, 0xda, 0x69, 0x14, 0x53, 0x31, 0x7c, 0x53, 0x6d, 0xd6, 0xba, 0xcd, 0x46, 0x51, 0x8a,
0xe1, 0x7b, 0xcd, 0x76, 0x63, 0xa7, 0xfd, 0x61, 0x31, 0x1d, 0xc3, 0xd5, 0xbb, 0xed, 0x36, 0xc7,
0xe7, 0x50, 0x09, 0x96, 0xa3, 0x3a, 0xbb, 0x77, 0xf6, 0x5a, 0x4d, 0xae, 0x94, 0x89, 0x5b, 0x6a,
0xed, 0xcd, 0x66, 0xab, 0xd5, 0x6c, 0x14, 0xb3, 0x68, 0x05, 0x96, 0x22, 0x96, 0xad, 0xda, 0x0e,
0x87, 0xe7, 0xd7, 0xbf, 0x92, 0x60, 0x31, 0xd2, 0x45, 0xb9, 0x40, 0xa7, 0xab, 0x36, 0x6b, 0x77,
0x12, 0xc1, 0xaf, 0xc0, 0xd2, 0xb4, 0xa5, 0xd1, 0x6a, 0x16, 0xa5, 0x04, 0xbc, 0xbb, 0xd7, 0x6c,
0x17, 0xd3, 0x09, 0x9d, 0x7a, 0x6b, 0x77, 0xf3, 0x76, 0xb3, 0x51, 0x9c, 0x43, 0x17, 0xe1, 0xfc,
0x94, 0x65, 0xb3, 0xb5, 0xdb, 0xe1, 0xb1, 0xd7, 0x3f, 0x7b, 0xf2, 0x5c, 0x4e, 0x3d, 0x7d, 0x2e,
0xa7, 0x5e, 0x3e, 0x97, 0xa5, 0x2f, 0x8e, 0x65, 0xe9, 0xd1, 0xb1, 0x2c, 0x3d, 0x3e, 0x96, 0xa5,
0x27, 0xc7, 0xb2, 0xf4, 0xdb, 0xb1, 0x2c, 0xfd, 0x7e, 0x2c, 0xa7, 0x5e, 0x1e, 0xcb, 0xd2, 0xc3,
0x17, 0x72, 0xea, 0xc9, 0x0b, 0x39, 0xf5, 0xf4, 0x85, 0x9c, 0xfa, 0xf4, 0xfd, 0xbf, 0x75, 0xc0,
0xbc, 0xbf, 0x13, 0xf4, 0xe7, 0xc5, 0x68, 0xe3, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x73, 0x1e,
0x81, 0x2c, 0x59, 0x10, 0x00, 0x00,
// 1444 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x41, 0x6c, 0x1b, 0x45,
0x14, 0xf5, 0xda, 0xeb, 0xc4, 0xfe, 0x71, 0x5b, 0x67, 0x9a, 0xb4, 0x96, 0x81, 0x4d, 0xb4, 0x20,
0x28, 0x69, 0x6b, 0x97, 0x46, 0x45, 0x14, 0xa4, 0x22, 0x3b, 0x76, 0x88, 0xa9, 0xeb, 0x84, 0xb5,
0x4b, 0x11, 0x17, 0x6b, 0xbc, 0x3b, 0xd9, 0xac, 0x6c, 0xef, 0x9a, 0xdd, 0x71, 0xda, 0x48, 0x1c,
0x38, 0x70, 0xe0, 0xd8, 0x03, 0x12, 0x12, 0x77, 0xa4, 0x5e, 0xb8, 0x22, 0x71, 0xe4, 0xd6, 0x13,
0xea, 0xb1, 0xe2, 0x50, 0x68, 0x7a, 0xe1, 0xd8, 0x0b, 0x77, 0x34, 0xb3, 0xeb, 0xf5, 0x64, 0xd7,
0x29, 0x12, 0x42, 0x29, 0x97, 0x64, 0xf7, 0xfd, 0xf7, 0xdf, 0xfc, 0xf9, 0xf3, 0xe7, 0xcf, 0xac,
0xe1, 0xf2, 0xa8, 0x6f, 0x96, 0x89, 0x6d, 0x5a, 0x36, 0x29, 0x5b, 0x36, 0x25, 0xae, 0x8d, 0x07,
0xe5, 0x91, 0xeb, 0x50, 0xa7, 0x7c, 0xd7, 0x72, 0xc9, 0xa8, 0x17, 0xfc, 0x2b, 0x71, 0x0c, 0x65,
0x07, 0x4e, 0xdf, 0x2a, 0x31, 0xa8, 0x78, 0xc5, 0xb4, 0xe8, 0xde, 0xb8, 0x57, 0xd2, 0x9d, 0x61,
0xd9, 0x74, 0xf1, 0x2e, 0xb6, 0x71, 0xd9, 0xf0, 0xfa, 0x16, 0x2d, 0xef, 0x51, 0x3a, 0x32, 0xdd,
0x91, 0x1e, 0x3e, 0xf8, 0xce, 0xc5, 0x25, 0xd3, 0x31, 0x1d, 0x5f, 0x9b, 0x3d, 0x05, 0xe8, 0x8a,
0xe9, 0x38, 0xe6, 0x80, 0xf8, 0x83, 0xf6, 0xc6, 0xbb, 0x65, 0x6a, 0x0d, 0x89, 0x47, 0xf1, 0x70,
0x14, 0x10, 0xae, 0x1d, 0x1f, 0xe2, 0x68, 0xef, 0xc0, 0xb3, 0x74, 0x3c, 0x18, 0xf5, 0x84, 0xc7,
0xc0, 0xed, 0xed, 0xe3, 0xdd, 0xc6, 0x03, 0xcb, 0xe0, 0x7f, 0x7c, 0xaa, 0xfa, 0xab, 0x04, 0xe9,
0x4d, 0x17, 0x0f, 0x09, 0x7a, 0x0b, 0x52, 0x58, 0xef, 0x17, 0xa4, 0x55, 0xe9, 0xc2, 0xc2, 0xd5,
0xb3, 0xa5, 0x70, 0xb6, 0xa5, 0x8a, 0xde, 0xe7, 0x8c, 0xad, 0x84, 0xc6, 0x18, 0x68, 0x0d, 0x64,
0x9b, 0x31, 0x93, 0x9c, 0xb9, 0x24, 0x30, 0x5b, 0x78, 0x4a, 0xe5, 0x1c, 0xb4, 0x0e, 0xf3, 0x86,
0xe5, 0xe9, 0xd8, 0x35, 0x0a, 0x29, 0x4e, 0x3f, 0x2f, 0xd0, 0x6b, 0xbe, 0x65, 0xe2, 0x31, 0x61,
0x32, 0xa7, 0x21, 0xf1, 0x3c, 0x6c, 0x92, 0x82, 0x1c, 0x73, 0xba, 0xe5, 0x5b, 0x42, 0xa7, 0x80,
0x59, 0x9d, 0x03, 0xb9, 0x6f, 0xd9, 0x86, 0x5a, 0x84, 0xcc, 0x24, 0x60, 0x74, 0x1a, 0x92, 0x96,
0xc1, 0x67, 0x24, 0x6b, 0x49, 0xcb, 0x50, 0x1b, 0x90, 0x0d, 0x43, 0x8c, 0x1a, 0xd1, 0x9b, 0x90,
0x26, 0xae, 0xeb, 0xb8, 0x41, 0xa0, 0x79, 0x61, 0xcc, 0x3a, 0xc3, 0x35, 0xdf, 0xfc, 0xb1, 0x9c,
0x49, 0xe6, 0x53, 0xea, 0x35, 0x48, 0x73, 0x14, 0x21, 0x90, 0x75, 0xc7, 0x20, 0x5c, 0x28, 0xad,
0xf1, 0x67, 0x54, 0x98, 0x4e, 0x80, 0x25, 0x29, 0x1b, 0x46, 0xa9, 0x2a, 0x90, 0x13, 0x67, 0x1d,
0x8b, 0xf0, 0x2f, 0x19, 0x72, 0xe2, 0x0c, 0x63, 0x51, 0x56, 0x21, 0x77, 0xd7, 0x71, 0xfb, 0xc4,
0xed, 0xba, 0x04, 0x1b, 0x07, 0xc1, 0x22, 0xbc, 0x26, 0x04, 0x7b, 0x87, 0x9b, 0x35, 0x66, 0x0d,
0x94, 0xb6, 0x12, 0xda, 0xc2, 0xdd, 0x29, 0x2a, 0x68, 0xec, 0x91, 0xc1, 0xc0, 0x29, 0xc0, 0x31,
0x1a, 0x5b, 0xcc, 0x1a, 0xd3, 0xe0, 0x28, 0xfa, 0x10, 0x16, 0x28, 0xf6, 0xfa, 0x5d, 0xec, 0x79,
0x96, 0x69, 0x07, 0x39, 0x7b, 0x55, 0x90, 0xe8, 0x60, 0xaf, 0x5f, 0xe1, 0xc6, 0xa9, 0x02, 0xd0,
0x10, 0x0c, 0x05, 0x74, 0x6c, 0xeb, 0x64, 0x10, 0x2c, 0x74, 0x54, 0x60, 0x83, 0x1b, 0x23, 0x02,
0x3e, 0x88, 0xae, 0x43, 0x96, 0x0b, 0xec, 0x0e, 0xb0, 0x59, 0x48, 0x73, 0xf7, 0x62, 0xc4, 0x7d,
0x73, 0x80, 0xcd, 0xa9, 0x73, 0x86, 0x06, 0x50, 0x38, 0xb6, 0x47, 0x31, 0x1d, 0x7b, 0x85, 0xb9,
0x99, 0x63, 0xb7, 0xb9, 0x31, 0x32, 0xb6, 0x0f, 0x32, 0x01, 0x8f, 0xba, 0x04, 0x0f, 0xbb, 0x3d,
0xcb, 0x36, 0x0a, 0xf3, 0x31, 0x81, 0x36, 0xb7, 0x56, 0x2d, 0xdb, 0x10, 0x04, 0xbc, 0x10, 0x14,
0x04, 0x0c, 0x4c, 0x71, 0x21, 0x73, 0x8c, 0x40, 0x0d, 0x53, 0x1c, 0x13, 0x60, 0x20, 0xaa, 0xc3,
0xa9, 0x40, 0x20, 0x98, 0x44, 0x96, 0x4b, 0x28, 0x31, 0x89, 0xe8, 0x34, 0x72, 0x9e, 0x00, 0x87,
0xbb, 0xa6, 0x04, 0x28, 0xbe, 0xe6, 0xac, 0x8e, 0xe9, 0x1e, 0xab, 0x33, 0x2f, 0xa8, 0xc0, 0xc9,
0xab, 0xba, 0x34, 0xe1, 0x8b, 0x75, 0xa6, 0x7e, 0x9b, 0x84, 0xc5, 0xd8, 0xba, 0xa3, 0xd7, 0x41,
0x66, 0xa9, 0x0b, 0x3a, 0xcb, 0x99, 0x48, 0x9a, 0x35, 0x6e, 0x44, 0xed, 0x23, 0xf3, 0x21, 0x5e,
0x21, 0xb9, 0x9a, 0xba, 0xb0, 0x70, 0xb5, 0xf4, 0xa2, 0x8a, 0x12, 0x66, 0x48, 0xbc, 0xba, 0x4d,
0xdd, 0x03, 0x71, 0x76, 0xc4, 0x43, 0x97, 0x20, 0x33, 0x24, 0x14, 0xf3, 0x14, 0xa7, 0xb8, 0x5e,
0xbe, 0x14, 0x36, 0xe6, 0x2d, 0x82, 0x0d, 0xe2, 0x6a, 0x21, 0xa3, 0x78, 0x07, 0x16, 0x63, 0x82,
0x28, 0x0f, 0xa9, 0x3e, 0x39, 0xe0, 0xb1, 0x67, 0x35, 0xf6, 0x88, 0x2e, 0x41, 0x7a, 0x1f, 0x0f,
0xc6, 0xfe, 0xd6, 0x3e, 0x7d, 0xf5, 0xdc, 0xcc, 0x8c, 0x13, 0xcd, 0x27, 0xbd, 0x9f, 0x7c, 0x4f,
0x52, 0xbf, 0x96, 0xfc, 0xb4, 0x1c, 0xa9, 0x66, 0xe4, 0x84, 0x3b, 0x9b, 0x35, 0x38, 0xde, 0x92,
0xb9, 0xd2, 0xfe, 0x3b, 0xa5, 0x1d, 0xd6, 0x9a, 0x6f, 0x37, 0x1b, 0xb5, 0xea, 0xe6, 0xc3, 0x27,
0x2b, 0x89, 0xdf, 0x9e, 0xac, 0xdc, 0x98, 0x71, 0xe2, 0x30, 0x76, 0x79, 0x7f, 0xbd, 0xfc, 0xe2,
0x66, 0x5f, 0x62, 0x3a, 0xbc, 0xb7, 0x3c, 0x90, 0xe0, 0x4c, 0x64, 0x57, 0x9c, 0x78, 0x10, 0xe8,
0x0d, 0x38, 0xc5, 0xed, 0xee, 0x78, 0x44, 0xad, 0xde, 0xc0, 0xcf, 0x62, 0x46, 0x3b, 0x0a, 0xaa,
0x3f, 0x07, 0x19, 0x3b, 0x52, 0xbc, 0x27, 0x1f, 0xec, 0x3a, 0xcc, 0x05, 0xbb, 0xcb, 0x6f, 0xb3,
0xcb, 0x33, 0x5b, 0x44, 0x55, 0x66, 0x43, 0x6a, 0x01, 0x55, 0xfd, 0x51, 0x9a, 0xd4, 0x91, 0xb0,
0xfd, 0xd1, 0x97, 0x90, 0x0d, 0xea, 0xfb, 0xe4, 0xa6, 0x90, 0xf1, 0x47, 0x6c, 0x18, 0xa8, 0x08,
0x19, 0x97, 0xe8, 0xc4, 0xda, 0x27, 0x6e, 0x70, 0x22, 0x85, 0xef, 0xea, 0x0f, 0x61, 0xbc, 0x42,
0xb7, 0x79, 0xc9, 0xf1, 0x22, 0x90, 0xf9, 0xa6, 0x65, 0xb1, 0xe6, 0x34, 0xfe, 0xac, 0xfe, 0x22,
0xc1, 0xd9, 0x19, 0x2d, 0xed, 0x25, 0x47, 0x7a, 0x09, 0xd2, 0xbc, 0x61, 0xfd, 0x53, 0x37, 0xe0,
0x24, 0xf5, 0x3b, 0x19, 0x64, 0x56, 0x38, 0xc8, 0x03, 0x99, 0xa9, 0x9d, 0x54, 0xbc, 0x7c, 0x30,
0xf4, 0x0a, 0x64, 0x29, 0xb1, 0xb1, 0x4d, 0x59, 0xa6, 0x82, 0x32, 0xf0, 0x81, 0x86, 0x81, 0xca,
0x90, 0xd9, 0x75, 0xb1, 0x39, 0x24, 0x36, 0x0d, 0x4e, 0xf3, 0xe0, 0x0e, 0x38, 0xb9, 0x5d, 0x96,
0x76, 0x06, 0xd8, 0xd6, 0x42, 0x12, 0x7a, 0x17, 0xe6, 0x3d, 0x67, 0xec, 0xea, 0xc4, 0x2b, 0xc8,
0xbc, 0xb7, 0x46, 0x0f, 0xd0, 0x52, 0xdb, 0x37, 0xfb, 0x9d, 0x79, 0x42, 0x46, 0x57, 0x20, 0xed,
0x59, 0x76, 0xdf, 0x2b, 0xa4, 0xb9, 0x57, 0x31, 0xe6, 0xc5, 0x8c, 0xbe, 0x8f, 0x4f, 0x44, 0x37,
0xe0, 0xf4, 0x10, 0xdf, 0xeb, 0xb2, 0xcb, 0x71, 0xd7, 0xc5, 0xb6, 0x49, 0x82, 0x13, 0xbb, 0x10,
0x09, 0xb0, 0x63, 0x0d, 0x89, 0xc6, 0xec, 0x5a, 0x6e, 0x88, 0xef, 0x85, 0x6f, 0xc5, 0x4f, 0x20,
0x27, 0x86, 0x32, 0xa3, 0xa7, 0x5f, 0x14, 0x7b, 0xfa, 0xd1, 0x7d, 0xee, 0xaf, 0x62, 0xd3, 0xf2,
0xa8, 0xd0, 0xd2, 0x8b, 0xdb, 0x00, 0xd3, 0x38, 0xff, 0x03, 0x41, 0xf5, 0x3a, 0xc0, 0xd4, 0x80,
0x2e, 0xc2, 0xbc, 0x5f, 0x61, 0xec, 0xe0, 0x65, 0x59, 0x5a, 0x8c, 0x09, 0x68, 0x13, 0x86, 0xfa,
0xbd, 0x04, 0x73, 0x3e, 0xf6, 0xff, 0x2b, 0x2b, 0xf5, 0xb1, 0x04, 0x30, 0x6d, 0x95, 0x68, 0x6d,
0xb2, 0x5d, 0x24, 0xbe, 0x5d, 0x96, 0x66, 0x34, 0xd4, 0xc9, 0x66, 0x61, 0x5c, 0xff, 0x42, 0x1e,
0xff, 0xd0, 0x60, 0x5c, 0xf1, 0x52, 0xce, 0x6e, 0x2a, 0x3a, 0x1e, 0xd1, 0xb1, 0x4b, 0x78, 0xf1,
0xe6, 0xb4, 0xc9, 0x2b, 0xfa, 0x0c, 0xce, 0xeb, 0x8e, 0x4d, 0x5d, 0xab, 0x37, 0xa6, 0x96, 0x6d,
0x8a, 0x55, 0xe4, 0xdf, 0x39, 0x57, 0x05, 0xdd, 0x0d, 0x81, 0x39, 0xad, 0xa6, 0x65, 0x7d, 0x16,
0xac, 0xde, 0x83, 0xe5, 0x99, 0x7c, 0x54, 0x85, 0x6c, 0xf8, 0x21, 0x17, 0x2c, 0x45, 0xb1, 0xe4,
0x7f, 0xea, 0x95, 0x26, 0x9f, 0x7a, 0xbc, 0x58, 0x39, 0xa3, 0x9a, 0x61, 0xab, 0x71, 0xff, 0xf7,
0x15, 0x49, 0x9b, 0xba, 0xb1, 0xa4, 0x0e, 0x88, 0xe7, 0x75, 0xe9, 0x1e, 0xb6, 0x83, 0x33, 0x32,
0xc3, 0x80, 0xce, 0x1e, 0xb6, 0xd5, 0xcb, 0x90, 0x0d, 0x33, 0x80, 0x56, 0x61, 0xc1, 0x20, 0x9e,
0xee, 0x5a, 0x23, 0x6a, 0x39, 0x76, 0x50, 0x84, 0x22, 0xb4, 0xf6, 0x93, 0xe4, 0xf3, 0x79, 0x76,
0xd1, 0x39, 0x40, 0x9d, 0x4a, 0xfb, 0x66, 0xb7, 0xdd, 0xa9, 0x74, 0xea, 0xdd, 0x46, 0xeb, 0xd3,
0x4a, 0xb3, 0x51, 0xcb, 0x27, 0x22, 0xf8, 0x86, 0x56, 0xaf, 0x74, 0xea, 0xb5, 0xbc, 0x14, 0xc1,
0x77, 0xea, 0xad, 0x5a, 0xa3, 0xf5, 0x51, 0x3e, 0x19, 0xc1, 0xb5, 0xdb, 0xad, 0x16, 0xc3, 0x53,
0xa8, 0x00, 0x4b, 0xa2, 0xce, 0xf6, 0xad, 0x9d, 0x66, 0x9d, 0x29, 0xc9, 0x51, 0x4b, 0xa5, 0xb5,
0x51, 0x6f, 0x36, 0xeb, 0xb5, 0x7c, 0x1a, 0x2d, 0xc3, 0xa2, 0x60, 0xd9, 0xac, 0x34, 0x18, 0x3c,
0xb7, 0xf6, 0x8d, 0x04, 0x0b, 0x42, 0x17, 0x65, 0x02, 0xed, 0x8e, 0x56, 0xaf, 0xdc, 0x8a, 0x05,
0xbf, 0x0c, 0x8b, 0x47, 0x2d, 0xb5, 0x66, 0x3d, 0x2f, 0xc5, 0xe0, 0xed, 0x9d, 0x7a, 0x2b, 0x9f,
0x8c, 0xe9, 0x54, 0x9b, 0xdb, 0x1b, 0x37, 0xeb, 0xb5, 0x7c, 0x0a, 0x9d, 0x87, 0xb3, 0x47, 0x2c,
0x1b, 0xcd, 0xed, 0x36, 0x8b, 0xbd, 0xfa, 0xc5, 0xa3, 0xa7, 0x4a, 0xe2, 0xf1, 0x53, 0x25, 0xf1,
0xfc, 0xa9, 0x22, 0x7d, 0x75, 0xa8, 0x48, 0x0f, 0x0e, 0x15, 0xe9, 0xe1, 0xa1, 0x22, 0x3d, 0x3a,
0x54, 0xa4, 0x3f, 0x0e, 0x15, 0xe9, 0xcf, 0x43, 0x25, 0xf1, 0xfc, 0x50, 0x91, 0xee, 0x3f, 0x53,
0x12, 0x8f, 0x9e, 0x29, 0x89, 0xc7, 0xcf, 0x94, 0xc4, 0xe7, 0x1f, 0xfc, 0xab, 0x0d, 0xe6, 0xff,
0xec, 0xd0, 0x9b, 0xe3, 0x6f, 0xeb, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x7f, 0xfd, 0x59, 0x2d,
0xa8, 0x10, 0x00, 0x00,
}
func (x TaskState) String() string {
@ -1623,7 +1679,34 @@ func (this *NackFrame) Equal(that interface{}) bool {
if this.Id != that1.Id {
return false
}
if this.Error != that1.Error {
if !this.Error.Equal(that1.Error) {
return false
}
return true
}
func (this *Error) Equal(that interface{}) bool {
if that == nil {
return this == nil
}
that1, ok := that.(*Error)
if !ok {
that2, ok := that.(Error)
if ok {
that1 = &that2
} else {
return false
}
}
if that1 == nil {
return this == nil
} else if this == nil {
return false
}
if this.Code != that1.Code {
return false
}
if this.Message != that1.Message {
return false
}
return true
@ -2395,7 +2478,20 @@ func (this *NackFrame) GoString() string {
s := make([]string, 0, 6)
s = append(s, "&wirepb.NackFrame{")
s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
if this.Error != nil {
s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Error) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 6)
s = append(s, "&wirepb.Error{")
s = append(s, "Code: "+fmt.Sprintf("%#v", this.Code)+",\n")
s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
s = append(s, "}")
return strings.Join(s, "")
}
@ -2878,12 +2974,17 @@ func (m *NackFrame) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.Error) > 0 {
i -= len(m.Error)
copy(dAtA[i:], m.Error)
i = encodeVarintWirepb(dAtA, i, uint64(len(m.Error)))
if m.Error != nil {
{
size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintWirepb(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
dAtA[i] = 0x1a
}
if m.Id != 0 {
i = encodeVarintWirepb(dAtA, i, uint64(m.Id))
@ -2893,6 +2994,41 @@ func (m *NackFrame) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Error) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Error) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Error) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Message) > 0 {
i -= len(m.Message)
copy(dAtA[i:], m.Message)
i = encodeVarintWirepb(dAtA, i, uint64(len(m.Message)))
i--
dAtA[i] = 0x12
}
if m.Code != 0 {
i = encodeVarintWirepb(dAtA, i, uint64(m.Code))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *DiscardFrame) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -3774,12 +3910,12 @@ func (m *ContributingTimeRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x10
}
n30, err30 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
if err30 != nil {
return 0, err30
n31, err31 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
if err31 != nil {
return 0, err31
}
i -= n30
i = encodeVarintWirepb(dAtA, i, uint64(n30))
i -= n31
i = encodeVarintWirepb(dAtA, i, uint64(n31))
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
@ -3907,7 +4043,23 @@ func (m *NackFrame) Size() (n int) {
if m.Id != 0 {
n += 1 + sovWirepb(uint64(m.Id))
}
l = len(m.Error)
if m.Error != nil {
l = m.Error.Size()
n += 1 + l + sovWirepb(uint64(l))
}
return n
}
func (m *Error) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Code != 0 {
n += 1 + sovWirepb(uint64(m.Code))
}
l = len(m.Message)
if l > 0 {
n += 1 + l + sovWirepb(uint64(l))
}
@ -4381,7 +4533,18 @@ func (this *NackFrame) String() string {
}
s := strings.Join([]string{`&NackFrame{`,
`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
`Error:` + fmt.Sprintf("%v", this.Error) + `,`,
`Error:` + strings.Replace(this.Error.String(), "Error", "Error", 1) + `,`,
`}`,
}, "")
return s
}
func (this *Error) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Error{`,
`Code:` + fmt.Sprintf("%v", this.Code) + `,`,
`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
`}`,
}, "")
return s
@ -5024,10 +5187,118 @@ func (m *NackFrame) Unmarshal(dAtA []byte) error {
break
}
}
case 2:
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowWirepb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthWirepb
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthWirepb
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Error == nil {
m.Error = &Error{}
}
if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipWirepb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthWirepb
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthWirepb
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Error) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowWirepb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Error: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
}
m.Code = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowWirepb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Code |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
@ -5054,7 +5325,7 @@ func (m *NackFrame) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Error = string(dAtA[iNdEx:postIndex])
m.Message = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex

12
pkg/engine/internal/proto/wirepb/wirepb.proto
Unescape View File

@ -26,8 +26,18 @@ message AckFrame {
}
message NackFrame {
reserved 2; // Previously error message, now used in 3.
uint64 id = 1;
string error = 2;
Error error = 3;
}
message Error {
// The HTTP status code of the error.
int32 code = 1;
// A message describing the error.
string message = 2;
}
message DiscardFrame {

34
pkg/engine/internal/scheduler/wire/codec.go
Unescape View File

@ -131,13 +131,9 @@ func (c *protobufCodec) frameFromPbFrame(f *wirepb.Frame) (Frame, error) {
return AckFrame{ID: k.Ack.Id}, nil
case *wirepb.Frame_Nack:
var err error
if k.Nack.Error != "" {
err = errors.New(k.Nack.Error)
}
return NackFrame{
ID: k.Nack.Id,
Error: err,
Error: c.errorFromPb(k.Nack.Error),
}, nil
case *wirepb.Frame_Discard:
@ -158,6 +154,17 @@ func (c *protobufCodec) frameFromPbFrame(f *wirepb.Frame) (Frame, error) {
}
}
func (c *protobufCodec) errorFromPb(errPb *wirepb.Error) *Error {
if errPb == nil {
return nil
}
return &Error{
Code: errPb.Code,
Message: errPb.Message,
}
}
func (c *protobufCodec) messageFromPbMessage(mf *wirepb.MessageFrame) (Message, error) {
if mf == nil {
return nil, errors.New("nil message frame")
@ -410,14 +417,10 @@ func (c *protobufCodec) frameToPbFrame(from Frame) (*wirepb.Frame, error) {
}
case NackFrame:
var errStr string
if v.Error != nil {
errStr = v.Error.Error()
}
f.Kind = &wirepb.Frame_Nack{
Nack: &wirepb.NackFrame{
Id: v.ID,
Error: errStr,
Error: c.errorToPb(v.Error),
},
}
@ -441,6 +444,17 @@ func (c *protobufCodec) frameToPbFrame(from Frame) (*wirepb.Frame, error) {
return f, nil
}
func (c *protobufCodec) errorToPb(e *Error) *wirepb.Error {
if e == nil {
return nil
}
return &wirepb.Error{
Code: e.Code,
Message: e.Message,
}
}
func (c *protobufCodec) messageToPbMessage(from Message) (*wirepb.MessageFrame, error) {
if from == nil {
return nil, errors.New("nil message")

3
pkg/engine/internal/scheduler/wire/codec_test.go
Unescape View File

@ -3,6 +3,7 @@ package wire
import (
"errors"
"net"
"net/http"
"net/netip"
"testing"
"time"
@ -31,7 +32,7 @@ func TestProtobufCodec_Frames(t *testing.T) {
"NackFrame with error": {
frame: NackFrame{
ID: 44,
Error: errors.New("test error"),
Error: Errorf(http.StatusInternalServerError, "test error"),
},
},
"DiscardFrame": {

37
pkg/engine/internal/scheduler/wire/error.go
Unescape View File

@ -0,0 +1,37 @@
package wire
import (
"fmt"
)
// Error represents an error received in response to a message.
type Error struct {
// Code is an HTTP status code representing the kind of error received.
Code int32
// Message is a human-readable description of the error.
Message string
}
var _ error = (*Error)(nil)
// Errorf creates a new Error with the given code and formatted message.
func Errorf(code int32, format string, args ...interface{}) *Error {
return &Error{
Code: code,
Message: fmt.Sprintf(format, args...),
}
}
// Is returns true if the target is identical to the error, providing
// functionality for [errors.Is].
func (e *Error) Is(target error) bool {
other, ok := target.(*Error)
if !ok {
return false
}
return other.Code == e.Code && other.Message == e.Message
}
// Error returns the message of the error.
func (e *Error) Error() string { return e.Message }

54
pkg/engine/internal/scheduler/wire/error_test.go
Unescape View File

@ -0,0 +1,54 @@
package wire
import (
"errors"
"fmt"
"testing"
"github.com/stretchr/testify/require"
)
func TestError_Is(t *testing.T) {
tt := []struct {
name string
left error
right error
expect bool
}{
{
name: "same code and message",
left: Errorf(100, "hello, world"),
right: Errorf(100, "hello, world"),
expect: true,
},
{
// NOTE(rfratto): errors.Is will only unwrap the left-hand side of
// the operation.
name: "same code and message (wrapped)",
left: fmt.Errorf("wrapped: %w", Errorf(100, "hello, world")),
right: Errorf(100, "hello, world"),
expect: true,
},
{
name: "different code, same message",
left: Errorf(100, "hello, world"),
right: Errorf(200, "hello, world"),
expect: false,
},
{
name: "different code, different message",
left: Errorf(100, "hello, world"),
right: Errorf(200, "goodbye, world"),
expect: false,
},
}
for _, tc := range tt {
t.Run(tc.name, func(t *testing.T) {
require.Equal(t, tc.expect, errors.Is(tc.left, tc.right), "expected errors.Is to return %t", tc.expect)
})
}
}

2
pkg/engine/internal/scheduler/wire/frame.go
Unescape View File

@ -72,7 +72,7 @@ type NackFrame struct {
ID uint64
// Error is the error that occurred.
Error error
Error *Error
}
// FrameKind returns [FrameKindNack].

17
pkg/engine/internal/scheduler/wire/peer.go
Unescape View File

@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"net"
"net/http"
"reflect"
"sync"
@ -186,7 +187,7 @@ func (p *Peer) notifyError(frame Frame, err error) {
// processMessage handles a message received from the peer.
func (p *Peer) processMessage(ctx context.Context, id uint64, message Message) {
if p.Handler == nil {
_ = p.enqueueFrame(ctx, NackFrame{ID: id, Error: errors.New("not implemented")})
_ = p.enqueueFrame(ctx, NackFrame{ID: id, Error: Errorf(http.StatusNotImplemented, "not implemented")})
return
}
@ -196,7 +197,19 @@ func (p *Peer) processMessage(ctx context.Context, id uint64, message Message) {
_ = p.enqueueFrame(ctx, AckFrame{ID: id})
default:
// TODO(rfratto): What should we do if this fails? Logs? Metrics?
_ = p.enqueueFrame(ctx, NackFrame{ID: id, Error: err})
_ = p.enqueueFrame(ctx, NackFrame{ID: id, Error: convertError(err)})
}
}
func convertError(err error) *Error {
var wireError *Error
if errors.As(err, &wireError) {
return wireError
}
return &Error{
Code: http.StatusInternalServerError,
Message: err.Error(),
}
}

18
pkg/engine/internal/worker/worker.go
Unescape View File

@ -7,6 +7,7 @@ import (
"errors"
"fmt"
"net"
"net/http"
"reflect"
"runtime"
"sync"
@ -302,11 +303,24 @@ func (w *Worker) handleSchedulerConn(ctx context.Context, logger log.Logger, con
}
}
handleAssignment := func(peer *wire.Peer, msg wire.TaskAssignMessage) error {
popRequest := func() (readyRequest, error) {
reqsMut.Lock()
defer reqsMut.Unlock()
if len(readyReqs) == 0 {
return readyRequest{}, wire.Errorf(http.StatusTooManyRequests, "no threads available")
}
req := readyReqs[0]
readyReqs = readyReqs[1:]
reqsMut.Unlock()
return req, nil
}
handleAssignment := func(peer *wire.Peer, msg wire.TaskAssignMessage) error {
req, err := popRequest()
if err != nil {
return err
}
job, err := w.newJob(req.Context, peer, logger, msg)
if err != nil {

Write Preview
Loading…
Cancel
Save