From faab75968b7cf66e824e95506f439c1301c10365 Mon Sep 17 00:00:00 2001 From: jlapacik Date: Thu, 2 May 2019 17:28:21 -0700 Subject: [PATCH] refactor(storage): remove Read method from Store interface --- query/stdlib/influxdata/influxdb/storage.go | 119 +--- storage/reads/datatypes/storage_common.pb.go | 646 +++++-------------- storage/reads/datatypes/storage_common.proto | 25 +- storage/reads/reader.go | 12 +- storage/reads/store.go | 3 - storage/reads/stream_reader.go | 20 +- storage/readservice/store.go | 4 - 7 files changed, 169 insertions(+), 660 deletions(-) diff --git a/query/stdlib/influxdata/influxdb/storage.go b/query/stdlib/influxdata/influxdb/storage.go index b9ddfd3a2c..ba60536281 100644 --- a/query/stdlib/influxdata/influxdb/storage.go +++ b/query/stdlib/influxdata/influxdb/storage.go @@ -3,8 +3,6 @@ package influxdb import ( "context" "fmt" - "log" - "math" "github.com/influxdata/flux" "github.com/influxdata/flux/execute" @@ -65,138 +63,27 @@ func (l StaticLookup) Watch() <-chan struct{} { return nil } -// source performs storage reads -type source struct { - Source - - reader Reader - readSpec ReadSpec - window execute.Window - bounds execute.Bounds - - currentTime execute.Time - overflow bool -} - -func NewSource(id execute.DatasetID, r Reader, readSpec ReadSpec, bounds execute.Bounds, w execute.Window, currentTime execute.Time, alloc *memory.Allocator) execute.Source { - src := &source{ - reader: r, - readSpec: readSpec, - bounds: bounds, - window: w, - currentTime: currentTime, - } - src.id = id - src.alloc = alloc - src.runner = src - return src -} - -func (s *source) run(ctx context.Context) error { - //TODO(nathanielc): Pass through context to actual network I/O. - for tables, mark, ok := s.next(ctx); ok; tables, mark, ok = s.next(ctx) { - err := s.processTables(ctx, tables, mark) - if err != nil { - return err - } - } - return nil -} - -func (s *source) next(ctx context.Context) (TableIterator, execute.Time, bool) { - if s.overflow { - return nil, 0, false - } - - start := s.currentTime - execute.Time(s.window.Period) - stop := s.currentTime - if stop > s.bounds.Stop { - return nil, 0, false - } - - // Check if we will overflow, if so we are done after this pass - every := execute.Time(s.window.Every) - if every > 0 { - s.overflow = s.currentTime > math.MaxInt64-every - } else { - s.overflow = s.currentTime < math.MinInt64-every - } - s.currentTime = s.currentTime + every - - bi, err := s.reader.Read( - ctx, - s.readSpec, - start, - stop, - s.alloc, - ) - if err != nil { - log.Println("E!", err) - return nil, 0, false - } - return bi, stop, true -} - type GroupMode int const ( - // GroupModeDefault specifies the default grouping mode, which is GroupModeAll. - GroupModeDefault GroupMode = 0 // GroupModeNone merges all series into a single group. - GroupModeNone GroupMode = 1 << iota - // GroupModeAll produces a separate table for each series. - GroupModeAll + GroupModeNone GroupMode = iota // GroupModeBy produces a table for each unique value of the specified GroupKeys. GroupModeBy - // GroupModeExcept produces a table for the unique values of all keys, except those specified by GroupKeys. - GroupModeExcept ) // ToGroupMode accepts the group mode from Flux and produces the appropriate storage group mode. func ToGroupMode(fluxMode flux.GroupMode) GroupMode { switch fluxMode { case flux.GroupModeNone: - return GroupModeDefault + return GroupModeNone case flux.GroupModeBy: return GroupModeBy - case flux.GroupModeExcept: - return GroupModeExcept default: panic(fmt.Sprint("unknown group mode: ", fluxMode)) } } -type ReadSpec struct { - OrganizationID platform.ID - BucketID platform.ID - - RAMLimit uint64 - Hosts []string - Predicate *semantic.FunctionExpression - PointsLimit int64 - SeriesLimit int64 - SeriesOffset int64 - Descending bool - - AggregateMethod string - - // OrderByTime indicates that series reads should produce all - // series for a time before producing any series for a larger time. - // By default this is false meaning all values of time are produced for a given series, - // before any values are produced from the next series. - OrderByTime bool - // GroupMode instructs - GroupMode GroupMode - // GroupKeys is the list of dimensions along which to group. - // - // When GroupMode is GroupModeBy, the results will be grouped by the specified keys. - // When GroupMode is GroupModeExcept, the results will be grouped by all keys, except those specified. - GroupKeys []string - - Database string // required by InfluxDB OSS - RetentionPolicy string // required by InfluxDB OSS -} - type ReadFilterSpec struct { OrganizationID platform.ID BucketID platform.ID @@ -231,8 +118,6 @@ type Reader interface { ReadTagKeys(ctx context.Context, spec ReadTagKeysSpec, alloc *memory.Allocator) (TableIterator, error) ReadTagValues(ctx context.Context, spec ReadTagValuesSpec, alloc *memory.Allocator) (TableIterator, error) - Read(ctx context.Context, rs ReadSpec, start, stop execute.Time, alloc *memory.Allocator) (TableIterator, error) - Close() } diff --git a/storage/reads/datatypes/storage_common.pb.go b/storage/reads/datatypes/storage_common.pb.go index b3310b0f64..8a1d066b9a 100644 --- a/storage/reads/datatypes/storage_common.pb.go +++ b/storage/reads/datatypes/storage_common.pb.go @@ -32,27 +32,18 @@ const ( // GroupNone returns all series as a single group. // The single GroupFrame.TagKeys will be the union of all tag keys. GroupNone ReadGroupRequest_Group = 0 - // GroupAll returns a unique group for each series. - // As an optimization, no GroupFrames will be generated. - GroupAll ReadGroupRequest_Group = 1 // GroupBy returns a group for each unique value of the specified GroupKeys. GroupBy ReadGroupRequest_Group = 2 - // GroupExcept in not implemented. - GroupExcept ReadGroupRequest_Group = 3 ) var ReadGroupRequest_Group_name = map[int32]string{ 0: "GROUP_NONE", - 1: "GROUP_ALL", 2: "GROUP_BY", - 3: "GROUP_EXCEPT", } var ReadGroupRequest_Group_value = map[string]int32{ - "GROUP_NONE": 0, - "GROUP_ALL": 1, - "GROUP_BY": 2, - "GROUP_EXCEPT": 3, + "GROUP_NONE": 0, + "GROUP_BY": 2, } func (x ReadGroupRequest_Group) String() string { @@ -124,7 +115,7 @@ func (x Aggregate_AggregateType) String() string { } func (Aggregate_AggregateType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{3, 0} + return fileDescriptor_715e4bf4cdf1f73d, []int{2, 0} } type ReadResponse_FrameType int32 @@ -149,7 +140,7 @@ func (x ReadResponse_FrameType) String() string { } func (ReadResponse_FrameType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 0} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 0} } type ReadResponse_DataType int32 @@ -183,7 +174,7 @@ func (x ReadResponse_DataType) String() string { } func (ReadResponse_DataType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 1} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 1} } type ReadFilterRequest struct { @@ -270,43 +261,6 @@ func (m *ReadGroupRequest) XXX_DiscardUnknown() { var xxx_messageInfo_ReadGroupRequest proto.InternalMessageInfo -// TODO(jlapacik): Remove this message -type ReadRequest struct { -} - -func (m *ReadRequest) Reset() { *m = ReadRequest{} } -func (m *ReadRequest) String() string { return proto.CompactTextString(m) } -func (*ReadRequest) ProtoMessage() {} -func (*ReadRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{2} -} -func (m *ReadRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ReadRequest.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalTo(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *ReadRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ReadRequest.Merge(m, src) -} -func (m *ReadRequest) XXX_Size() int { - return m.Size() -} -func (m *ReadRequest) XXX_DiscardUnknown() { - xxx_messageInfo_ReadRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_ReadRequest proto.InternalMessageInfo - type Aggregate struct { Type Aggregate_AggregateType `protobuf:"varint,1,opt,name=type,proto3,enum=influxdata.platform.storage.Aggregate_AggregateType" json:"type,omitempty"` } @@ -315,7 +269,7 @@ func (m *Aggregate) Reset() { *m = Aggregate{} } func (m *Aggregate) String() string { return proto.CompactTextString(m) } func (*Aggregate) ProtoMessage() {} func (*Aggregate) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{3} + return fileDescriptor_715e4bf4cdf1f73d, []int{2} } func (m *Aggregate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -353,7 +307,7 @@ func (m *Tag) Reset() { *m = Tag{} } func (m *Tag) String() string { return proto.CompactTextString(m) } func (*Tag) ProtoMessage() {} func (*Tag) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{4} + return fileDescriptor_715e4bf4cdf1f73d, []int{3} } func (m *Tag) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -391,7 +345,7 @@ func (m *ReadResponse) Reset() { *m = ReadResponse{} } func (m *ReadResponse) String() string { return proto.CompactTextString(m) } func (*ReadResponse) ProtoMessage() {} func (*ReadResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5} + return fileDescriptor_715e4bf4cdf1f73d, []int{4} } func (m *ReadResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -436,7 +390,7 @@ func (m *ReadResponse_Frame) Reset() { *m = ReadResponse_Frame{} } func (m *ReadResponse_Frame) String() string { return proto.CompactTextString(m) } func (*ReadResponse_Frame) ProtoMessage() {} func (*ReadResponse_Frame) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 0} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 0} } func (m *ReadResponse_Frame) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -737,7 +691,7 @@ func (m *ReadResponse_GroupFrame) Reset() { *m = ReadResponse_GroupFrame func (m *ReadResponse_GroupFrame) String() string { return proto.CompactTextString(m) } func (*ReadResponse_GroupFrame) ProtoMessage() {} func (*ReadResponse_GroupFrame) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 1} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 1} } func (m *ReadResponse_GroupFrame) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -775,7 +729,7 @@ func (m *ReadResponse_SeriesFrame) Reset() { *m = ReadResponse_SeriesFra func (m *ReadResponse_SeriesFrame) String() string { return proto.CompactTextString(m) } func (*ReadResponse_SeriesFrame) ProtoMessage() {} func (*ReadResponse_SeriesFrame) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 2} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 2} } func (m *ReadResponse_SeriesFrame) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -813,7 +767,7 @@ func (m *ReadResponse_FloatPointsFrame) Reset() { *m = ReadResponse_Floa func (m *ReadResponse_FloatPointsFrame) String() string { return proto.CompactTextString(m) } func (*ReadResponse_FloatPointsFrame) ProtoMessage() {} func (*ReadResponse_FloatPointsFrame) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 3} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 3} } func (m *ReadResponse_FloatPointsFrame) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -851,7 +805,7 @@ func (m *ReadResponse_IntegerPointsFrame) Reset() { *m = ReadResponse_In func (m *ReadResponse_IntegerPointsFrame) String() string { return proto.CompactTextString(m) } func (*ReadResponse_IntegerPointsFrame) ProtoMessage() {} func (*ReadResponse_IntegerPointsFrame) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 4} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 4} } func (m *ReadResponse_IntegerPointsFrame) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -889,7 +843,7 @@ func (m *ReadResponse_UnsignedPointsFrame) Reset() { *m = ReadResponse_U func (m *ReadResponse_UnsignedPointsFrame) String() string { return proto.CompactTextString(m) } func (*ReadResponse_UnsignedPointsFrame) ProtoMessage() {} func (*ReadResponse_UnsignedPointsFrame) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 5} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 5} } func (m *ReadResponse_UnsignedPointsFrame) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -927,7 +881,7 @@ func (m *ReadResponse_BooleanPointsFrame) Reset() { *m = ReadResponse_Bo func (m *ReadResponse_BooleanPointsFrame) String() string { return proto.CompactTextString(m) } func (*ReadResponse_BooleanPointsFrame) ProtoMessage() {} func (*ReadResponse_BooleanPointsFrame) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 6} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 6} } func (m *ReadResponse_BooleanPointsFrame) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -965,7 +919,7 @@ func (m *ReadResponse_StringPointsFrame) Reset() { *m = ReadResponse_Str func (m *ReadResponse_StringPointsFrame) String() string { return proto.CompactTextString(m) } func (*ReadResponse_StringPointsFrame) ProtoMessage() {} func (*ReadResponse_StringPointsFrame) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{5, 7} + return fileDescriptor_715e4bf4cdf1f73d, []int{4, 7} } func (m *ReadResponse_StringPointsFrame) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1002,7 +956,7 @@ func (m *CapabilitiesResponse) Reset() { *m = CapabilitiesResponse{} } func (m *CapabilitiesResponse) String() string { return proto.CompactTextString(m) } func (*CapabilitiesResponse) ProtoMessage() {} func (*CapabilitiesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{6} + return fileDescriptor_715e4bf4cdf1f73d, []int{5} } func (m *CapabilitiesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1031,42 +985,6 @@ func (m *CapabilitiesResponse) XXX_DiscardUnknown() { var xxx_messageInfo_CapabilitiesResponse proto.InternalMessageInfo -type HintsResponse struct { -} - -func (m *HintsResponse) Reset() { *m = HintsResponse{} } -func (m *HintsResponse) String() string { return proto.CompactTextString(m) } -func (*HintsResponse) ProtoMessage() {} -func (*HintsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{7} -} -func (m *HintsResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *HintsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_HintsResponse.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalTo(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *HintsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_HintsResponse.Merge(m, src) -} -func (m *HintsResponse) XXX_Size() int { - return m.Size() -} -func (m *HintsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_HintsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_HintsResponse proto.InternalMessageInfo - // Specifies a continuous range of nanosecond timestamps. type TimestampRange struct { // Start defines the inclusive lower bound. @@ -1079,7 +997,7 @@ func (m *TimestampRange) Reset() { *m = TimestampRange{} } func (m *TimestampRange) String() string { return proto.CompactTextString(m) } func (*TimestampRange) ProtoMessage() {} func (*TimestampRange) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{8} + return fileDescriptor_715e4bf4cdf1f73d, []int{6} } func (m *TimestampRange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1119,7 +1037,7 @@ func (m *TagKeysRequest) Reset() { *m = TagKeysRequest{} } func (m *TagKeysRequest) String() string { return proto.CompactTextString(m) } func (*TagKeysRequest) ProtoMessage() {} func (*TagKeysRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{9} + return fileDescriptor_715e4bf4cdf1f73d, []int{7} } func (m *TagKeysRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1160,7 +1078,7 @@ func (m *TagValuesRequest) Reset() { *m = TagValuesRequest{} } func (m *TagValuesRequest) String() string { return proto.CompactTextString(m) } func (*TagValuesRequest) ProtoMessage() {} func (*TagValuesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{10} + return fileDescriptor_715e4bf4cdf1f73d, []int{8} } func (m *TagValuesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1198,7 +1116,7 @@ func (m *StringValuesResponse) Reset() { *m = StringValuesResponse{} } func (m *StringValuesResponse) String() string { return proto.CompactTextString(m) } func (*StringValuesResponse) ProtoMessage() {} func (*StringValuesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_715e4bf4cdf1f73d, []int{11} + return fileDescriptor_715e4bf4cdf1f73d, []int{9} } func (m *StringValuesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1235,7 +1153,6 @@ func init() { proto.RegisterEnum("influxdata.platform.storage.ReadResponse_DataType", ReadResponse_DataType_name, ReadResponse_DataType_value) proto.RegisterType((*ReadFilterRequest)(nil), "influxdata.platform.storage.ReadFilterRequest") proto.RegisterType((*ReadGroupRequest)(nil), "influxdata.platform.storage.ReadGroupRequest") - proto.RegisterType((*ReadRequest)(nil), "influxdata.platform.storage.ReadRequest") proto.RegisterType((*Aggregate)(nil), "influxdata.platform.storage.Aggregate") proto.RegisterType((*Tag)(nil), "influxdata.platform.storage.Tag") proto.RegisterType((*ReadResponse)(nil), "influxdata.platform.storage.ReadResponse") @@ -1249,7 +1166,6 @@ func init() { proto.RegisterType((*ReadResponse_StringPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.StringPointsFrame") proto.RegisterType((*CapabilitiesResponse)(nil), "influxdata.platform.storage.CapabilitiesResponse") proto.RegisterMapType((map[string]string)(nil), "influxdata.platform.storage.CapabilitiesResponse.CapsEntry") - proto.RegisterType((*HintsResponse)(nil), "influxdata.platform.storage.HintsResponse") proto.RegisterType((*TimestampRange)(nil), "influxdata.platform.storage.TimestampRange") proto.RegisterType((*TagKeysRequest)(nil), "influxdata.platform.storage.TagKeysRequest") proto.RegisterType((*TagValuesRequest)(nil), "influxdata.platform.storage.TagValuesRequest") @@ -1259,106 +1175,101 @@ func init() { func init() { proto.RegisterFile("storage_common.proto", fileDescriptor_715e4bf4cdf1f73d) } var fileDescriptor_715e4bf4cdf1f73d = []byte{ - // 1578 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0xcd, 0x6f, 0x23, 0x49, - 0x15, 0x77, 0xfb, 0x33, 0xfd, 0xfc, 0x91, 0x4e, 0xad, 0x09, 0xd9, 0x1e, 0xd6, 0xee, 0xb5, 0xd0, - 0x12, 0xd8, 0x1d, 0x67, 0xc8, 0x0c, 0x62, 0x34, 0xc0, 0xc1, 0xce, 0x38, 0xb1, 0x49, 0x62, 0x47, - 0x6d, 0x67, 0xc4, 0x20, 0x21, 0xab, 0x92, 0x54, 0x7a, 0x5a, 0x63, 0x77, 0x37, 0xdd, 0xed, 0x51, - 0x2c, 0x71, 0xe1, 0xc4, 0xc8, 0x12, 0x12, 0x5c, 0x91, 0x2c, 0x21, 0x71, 0xe4, 0xce, 0x1f, 0xc0, - 0x69, 0x6e, 0xcc, 0x91, 0x93, 0x05, 0x1e, 0x09, 0x89, 0x7f, 0x81, 0x13, 0xaa, 0xaa, 0x2e, 0xbb, - 0x9d, 0x84, 0xc4, 0xe6, 0xb4, 0x9a, 0x5b, 0xd5, 0xfb, 0xf8, 0xbd, 0xf7, 0xaa, 0xde, 0x47, 0x15, - 0xe4, 0x3d, 0xdf, 0x76, 0xb1, 0x41, 0xba, 0xe7, 0x76, 0xbf, 0x6f, 0x5b, 0x65, 0xc7, 0xb5, 0x7d, - 0x1b, 0x3d, 0x30, 0xad, 0xcb, 0xde, 0xe0, 0xea, 0x02, 0xfb, 0xb8, 0xec, 0xf4, 0xb0, 0x7f, 0x69, - 0xbb, 0xfd, 0x72, 0x20, 0xa9, 0xe6, 0x0d, 0xdb, 0xb0, 0x99, 0xdc, 0x0e, 0x5d, 0x71, 0x15, 0xf5, - 0x81, 0x61, 0xdb, 0x46, 0x8f, 0xec, 0xb0, 0xdd, 0xd9, 0xe0, 0x72, 0x87, 0xf4, 0x1d, 0x7f, 0x18, - 0x30, 0x3f, 0xbd, 0xce, 0xc4, 0x96, 0x60, 0xad, 0x3b, 0x2e, 0xb9, 0x30, 0xcf, 0xb1, 0x4f, 0x38, - 0xa1, 0xf4, 0x6f, 0x09, 0x36, 0x74, 0x82, 0x2f, 0xf6, 0xcd, 0x9e, 0x4f, 0x5c, 0x9d, 0xfc, 0x72, - 0x40, 0x3c, 0x1f, 0xd5, 0x20, 0xed, 0x12, 0x7c, 0xd1, 0xf5, 0xec, 0x81, 0x7b, 0x4e, 0xb6, 0x24, - 0x4d, 0xda, 0x4e, 0xef, 0xe6, 0xcb, 0x1c, 0xb7, 0x2c, 0x70, 0xcb, 0x15, 0x6b, 0x58, 0xcd, 0x4d, - 0x27, 0x45, 0xa0, 0x08, 0x6d, 0x26, 0xab, 0x83, 0x3b, 0x5b, 0xa3, 0x03, 0x48, 0xb8, 0xd8, 0x32, - 0xc8, 0x56, 0x94, 0x01, 0x7c, 0x59, 0xbe, 0x23, 0xd0, 0x72, 0xc7, 0xec, 0x13, 0xcf, 0xc7, 0x7d, - 0x47, 0xa7, 0x2a, 0xd5, 0xf8, 0xbb, 0x49, 0x31, 0xa2, 0x73, 0x7d, 0xf4, 0x1c, 0xe4, 0x99, 0xe3, - 0x5b, 0x31, 0x06, 0xf6, 0xc5, 0x9d, 0x60, 0x27, 0x42, 0x5a, 0x9f, 0x2b, 0x96, 0x7e, 0x9b, 0x04, - 0x85, 0x7a, 0x7a, 0xe0, 0xda, 0x03, 0xe7, 0xa3, 0x0e, 0x15, 0x7d, 0x05, 0x60, 0xd0, 0x28, 0xbb, - 0xaf, 0xc9, 0xd0, 0xdb, 0x8a, 0x6b, 0xb1, 0x6d, 0xb9, 0x9a, 0x9d, 0x4e, 0x8a, 0x32, 0x8b, 0xfd, - 0x90, 0x0c, 0x3d, 0x5d, 0x36, 0xc4, 0x12, 0x35, 0x20, 0xc1, 0x36, 0x5b, 0x09, 0x4d, 0xda, 0xce, - 0xed, 0x3e, 0xbe, 0xd3, 0xde, 0xf5, 0x13, 0x2c, 0xf3, 0x0d, 0x47, 0xa0, 0xee, 0x63, 0xc3, 0x70, - 0x89, 0x41, 0xdd, 0x4f, 0x2e, 0xe1, 0x7e, 0x45, 0x48, 0xeb, 0x73, 0x45, 0xf4, 0x15, 0x24, 0x5e, - 0x99, 0x96, 0xef, 0x6d, 0xa5, 0x34, 0x69, 0x3b, 0x55, 0xdd, 0x9c, 0x4e, 0x8a, 0x89, 0x3a, 0x25, - 0xfc, 0x67, 0x52, 0x94, 0xe9, 0x62, 0xbf, 0x87, 0x0d, 0x4f, 0xe7, 0x42, 0xa5, 0xdf, 0x48, 0x90, - 0x60, 0x4e, 0xa0, 0xcf, 0x00, 0x0e, 0xf4, 0xd6, 0xe9, 0x49, 0xb7, 0xd9, 0x6a, 0xd6, 0x94, 0x88, - 0x9a, 0x1d, 0x8d, 0x35, 0x1e, 0x72, 0xd3, 0xb6, 0x08, 0x7a, 0x00, 0x32, 0x67, 0x57, 0x8e, 0x8e, - 0x14, 0x49, 0xcd, 0x8c, 0xc6, 0xda, 0x1a, 0xe3, 0x56, 0x7a, 0x3d, 0xf4, 0x29, 0xac, 0x71, 0x66, - 0xf5, 0xa5, 0x12, 0x55, 0xd3, 0xa3, 0xb1, 0x96, 0x62, 0xbc, 0xea, 0x10, 0x7d, 0x0e, 0x19, 0xce, - 0xaa, 0xfd, 0x6c, 0xaf, 0x76, 0xd2, 0x51, 0x62, 0xea, 0xfa, 0x68, 0xac, 0xa5, 0x19, 0xbb, 0x76, - 0x75, 0x4e, 0x1c, 0x5f, 0x8d, 0xbf, 0xfd, 0x53, 0x21, 0x52, 0xfa, 0xb3, 0x04, 0x73, 0xf7, 0xa8, - 0xb9, 0x7a, 0xa3, 0xd9, 0x11, 0xce, 0x30, 0x73, 0x94, 0xcb, 0x7c, 0xf9, 0x36, 0xe4, 0x02, 0x66, - 0xf7, 0xa4, 0xd5, 0x68, 0x76, 0xda, 0x8a, 0xa4, 0x2a, 0xa3, 0xb1, 0x96, 0xe1, 0x12, 0x27, 0x36, - 0x0d, 0x2d, 0x2c, 0xd5, 0xae, 0xe9, 0x8d, 0x5a, 0x5b, 0x89, 0x86, 0xa5, 0xda, 0xc4, 0x35, 0x89, - 0x87, 0x76, 0x20, 0xcf, 0xa4, 0xda, 0x7b, 0xf5, 0xda, 0x71, 0x85, 0x46, 0xd7, 0xed, 0x34, 0x8e, - 0x6b, 0x4a, 0x5c, 0xfd, 0xc6, 0x68, 0xac, 0x6d, 0x50, 0xd9, 0xf6, 0xf9, 0x2b, 0xd2, 0xc7, 0x95, - 0x5e, 0x8f, 0xe6, 0x5e, 0xe0, 0x6d, 0x16, 0xd2, 0xf4, 0x32, 0x83, 0x7b, 0x2c, 0xfd, 0x4d, 0x02, - 0x79, 0x76, 0x1b, 0xa8, 0x0e, 0x71, 0x7f, 0xe8, 0xf0, 0x82, 0xc8, 0xed, 0x3e, 0x59, 0xee, 0x0e, - 0xe7, 0xab, 0xce, 0xd0, 0x21, 0x3a, 0x43, 0x28, 0x5d, 0x41, 0x76, 0x81, 0x8c, 0x8a, 0x10, 0x0f, - 0x8e, 0x84, 0xb9, 0xb7, 0xc0, 0x64, 0x67, 0xf3, 0x19, 0xc4, 0xda, 0xa7, 0xc7, 0x8a, 0xa4, 0xe6, - 0x47, 0x63, 0x4d, 0x59, 0xe0, 0xb7, 0x07, 0x7d, 0xf4, 0x39, 0x24, 0xf6, 0x5a, 0xa7, 0xcd, 0x8e, - 0x12, 0x55, 0x37, 0x47, 0x63, 0x0d, 0x2d, 0x08, 0xec, 0xd9, 0x03, 0x4b, 0x5c, 0xc7, 0x43, 0x88, - 0x75, 0xb0, 0x81, 0x14, 0x88, 0xbd, 0x26, 0x43, 0x16, 0x49, 0x46, 0xa7, 0x4b, 0x94, 0x87, 0xc4, - 0x1b, 0xdc, 0x1b, 0xf0, 0x6a, 0xcd, 0xe8, 0x7c, 0x53, 0xfa, 0x7d, 0x0e, 0x32, 0xfc, 0x40, 0x3c, - 0xc7, 0xb6, 0x3c, 0x82, 0x8e, 0x21, 0x79, 0xe9, 0xe2, 0x3e, 0xf1, 0xb6, 0x24, 0x2d, 0xb6, 0x9d, - 0xde, 0xdd, 0xb9, 0xb7, 0x30, 0x84, 0x6a, 0x79, 0x9f, 0xea, 0x05, 0x95, 0x1d, 0x80, 0xa8, 0x6f, - 0x93, 0x90, 0x60, 0x74, 0x74, 0x24, 0x0a, 0x2e, 0xc5, 0x2a, 0xe4, 0xc9, 0xf2, 0xb8, 0x2c, 0xe7, - 0x18, 0x48, 0x3d, 0x22, 0x6a, 0xae, 0x05, 0x49, 0x8f, 0x25, 0x42, 0xd0, 0xbd, 0x7e, 0xb0, 0x3c, - 0x1c, 0x4f, 0x20, 0x81, 0x17, 0xc0, 0x20, 0x07, 0x32, 0x97, 0x3d, 0x1b, 0xfb, 0x5d, 0x87, 0x65, - 0x61, 0xd0, 0xd3, 0x9e, 0xad, 0x10, 0x3d, 0xd5, 0xe6, 0x29, 0xcc, 0x0f, 0x62, 0x7d, 0x3a, 0x29, - 0xa6, 0x43, 0xd4, 0x7a, 0x44, 0x4f, 0x5f, 0xce, 0xb7, 0xe8, 0x0a, 0x72, 0xa6, 0xe5, 0x13, 0x83, - 0xb8, 0xc2, 0x26, 0x6f, 0x7d, 0x3f, 0x5e, 0xde, 0x66, 0x83, 0xeb, 0x87, 0xad, 0x6e, 0x4c, 0x27, - 0xc5, 0xec, 0x02, 0xbd, 0x1e, 0xd1, 0xb3, 0x66, 0x98, 0x80, 0x7e, 0x05, 0xeb, 0x03, 0xcb, 0x33, - 0x0d, 0x8b, 0x5c, 0x08, 0xd3, 0x71, 0x66, 0xfa, 0x27, 0xcb, 0x9b, 0x3e, 0x0d, 0x00, 0xc2, 0xb6, - 0xd1, 0x74, 0x52, 0xcc, 0x2d, 0x32, 0xea, 0x11, 0x3d, 0x37, 0x58, 0xa0, 0xd0, 0xb8, 0xcf, 0x6c, - 0xbb, 0x47, 0xb0, 0x25, 0x8c, 0x27, 0x56, 0x8d, 0xbb, 0xca, 0xf5, 0x6f, 0xc4, 0xbd, 0x40, 0xa7, - 0x71, 0x9f, 0x85, 0x09, 0xc8, 0x87, 0xac, 0xe7, 0xbb, 0xa6, 0x65, 0x08, 0xc3, 0xbc, 0x59, 0xff, - 0x68, 0x85, 0xdc, 0x61, 0xea, 0x61, 0xbb, 0xca, 0x74, 0x52, 0xcc, 0x84, 0xc9, 0xf5, 0x88, 0x9e, - 0xf1, 0x42, 0xfb, 0x6a, 0x12, 0xe2, 0x14, 0x59, 0xbd, 0x02, 0x98, 0x67, 0x32, 0xfa, 0x02, 0xd6, - 0x7c, 0x6c, 0xf0, 0x59, 0x45, 0x2b, 0x2d, 0x53, 0x4d, 0x4f, 0x27, 0xc5, 0x54, 0x07, 0x1b, 0x6c, - 0x52, 0xa5, 0x7c, 0xbe, 0x40, 0x55, 0x40, 0x0e, 0x76, 0x7d, 0xd3, 0x37, 0x6d, 0x8b, 0x4a, 0x77, - 0xdf, 0xe0, 0x1e, 0xcd, 0x4e, 0xaa, 0x91, 0x9f, 0x4e, 0x8a, 0xca, 0x89, 0xe0, 0x1e, 0x92, 0xe1, - 0x0b, 0xdc, 0xf3, 0x74, 0xc5, 0xb9, 0x46, 0x51, 0xff, 0x20, 0x41, 0x3a, 0x94, 0xf5, 0xe8, 0x19, - 0xc4, 0x7d, 0x6c, 0x88, 0x0a, 0xd7, 0xee, 0x9e, 0xdb, 0xd8, 0x08, 0x4a, 0x9a, 0xe9, 0xa0, 0x16, - 0xc8, 0x54, 0xb0, 0xcb, 0x1a, 0x65, 0x94, 0x35, 0xca, 0xdd, 0xe5, 0xcf, 0xef, 0x39, 0xf6, 0x31, - 0x6b, 0x93, 0x6b, 0x17, 0xc1, 0x4a, 0xfd, 0x29, 0x28, 0xd7, 0x4b, 0x07, 0x15, 0x00, 0x7c, 0xf1, - 0x5e, 0xe0, 0x6e, 0x2a, 0x7a, 0x88, 0x82, 0x36, 0x21, 0xc9, 0xda, 0x17, 0x3f, 0x08, 0x49, 0x0f, - 0x76, 0xea, 0x11, 0xa0, 0x9b, 0x25, 0xb1, 0x22, 0x5a, 0x6c, 0x86, 0x76, 0x0c, 0x9f, 0xdc, 0x92, - 0xe5, 0x2b, 0xc2, 0xc5, 0xc3, 0xce, 0xdd, 0xcc, 0xdb, 0x15, 0xd1, 0xd6, 0x66, 0x68, 0x87, 0xb0, - 0x71, 0x23, 0x19, 0x57, 0x04, 0x93, 0x05, 0x58, 0xa9, 0x0d, 0x32, 0x03, 0x08, 0x46, 0x55, 0x32, - 0x98, 0xbb, 0x11, 0xf5, 0x93, 0xd1, 0x58, 0x5b, 0x9f, 0xb1, 0x82, 0xd1, 0x5b, 0x84, 0xe4, 0x6c, - 0x7c, 0x2f, 0x0a, 0x70, 0x5f, 0x82, 0x49, 0xf4, 0x17, 0x09, 0xd6, 0xc4, 0x7d, 0xa3, 0x6f, 0x41, - 0x62, 0xff, 0xa8, 0x55, 0xe9, 0x28, 0x11, 0x75, 0x63, 0x34, 0xd6, 0xb2, 0x82, 0xc1, 0xae, 0x1e, - 0x69, 0x90, 0x6a, 0x34, 0x3b, 0xb5, 0x83, 0x9a, 0x2e, 0x20, 0x05, 0x3f, 0xb8, 0x4e, 0x54, 0x82, - 0xb5, 0xd3, 0x66, 0xbb, 0x71, 0xd0, 0xac, 0x3d, 0x57, 0xa2, 0x7c, 0x46, 0x0a, 0x11, 0x71, 0x47, - 0x14, 0xa5, 0xda, 0x6a, 0x1d, 0xd5, 0x2a, 0x4d, 0x25, 0xb6, 0x88, 0x12, 0x9c, 0x3b, 0x2a, 0x40, - 0xb2, 0xdd, 0xd1, 0x1b, 0xcd, 0x03, 0x25, 0xae, 0xa2, 0xd1, 0x58, 0xcb, 0x09, 0x01, 0x7e, 0x94, - 0x81, 0xe3, 0x7f, 0x94, 0x20, 0xbf, 0x87, 0x1d, 0x7c, 0x66, 0xf6, 0x4c, 0xdf, 0x24, 0xde, 0x6c, - 0x36, 0xb6, 0x20, 0x7e, 0x8e, 0x1d, 0x51, 0x37, 0x77, 0xb7, 0x8d, 0xdb, 0x00, 0x28, 0xd1, 0xab, - 0x59, 0xbe, 0x3b, 0xd4, 0x19, 0x90, 0xfa, 0x43, 0x90, 0x67, 0xa4, 0xf0, 0xc8, 0x96, 0x6f, 0x19, - 0xd9, 0x72, 0x30, 0xb2, 0x9f, 0x45, 0x9f, 0x4a, 0xa5, 0x75, 0xc8, 0xb2, 0xb7, 0xa1, 0x40, 0x2e, - 0x3d, 0x85, 0xdc, 0xe2, 0x0b, 0x9b, 0x2a, 0x7b, 0x3e, 0x76, 0x7d, 0x06, 0x18, 0xd3, 0xf9, 0x86, - 0x1a, 0x21, 0xd6, 0x05, 0x03, 0x8c, 0xe9, 0x74, 0x59, 0xfa, 0x97, 0x04, 0x39, 0xd1, 0x75, 0xe6, - 0xff, 0x03, 0x5a, 0xeb, 0x4b, 0xff, 0x0f, 0x3a, 0xd8, 0xf0, 0xc4, 0xff, 0xc0, 0x9f, 0xad, 0xbf, - 0x6e, 0x5f, 0xa1, 0x5f, 0x47, 0x41, 0xe9, 0x60, 0xe3, 0x05, 0x4b, 0xf9, 0x8f, 0x3a, 0x54, 0xf4, - 0x4d, 0x48, 0x05, 0xc3, 0x85, 0x0d, 0x76, 0x59, 0x4f, 0xf2, 0x71, 0x52, 0x2a, 0x43, 0x9e, 0xa7, - 0xba, 0x38, 0x85, 0x20, 0xb3, 0xe7, 0x8d, 0x81, 0xcd, 0x22, 0xd1, 0x18, 0x76, 0xff, 0x9a, 0x80, - 0x54, 0x9b, 0x5b, 0x42, 0xbf, 0x80, 0x38, 0xed, 0xe5, 0x68, 0x7b, 0x89, 0x76, 0xcf, 0x0e, 0x57, - 0xfd, 0xee, 0xd2, 0x83, 0xe1, 0x91, 0x84, 0x4c, 0x80, 0xf9, 0xa7, 0x1c, 0x95, 0xef, 0x55, 0x5d, - 0xf8, 0xbd, 0xaf, 0x66, 0xca, 0x00, 0x79, 0xf6, 0xa3, 0x43, 0x0f, 0x57, 0xfa, 0xf9, 0xad, 0x66, - 0xe8, 0x25, 0x64, 0xc2, 0x7d, 0x00, 0x6d, 0xde, 0x48, 0xac, 0x5a, 0xdf, 0xf1, 0x87, 0xea, 0xf7, - 0x57, 0x6e, 0x25, 0xe8, 0x10, 0xf8, 0xef, 0xf0, 0x7f, 0x62, 0x7e, 0xef, 0x4e, 0xcc, 0x85, 0xee, - 0x81, 0x5e, 0x83, 0x78, 0x78, 0xa0, 0x2f, 0xef, 0x7b, 0x0d, 0x84, 0x1a, 0xc5, 0x3d, 0x7e, 0xdf, - 0x96, 0x69, 0x8f, 0x24, 0x64, 0x83, 0x3c, 0x2b, 0xc3, 0x7b, 0x4e, 0xff, 0x7a, 0xb9, 0xfe, 0x5f, - 0x06, 0xab, 0xdf, 0x79, 0xf7, 0xcf, 0x42, 0xe4, 0xdd, 0xb4, 0x20, 0xbd, 0x9f, 0x16, 0xa4, 0x7f, - 0x4c, 0x0b, 0xd2, 0xef, 0x3e, 0x14, 0x22, 0xef, 0x3f, 0x14, 0x22, 0x7f, 0xff, 0x50, 0x88, 0xfc, - 0x9c, 0x3d, 0x67, 0xe8, 0x6b, 0xc6, 0x3b, 0x4b, 0xb2, 0x23, 0x7c, 0xfc, 0xdf, 0x00, 0x00, 0x00, - 0xff, 0xff, 0x03, 0xca, 0xf6, 0x4a, 0xb3, 0x12, 0x00, 0x00, + // 1498 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0xcb, 0x6f, 0xdb, 0xc8, + 0x19, 0x17, 0xf5, 0x34, 0x3f, 0xc9, 0x32, 0x3d, 0x51, 0x5d, 0x87, 0x69, 0x24, 0x56, 0x28, 0x52, + 0x17, 0x49, 0xe4, 0xd4, 0x49, 0xd1, 0x20, 0x6d, 0x0f, 0x96, 0x23, 0x5b, 0x6a, 0x6c, 0xc9, 0xa0, + 0xe4, 0x00, 0xe9, 0x45, 0x18, 0xdb, 0x63, 0x86, 0x88, 0x44, 0xb2, 0x24, 0x15, 0x58, 0x40, 0x2f, + 0xbd, 0x05, 0x3a, 0xb5, 0x97, 0x1e, 0x0a, 0x08, 0x58, 0x60, 0x8f, 0x7b, 0xdf, 0xbf, 0x21, 0x87, + 0x05, 0x36, 0xc7, 0x3d, 0x09, 0xbb, 0x0a, 0xb0, 0xc0, 0xfe, 0x0b, 0x7b, 0x5a, 0xcc, 0x0c, 0x47, + 0xa2, 0x6c, 0xc3, 0x96, 0xf6, 0xb4, 0xc8, 0x6d, 0xe6, 0x7b, 0xfc, 0xbe, 0x07, 0xbf, 0xc7, 0x10, + 0x72, 0x9e, 0x6f, 0xbb, 0xd8, 0x20, 0xed, 0x13, 0xbb, 0xdb, 0xb5, 0xad, 0x92, 0xe3, 0xda, 0xbe, + 0x8d, 0xee, 0x98, 0xd6, 0x59, 0xa7, 0x77, 0x7e, 0x8a, 0x7d, 0x5c, 0x72, 0x3a, 0xd8, 0x3f, 0xb3, + 0xdd, 0x6e, 0x29, 0x90, 0x54, 0x73, 0x86, 0x6d, 0xd8, 0x4c, 0x6e, 0x93, 0x9e, 0xb8, 0x8a, 0x7a, + 0xc7, 0xb0, 0x6d, 0xa3, 0x43, 0x36, 0xd9, 0xed, 0xb8, 0x77, 0xb6, 0x49, 0xba, 0x8e, 0xdf, 0x0f, + 0x98, 0xb7, 0x2f, 0x32, 0xb1, 0x25, 0x58, 0x2b, 0x8e, 0x4b, 0x4e, 0xcd, 0x13, 0xec, 0x13, 0x4e, + 0x28, 0xfe, 0x20, 0xc1, 0xaa, 0x4e, 0xf0, 0xe9, 0xae, 0xd9, 0xf1, 0x89, 0xab, 0x93, 0x7f, 0xf6, + 0x88, 0xe7, 0xa3, 0x0a, 0xa4, 0x5d, 0x82, 0x4f, 0xdb, 0x9e, 0xdd, 0x73, 0x4f, 0xc8, 0xba, 0xa4, + 0x49, 0x1b, 0xe9, 0xad, 0x5c, 0x89, 0xe3, 0x96, 0x04, 0x6e, 0x69, 0xdb, 0xea, 0x97, 0xb3, 0xe3, + 0x51, 0x01, 0x28, 0x42, 0x93, 0xc9, 0xea, 0xe0, 0x4e, 0xce, 0x68, 0x0f, 0x12, 0x2e, 0xb6, 0x0c, + 0xb2, 0x1e, 0x65, 0x00, 0xf7, 0x4b, 0xd7, 0x04, 0x5a, 0x6a, 0x99, 0x5d, 0xe2, 0xf9, 0xb8, 0xeb, + 0xe8, 0x54, 0xa5, 0x1c, 0x7f, 0x3f, 0x2a, 0x44, 0x74, 0xae, 0x8f, 0x9e, 0x83, 0x3c, 0x71, 0x7c, + 0x3d, 0xc6, 0xc0, 0xee, 0x5d, 0x0b, 0x76, 0x28, 0xa4, 0xf5, 0xa9, 0x62, 0xf1, 0xab, 0x04, 0x28, + 0xd4, 0xd3, 0x3d, 0xd7, 0xee, 0x39, 0x9f, 0x74, 0xa8, 0xe8, 0x01, 0x80, 0x41, 0xa3, 0x6c, 0xbf, + 0x21, 0x7d, 0x6f, 0x3d, 0xae, 0xc5, 0x36, 0xe4, 0xf2, 0xf2, 0x78, 0x54, 0x90, 0x59, 0xec, 0x2f, + 0x48, 0xdf, 0xd3, 0x65, 0x43, 0x1c, 0x51, 0x0d, 0x12, 0xec, 0xb2, 0x9e, 0xd0, 0xa4, 0x8d, 0xec, + 0xd6, 0xe3, 0x6b, 0xed, 0x5d, 0xcc, 0x60, 0x89, 0x5f, 0x38, 0x02, 0x75, 0x1f, 0x1b, 0x86, 0x4b, + 0x0c, 0xea, 0x7e, 0x72, 0x0e, 0xf7, 0xb7, 0x85, 0xb4, 0x3e, 0x55, 0x44, 0x0f, 0x20, 0xf1, 0xda, + 0xb4, 0x7c, 0x6f, 0x3d, 0xa5, 0x49, 0x1b, 0xa9, 0xf2, 0xda, 0x78, 0x54, 0x48, 0x54, 0x29, 0xe1, + 0xc7, 0x51, 0x41, 0xa6, 0x87, 0xdd, 0x0e, 0x36, 0x3c, 0x9d, 0x0b, 0x15, 0xf7, 0x20, 0xc1, 0x7c, + 0x40, 0x77, 0x01, 0xf6, 0xf4, 0xc6, 0xd1, 0x61, 0xbb, 0xde, 0xa8, 0x57, 0x94, 0x88, 0xba, 0x3c, + 0x18, 0x6a, 0x3c, 0xe2, 0xba, 0x6d, 0x11, 0x74, 0x1b, 0x96, 0x38, 0xbb, 0xfc, 0x4a, 0x89, 0xaa, + 0xe9, 0xc1, 0x50, 0x4b, 0x31, 0x66, 0xb9, 0xaf, 0xc6, 0xdf, 0x7d, 0x9e, 0x8f, 0x14, 0xbf, 0x90, + 0x60, 0x8a, 0x8e, 0xee, 0x80, 0x5c, 0xad, 0xd5, 0x5b, 0x02, 0x2c, 0x33, 0x18, 0x6a, 0x4b, 0x94, + 0xcb, 0xb0, 0x7e, 0x07, 0xd9, 0x80, 0xd9, 0x3e, 0x6c, 0xd4, 0xea, 0xad, 0xa6, 0x22, 0xa9, 0xca, + 0x60, 0xa8, 0x65, 0xb8, 0xc4, 0xa1, 0x4d, 0x3d, 0x0b, 0x4b, 0x35, 0x2b, 0x7a, 0xad, 0xd2, 0x54, + 0xa2, 0x61, 0xa9, 0x26, 0x71, 0x4d, 0xe2, 0xa1, 0x4d, 0xc8, 0x31, 0xa9, 0xe6, 0x4e, 0xb5, 0x72, + 0xb0, 0xdd, 0xde, 0xde, 0xdf, 0x6f, 0xb7, 0x6a, 0x07, 0x15, 0x25, 0xae, 0xfe, 0x6a, 0x30, 0xd4, + 0x56, 0xa9, 0x6c, 0xf3, 0xe4, 0x35, 0xe9, 0xe2, 0xed, 0x4e, 0x87, 0x96, 0x4e, 0xe0, 0xed, 0xd7, + 0x12, 0xc8, 0x93, 0xec, 0xa1, 0x2a, 0xc4, 0xfd, 0xbe, 0xc3, 0x0b, 0x38, 0xbb, 0xf5, 0x64, 0xbe, + 0x9c, 0x4f, 0x4f, 0xad, 0xbe, 0x43, 0x74, 0x86, 0x50, 0x3c, 0x87, 0xe5, 0x19, 0x32, 0x2a, 0x40, + 0x3c, 0xc8, 0x01, 0xf3, 0x67, 0x86, 0xc9, 0x92, 0x71, 0x17, 0x62, 0xcd, 0xa3, 0x03, 0x45, 0x52, + 0x73, 0x83, 0xa1, 0xa6, 0xcc, 0xf0, 0x9b, 0xbd, 0x2e, 0xfa, 0x2d, 0x24, 0x76, 0x1a, 0x47, 0xf5, + 0x96, 0x12, 0x55, 0xd7, 0x06, 0x43, 0x0d, 0xcd, 0x08, 0xec, 0xd8, 0x3d, 0xcb, 0x0f, 0x22, 0x7a, + 0x08, 0xb1, 0x16, 0x36, 0x90, 0x02, 0xb1, 0x37, 0xa4, 0xcf, 0x22, 0xc9, 0xe8, 0xf4, 0x88, 0x72, + 0x90, 0x78, 0x8b, 0x3b, 0x3d, 0xde, 0x5d, 0x19, 0x9d, 0x5f, 0x8a, 0xff, 0xcd, 0x42, 0x86, 0x56, + 0xa3, 0x4e, 0x3c, 0xc7, 0xb6, 0x3c, 0x82, 0x0e, 0x20, 0x79, 0xe6, 0xe2, 0x2e, 0xf1, 0xd6, 0x25, + 0x2d, 0xb6, 0x91, 0xde, 0xda, 0xbc, 0xb1, 0x90, 0x85, 0x6a, 0x69, 0x97, 0xea, 0x05, 0x9d, 0x18, + 0x80, 0xa8, 0xef, 0x92, 0x90, 0x60, 0x74, 0xb4, 0x2f, 0x1a, 0x24, 0xc5, 0x2a, 0xfa, 0xc9, 0xfc, + 0xb8, 0xac, 0xc0, 0x18, 0x48, 0x35, 0x22, 0x7a, 0xa4, 0x01, 0x49, 0x8f, 0x7d, 0xf9, 0x60, 0xda, + 0xfc, 0x69, 0x7e, 0x38, 0x5e, 0x31, 0x02, 0x2f, 0x80, 0x41, 0x0e, 0x64, 0xce, 0x3a, 0x36, 0xf6, + 0xdb, 0x0e, 0x2b, 0xbb, 0x60, 0x06, 0x3d, 0x5b, 0x20, 0x7a, 0xaa, 0xcd, 0x6b, 0x96, 0x27, 0x62, + 0x65, 0x3c, 0x2a, 0xa4, 0x43, 0xd4, 0x6a, 0x44, 0x4f, 0x9f, 0x4d, 0xaf, 0xe8, 0x1c, 0xb2, 0xa6, + 0xe5, 0x13, 0x83, 0xb8, 0xc2, 0x26, 0x1f, 0x55, 0x7f, 0x9d, 0xdf, 0x66, 0x8d, 0xeb, 0x87, 0xad, + 0xae, 0x8e, 0x47, 0x85, 0xe5, 0x19, 0x7a, 0x35, 0xa2, 0x2f, 0x9b, 0x61, 0x02, 0xfa, 0x17, 0xac, + 0xf4, 0x2c, 0xcf, 0x34, 0x2c, 0x72, 0x2a, 0x4c, 0xc7, 0x99, 0xe9, 0xbf, 0xcd, 0x6f, 0xfa, 0x28, + 0x00, 0x08, 0xdb, 0x46, 0xe3, 0x51, 0x21, 0x3b, 0xcb, 0xa8, 0x46, 0xf4, 0x6c, 0x6f, 0x86, 0x42, + 0xe3, 0x3e, 0xb6, 0xed, 0x0e, 0xc1, 0x96, 0x30, 0x9e, 0x58, 0x34, 0xee, 0x32, 0xd7, 0xbf, 0x14, + 0xf7, 0x0c, 0x9d, 0xc6, 0x7d, 0x1c, 0x26, 0x20, 0x1f, 0x96, 0x3d, 0xdf, 0x35, 0x2d, 0x43, 0x18, + 0xe6, 0xc3, 0xf5, 0x2f, 0x0b, 0xd4, 0x0e, 0x53, 0x0f, 0xdb, 0x55, 0xc6, 0xa3, 0x42, 0x26, 0x4c, + 0xae, 0x46, 0xf4, 0x8c, 0x17, 0xba, 0x97, 0x93, 0x10, 0xa7, 0xc8, 0xea, 0x39, 0xc0, 0xb4, 0x92, + 0xd1, 0x3d, 0x58, 0xf2, 0xb1, 0xc1, 0x77, 0x0b, 0xed, 0xb4, 0x4c, 0x39, 0x3d, 0x1e, 0x15, 0x52, + 0x2d, 0x6c, 0xb0, 0xcd, 0x92, 0xf2, 0xf9, 0x01, 0x95, 0x01, 0x39, 0xd8, 0xf5, 0x4d, 0xdf, 0xb4, + 0x2d, 0x2a, 0xdd, 0x7e, 0x8b, 0x3b, 0xb4, 0x3a, 0xa9, 0x46, 0x6e, 0x3c, 0x2a, 0x28, 0x87, 0x82, + 0xfb, 0x82, 0xf4, 0x5f, 0xe2, 0x8e, 0xa7, 0x2b, 0xce, 0x05, 0x8a, 0xfa, 0x7f, 0x09, 0xd2, 0xa1, + 0xaa, 0x47, 0xcf, 0x20, 0xee, 0x63, 0x43, 0x74, 0xb8, 0x76, 0xfd, 0x9e, 0xc5, 0x46, 0xd0, 0xd2, + 0x4c, 0x07, 0x35, 0x40, 0xa6, 0x82, 0x6d, 0x36, 0x28, 0xa3, 0x6c, 0x50, 0x6e, 0xcd, 0x9f, 0xbf, + 0xe7, 0xd8, 0xc7, 0x6c, 0x4c, 0x2e, 0x9d, 0x06, 0x27, 0xf5, 0xef, 0xa0, 0x5c, 0x6c, 0x1d, 0x94, + 0x07, 0xf0, 0xc5, 0x7e, 0xe7, 0x6e, 0x2a, 0x7a, 0x88, 0x82, 0xd6, 0x20, 0xc9, 0xc6, 0x17, 0x4f, + 0x84, 0xa4, 0x07, 0x37, 0x75, 0x1f, 0xd0, 0xe5, 0x96, 0x58, 0x10, 0x2d, 0x36, 0x41, 0x3b, 0x80, + 0x5b, 0x57, 0x54, 0xf9, 0x82, 0x70, 0xf1, 0xb0, 0x73, 0x97, 0xeb, 0x76, 0x41, 0xb4, 0xa5, 0x09, + 0xda, 0x0b, 0x58, 0xbd, 0x54, 0x8c, 0x0b, 0x82, 0xc9, 0x02, 0xac, 0xd8, 0x04, 0x99, 0x01, 0x04, + 0xab, 0x2a, 0x19, 0x2c, 0xda, 0x88, 0x7a, 0x6b, 0x30, 0xd4, 0x56, 0x26, 0xac, 0x60, 0xd7, 0x16, + 0x20, 0x39, 0xd9, 0xd7, 0xb3, 0x02, 0xdc, 0x97, 0x60, 0x13, 0x7d, 0x29, 0xc1, 0x92, 0xf8, 0xde, + 0xe8, 0x37, 0x90, 0xd8, 0xdd, 0x6f, 0x6c, 0xb7, 0x94, 0x88, 0xba, 0x3a, 0x18, 0x6a, 0xcb, 0x82, + 0xc1, 0x3e, 0x3d, 0xd2, 0x20, 0x55, 0xab, 0xb7, 0x2a, 0x7b, 0x15, 0x5d, 0x40, 0x0a, 0x7e, 0xf0, + 0x39, 0x51, 0x11, 0x96, 0x8e, 0xea, 0xcd, 0xda, 0x5e, 0xbd, 0xf2, 0x5c, 0x89, 0xf2, 0x1d, 0x29, + 0x44, 0xc4, 0x37, 0xa2, 0x28, 0xe5, 0x46, 0x63, 0xbf, 0xb2, 0x5d, 0x57, 0x62, 0xb3, 0x28, 0x41, + 0xde, 0x51, 0x1e, 0x92, 0xcd, 0x96, 0x5e, 0xab, 0xef, 0x29, 0x71, 0x15, 0x0d, 0x86, 0x5a, 0x56, + 0x08, 0xf0, 0x54, 0x06, 0x8e, 0x7f, 0x26, 0x41, 0x6e, 0x07, 0x3b, 0xf8, 0xd8, 0xec, 0x98, 0xbe, + 0x49, 0xbc, 0xc9, 0x6e, 0x6c, 0x40, 0xfc, 0x04, 0x3b, 0xa2, 0x6f, 0xae, 0x1f, 0x1b, 0x57, 0x01, + 0x50, 0xa2, 0x57, 0xb1, 0x7c, 0xb7, 0xaf, 0x33, 0x20, 0xf5, 0xcf, 0x20, 0x4f, 0x48, 0xe1, 0x95, + 0x2d, 0x5f, 0xb1, 0xb2, 0xe5, 0x60, 0x65, 0x3f, 0x8b, 0x3e, 0x95, 0x8a, 0x4f, 0x21, 0x3b, 0xfb, + 0x00, 0xa6, 0xb2, 0x9e, 0x8f, 0x5d, 0x9f, 0xe9, 0xc7, 0x74, 0x7e, 0xa1, 0x98, 0xc4, 0x3a, 0x65, + 0xfa, 0x31, 0x9d, 0x1e, 0x8b, 0xdf, 0x4b, 0x90, 0x15, 0x43, 0x66, 0xfa, 0x7c, 0xa7, 0xad, 0x3d, + 0xf7, 0xf3, 0xbd, 0x85, 0x0d, 0x4f, 0x3c, 0xdf, 0xfd, 0xc9, 0xf9, 0x97, 0xf6, 0xa7, 0xf2, 0xef, + 0x28, 0x28, 0x2d, 0x6c, 0xbc, 0x64, 0x15, 0xfe, 0x49, 0x87, 0x8a, 0x7e, 0x0d, 0xa9, 0x60, 0x97, + 0xb0, 0x3d, 0x2e, 0xeb, 0x49, 0xbe, 0x3d, 0x8a, 0x25, 0xc8, 0xf1, 0xca, 0x16, 0x59, 0x08, 0x0a, + 0x79, 0x3a, 0x07, 0xd8, 0xea, 0x11, 0x73, 0x60, 0xeb, 0x7f, 0x71, 0x48, 0x35, 0xb9, 0x25, 0x64, + 0x02, 0x4c, 0x7f, 0x6a, 0x51, 0xe9, 0xc6, 0x19, 0x3f, 0xf3, 0xf7, 0xab, 0xfe, 0x61, 0xee, 0x9d, + 0xf0, 0x48, 0x42, 0x06, 0xc8, 0x93, 0x3f, 0x22, 0xf4, 0x70, 0xa1, 0x3f, 0xa7, 0xc5, 0x0c, 0xbd, + 0x01, 0xb1, 0x60, 0xd1, 0xfd, 0x9b, 0xb6, 0x5e, 0xa8, 0x43, 0xd4, 0x3f, 0x5e, 0x2b, 0x7c, 0x55, + 0x8a, 0x1f, 0x49, 0xc8, 0x06, 0x79, 0x52, 0x7f, 0x37, 0x44, 0x75, 0xb1, 0x4e, 0x7f, 0x9e, 0xc1, + 0x57, 0x90, 0x09, 0x4f, 0x1d, 0xb4, 0x76, 0xa9, 0xae, 0x2b, 0x5d, 0xc7, 0xef, 0xdf, 0x00, 0x7e, + 0xd5, 0xe0, 0x2a, 0xff, 0xfe, 0xfd, 0x77, 0xf9, 0xc8, 0xfb, 0x71, 0x5e, 0xfa, 0x30, 0xce, 0x4b, + 0xdf, 0x8e, 0xf3, 0xd2, 0x7f, 0x3e, 0xe6, 0x23, 0x1f, 0x3e, 0xe6, 0x23, 0xdf, 0x7c, 0xcc, 0x47, + 0xfe, 0xc1, 0x5e, 0x04, 0xf4, 0x41, 0xe0, 0x1d, 0x27, 0x99, 0xad, 0xc7, 0x3f, 0x05, 0x00, 0x00, + 0xff, 0xff, 0x7f, 0x0e, 0xbb, 0xbb, 0xa6, 0x11, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1373,19 +1284,16 @@ const _ = grpc.SupportPackageIsVersion4 // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type StorageClient interface { - // TODO(jlapacik): Remove this unsupported call - Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (Storage_ReadClient, error) // ReadFilter performs a filter operation at storage ReadFilter(ctx context.Context, in *ReadFilterRequest, opts ...grpc.CallOption) (Storage_ReadFilterClient, error) // ReadGroup performs a group operation at storage ReadGroup(ctx context.Context, in *ReadGroupRequest, opts ...grpc.CallOption) (Storage_ReadGroupClient, error) - // Capabilities returns a map of keys and values identifying the capabilities supported by the storage engine - Capabilities(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error) - Hints(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*HintsResponse, error) // TagKeys performs a read operation for tag keys TagKeys(ctx context.Context, in *TagKeysRequest, opts ...grpc.CallOption) (Storage_TagKeysClient, error) // TagValues performs a read operation for tag values TagValues(ctx context.Context, in *TagValuesRequest, opts ...grpc.CallOption) (Storage_TagValuesClient, error) + // Capabilities returns a map of keys and values identifying the capabilities supported by the storage engine + Capabilities(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error) } type storageClient struct { @@ -1396,40 +1304,8 @@ func NewStorageClient(cc *grpc.ClientConn) StorageClient { return &storageClient{cc} } -func (c *storageClient) Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (Storage_ReadClient, error) { - stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[0], "/influxdata.platform.storage.Storage/Read", opts...) - if err != nil { - return nil, err - } - x := &storageReadClient{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 Storage_ReadClient interface { - Recv() (*ReadResponse, error) - grpc.ClientStream -} - -type storageReadClient struct { - grpc.ClientStream -} - -func (x *storageReadClient) Recv() (*ReadResponse, error) { - m := new(ReadResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} - func (c *storageClient) ReadFilter(ctx context.Context, in *ReadFilterRequest, opts ...grpc.CallOption) (Storage_ReadFilterClient, error) { - stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[1], "/influxdata.platform.storage.Storage/ReadFilter", opts...) + stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[0], "/influxdata.platform.storage.Storage/ReadFilter", opts...) if err != nil { return nil, err } @@ -1461,7 +1337,7 @@ func (x *storageReadFilterClient) Recv() (*ReadResponse, error) { } func (c *storageClient) ReadGroup(ctx context.Context, in *ReadGroupRequest, opts ...grpc.CallOption) (Storage_ReadGroupClient, error) { - stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[2], "/influxdata.platform.storage.Storage/ReadGroup", opts...) + stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[1], "/influxdata.platform.storage.Storage/ReadGroup", opts...) if err != nil { return nil, err } @@ -1492,26 +1368,8 @@ func (x *storageReadGroupClient) Recv() (*ReadResponse, error) { return m, nil } -func (c *storageClient) Capabilities(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error) { - out := new(CapabilitiesResponse) - err := c.cc.Invoke(ctx, "/influxdata.platform.storage.Storage/Capabilities", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *storageClient) Hints(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*HintsResponse, error) { - out := new(HintsResponse) - err := c.cc.Invoke(ctx, "/influxdata.platform.storage.Storage/Hints", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - func (c *storageClient) TagKeys(ctx context.Context, in *TagKeysRequest, opts ...grpc.CallOption) (Storage_TagKeysClient, error) { - stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[3], "/influxdata.platform.storage.Storage/TagKeys", opts...) + stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[2], "/influxdata.platform.storage.Storage/TagKeys", opts...) if err != nil { return nil, err } @@ -1543,7 +1401,7 @@ func (x *storageTagKeysClient) Recv() (*StringValuesResponse, error) { } func (c *storageClient) TagValues(ctx context.Context, in *TagValuesRequest, opts ...grpc.CallOption) (Storage_TagValuesClient, error) { - stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[4], "/influxdata.platform.storage.Storage/TagValues", opts...) + stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[3], "/influxdata.platform.storage.Storage/TagValues", opts...) if err != nil { return nil, err } @@ -1574,48 +1432,33 @@ func (x *storageTagValuesClient) Recv() (*StringValuesResponse, error) { return m, nil } +func (c *storageClient) Capabilities(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error) { + out := new(CapabilitiesResponse) + err := c.cc.Invoke(ctx, "/influxdata.platform.storage.Storage/Capabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // StorageServer is the server API for Storage service. type StorageServer interface { - // TODO(jlapacik): Remove this unsupported call - Read(*ReadRequest, Storage_ReadServer) error // ReadFilter performs a filter operation at storage ReadFilter(*ReadFilterRequest, Storage_ReadFilterServer) error // ReadGroup performs a group operation at storage ReadGroup(*ReadGroupRequest, Storage_ReadGroupServer) error - // Capabilities returns a map of keys and values identifying the capabilities supported by the storage engine - Capabilities(context.Context, *types.Empty) (*CapabilitiesResponse, error) - Hints(context.Context, *types.Empty) (*HintsResponse, error) // TagKeys performs a read operation for tag keys TagKeys(*TagKeysRequest, Storage_TagKeysServer) error // TagValues performs a read operation for tag values TagValues(*TagValuesRequest, Storage_TagValuesServer) error + // Capabilities returns a map of keys and values identifying the capabilities supported by the storage engine + Capabilities(context.Context, *types.Empty) (*CapabilitiesResponse, error) } func RegisterStorageServer(s *grpc.Server, srv StorageServer) { s.RegisterService(&_Storage_serviceDesc, srv) } -func _Storage_Read_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(ReadRequest) - if err := stream.RecvMsg(m); err != nil { - return err - } - return srv.(StorageServer).Read(m, &storageReadServer{stream}) -} - -type Storage_ReadServer interface { - Send(*ReadResponse) error - grpc.ServerStream -} - -type storageReadServer struct { - grpc.ServerStream -} - -func (x *storageReadServer) Send(m *ReadResponse) error { - return x.ServerStream.SendMsg(m) -} - func _Storage_ReadFilter_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ReadFilterRequest) if err := stream.RecvMsg(m); err != nil { @@ -1658,42 +1501,6 @@ func (x *storageReadGroupServer) Send(m *ReadResponse) error { return x.ServerStream.SendMsg(m) } -func _Storage_Capabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(types.Empty) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StorageServer).Capabilities(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/influxdata.platform.storage.Storage/Capabilities", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StorageServer).Capabilities(ctx, req.(*types.Empty)) - } - return interceptor(ctx, in, info, handler) -} - -func _Storage_Hints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(types.Empty) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StorageServer).Hints(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/influxdata.platform.storage.Storage/Hints", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StorageServer).Hints(ctx, req.(*types.Empty)) - } - return interceptor(ctx, in, info, handler) -} - func _Storage_TagKeys_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(TagKeysRequest) if err := stream.RecvMsg(m); err != nil { @@ -1736,6 +1543,24 @@ func (x *storageTagValuesServer) Send(m *StringValuesResponse) error { return x.ServerStream.SendMsg(m) } +func _Storage_Capabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(types.Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StorageServer).Capabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/influxdata.platform.storage.Storage/Capabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StorageServer).Capabilities(ctx, req.(*types.Empty)) + } + return interceptor(ctx, in, info, handler) +} + var _Storage_serviceDesc = grpc.ServiceDesc{ ServiceName: "influxdata.platform.storage.Storage", HandlerType: (*StorageServer)(nil), @@ -1744,17 +1569,8 @@ var _Storage_serviceDesc = grpc.ServiceDesc{ MethodName: "Capabilities", Handler: _Storage_Capabilities_Handler, }, - { - MethodName: "Hints", - Handler: _Storage_Hints_Handler, - }, }, Streams: []grpc.StreamDesc{ - { - StreamName: "Read", - Handler: _Storage_Read_Handler, - ServerStreams: true, - }, { StreamName: "ReadFilter", Handler: _Storage_ReadFilter_Handler, @@ -1907,24 +1723,6 @@ func (m *ReadGroupRequest) MarshalTo(dAtA []byte) (int, error) { return i, nil } -func (m *ReadRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *ReadRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - return i, nil -} - func (m *Aggregate) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2443,24 +2241,6 @@ func (m *CapabilitiesResponse) MarshalTo(dAtA []byte) (int, error) { return i, nil } -func (m *HintsResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *HintsResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - return i, nil -} - func (m *TimestampRange) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2676,15 +2456,6 @@ func (m *ReadGroupRequest) Size() (n int) { return n } -func (m *ReadRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - func (m *Aggregate) Size() (n int) { if m == nil { return 0 @@ -2967,15 +2738,6 @@ func (m *CapabilitiesResponse) Size() (n int) { return n } -func (m *HintsResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - func (m *TimestampRange) Size() (n int) { if m == nil { return 0 @@ -3474,59 +3236,6 @@ func (m *ReadGroupRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ReadRequest) 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 ErrIntOverflowStorageCommon - } - 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: ReadRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ReadRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipStorageCommon(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthStorageCommon - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthStorageCommon - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *Aggregate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5341,59 +5050,6 @@ func (m *CapabilitiesResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *HintsResponse) 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 ErrIntOverflowStorageCommon - } - 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: HintsResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: HintsResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipStorageCommon(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthStorageCommon - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthStorageCommon - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *TimestampRange) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/storage/reads/datatypes/storage_common.proto b/storage/reads/datatypes/storage_common.proto index 0d0c550c9b..0409441764 100644 --- a/storage/reads/datatypes/storage_common.proto +++ b/storage/reads/datatypes/storage_common.proto @@ -13,28 +13,20 @@ option (gogoproto.unmarshaler_all) = true; option (gogoproto.goproto_getters_all) = false; service Storage { - // TODO(jlapacik): Remove this unsupported call - rpc Read (ReadRequest) returns (stream ReadResponse); - // ReadFilter performs a filter operation at storage rpc ReadFilter (ReadFilterRequest) returns (stream ReadResponse); // ReadGroup performs a group operation at storage rpc ReadGroup (ReadGroupRequest) returns (stream ReadResponse); - // Capabilities returns a map of keys and values identifying the capabilities supported by the storage engine - rpc Capabilities (google.protobuf.Empty) returns (CapabilitiesResponse); - - rpc Hints (google.protobuf.Empty) returns (HintsResponse); - // TagKeys performs a read operation for tag keys rpc TagKeys (TagKeysRequest) returns (stream StringValuesResponse); // TagValues performs a read operation for tag values rpc TagValues (TagValuesRequest) returns (stream StringValuesResponse); - // Explain describes the costs associated with executing a given Read request - // rpc Explain(google.protobuf.Empty) returns (ExplainResponse){} + // Capabilities returns a map of keys and values identifying the capabilities supported by the storage engine + rpc Capabilities (google.protobuf.Empty) returns (CapabilitiesResponse); } message ReadFilterRequest { @@ -55,15 +47,8 @@ message ReadGroupRequest { // The single GroupFrame.TagKeys will be the union of all tag keys. GROUP_NONE = 0 [(gogoproto.enumvalue_customname) = "GroupNone"]; - // GroupAll returns a unique group for each series. - // As an optimization, no GroupFrames will be generated. - GROUP_ALL = 1 [(gogoproto.enumvalue_customname) = "GroupAll"]; - // GroupBy returns a group for each unique value of the specified GroupKeys. GROUP_BY = 2 [(gogoproto.enumvalue_customname) = "GroupBy"]; - - // GroupExcept in not implemented. - GROUP_EXCEPT = 3 [(gogoproto.enumvalue_customname) = "GroupExcept"]; } // GroupKeys specifies a list of tag keys used to order the data. @@ -89,9 +74,6 @@ message ReadGroupRequest { fixed32 hints = 7 [(gogoproto.customname) = "Hints", (gogoproto.casttype) = "HintFlags"]; } -// TODO(jlapacik): Remove this message -message ReadRequest {} - message Aggregate { enum AggregateType { option (gogoproto.goproto_enum_prefix) = false; @@ -186,9 +168,6 @@ message CapabilitiesResponse { map caps = 1; } -message HintsResponse { -} - // Specifies a continuous range of nanosecond timestamps. message TimestampRange { // Start defines the inclusive lower bound. diff --git a/storage/reads/reader.go b/storage/reads/reader.go index 76bd10d91e..b867da53e2 100644 --- a/storage/reads/reader.go +++ b/storage/reads/reader.go @@ -31,10 +31,6 @@ func NewReader(s Store) influxdb.Reader { return &storeReader{s: s} } -func (r *storeReader) Read(ctx context.Context, rs influxdb.ReadSpec, start, stop execute.Time, alloc *memory.Allocator) (influxdb.TableIterator, error) { - return nil, nil -} - func (r *storeReader) ReadFilter(ctx context.Context, spec influxdb.ReadFilterSpec, alloc *memory.Allocator) (influxdb.TableIterator, error) { return &filterIterator{ ctx: ctx, @@ -378,14 +374,8 @@ func convertGroupMode(m influxdb.GroupMode) datatypes.ReadGroupRequest_Group { return datatypes.GroupNone case influxdb.GroupModeBy: return datatypes.GroupBy - case influxdb.GroupModeExcept: - return datatypes.GroupExcept - - case influxdb.GroupModeDefault, influxdb.GroupModeAll: - fallthrough - default: - return datatypes.GroupAll } + panic(fmt.Sprint("invalid group mode: ", m)) } const ( diff --git a/storage/reads/store.go b/storage/reads/store.go index dedb6be19e..8918794b37 100644 --- a/storage/reads/store.go +++ b/storage/reads/store.go @@ -80,8 +80,5 @@ type Store interface { TagKeys(ctx context.Context, req *datatypes.TagKeysRequest) (cursors.StringIterator, error) TagValues(ctx context.Context, req *datatypes.TagValuesRequest) (cursors.StringIterator, error) - // Deprecated method; should use ReadFilter and ReadGroup instead. - Read(ctx context.Context, req *datatypes.ReadRequest) (ResultSet, error) - GetSource(orgID, bucketID uint64) proto.Message } diff --git a/storage/reads/stream_reader.go b/storage/reads/stream_reader.go index 88e15b3141..b7b87bde34 100644 --- a/storage/reads/stream_reader.go +++ b/storage/reads/stream_reader.go @@ -9,6 +9,7 @@ import ( "github.com/influxdata/influxdb/models" "github.com/influxdata/influxdb/storage/reads/datatypes" "github.com/influxdata/influxdb/tsdb/cursors" + "google.golang.org/grpc" "google.golang.org/grpc/metadata" ) @@ -44,23 +45,28 @@ func (*emptyStatistics) Stats() cursors.CursorStats { return cursors.CursorStats{} } -// StorageReadClient adapts a Storage_ReadClient to implement cursors.Statistics -// and read the statistics from the gRPC trailer. +type StreamClient interface { + StreamReader + grpc.ClientStream +} + +// StorageReadClient adapts a grpc client to implement the cursors.Statistics +// interface and read the statistics from the gRPC trailer. type StorageReadClient struct { - c datatypes.Storage_ReadClient + client StreamClient trailer metadata.MD } // NewStorageReadClient returns a new StorageReadClient which implements // StreamReader and reads the gRPC trailer to return CursorStats. -func NewStorageReadClient(c datatypes.Storage_ReadClient) *StorageReadClient { - return &StorageReadClient{c: c} +func NewStorageReadClient(client StreamClient) *StorageReadClient { + return &StorageReadClient{client: client} } func (rc *StorageReadClient) Recv() (res *datatypes.ReadResponse, err error) { - res, err = rc.c.Recv() + res, err = rc.client.Recv() if err != nil { - rc.trailer = rc.c.Trailer() + rc.trailer = rc.client.Trailer() } return res, err } diff --git a/storage/readservice/store.go b/storage/readservice/store.go index a4371e717d..0461345293 100644 --- a/storage/readservice/store.go +++ b/storage/readservice/store.go @@ -67,10 +67,6 @@ func (s *store) ReadGroup(ctx context.Context, req *datatypes.ReadGroupRequest) return reads.NewGroupResultSet(ctx, req, newCursor), nil } -func (s *store) Read(ctx context.Context, req *datatypes.ReadRequest) (reads.ResultSet, error) { - return nil, nil -} - func (s *store) TagKeys(ctx context.Context, req *datatypes.TagKeysRequest) (cursors.StringIterator, error) { span, _ := tracing.StartSpanFromContext(ctx) defer span.Finish()