Influxdata
/
influxdb
mirror of https://github.com/influxdata/influxdb.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

refactor(storage): remove Read method from Store interface

pull/13736/head
jlapacik 2019-05-02 17:28:21 -07:00
parent 7333847e2a
commit faab75968b
7 changed files with 169 additions and 660 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
query/stdlib/influxdata/influxdb/storage.go
View File

@ -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()
}

642
storage/reads/datatypes/storage_common.pb.go
View File

@ -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,
}
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

25
storage/reads/datatypes/storage_common.proto
View File

@ -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<string, string> caps = 1;
}
message HintsResponse {
}
// Specifies a continuous range of nanosecond timestamps.
message TimestampRange {
// Start defines the inclusive lower bound.

12
storage/reads/reader.go
View File

@ -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 (

3
storage/reads/store.go
View File

@ -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
}

20
storage/reads/stream_reader.go
View File

@ -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
}

4
storage/readservice/store.go
View File

@ -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()