diff --git a/pkg/ingester/client/ingester.pb.go b/pkg/ingester/client/ingester.pb.go index 5439674039..a1ad1b6a7b 100644 --- a/pkg/ingester/client/ingester.pb.go +++ b/pkg/ingester/client/ingester.pb.go @@ -85,54 +85,6 @@ func (MatchType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_60f6df4f3586b478, []int{1} } -type ReadRequest_ResponseType int32 - -const ( - SAMPLES ReadRequest_ResponseType = 0 - STREAMED_XOR_CHUNKS ReadRequest_ResponseType = 1 -) - -var ReadRequest_ResponseType_name = map[int32]string{ - 0: "SAMPLES", - 1: "STREAMED_XOR_CHUNKS", -} - -var ReadRequest_ResponseType_value = map[string]int32{ - "SAMPLES": 0, - "STREAMED_XOR_CHUNKS": 1, -} - -func (ReadRequest_ResponseType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{6, 0} -} - -type StreamChunk_Encoding int32 - -const ( - UNKNOWN StreamChunk_Encoding = 0 - XOR StreamChunk_Encoding = 1 - HISTOGRAM StreamChunk_Encoding = 2 - FLOAT_HISTOGRAM StreamChunk_Encoding = 3 -) - -var StreamChunk_Encoding_name = map[int32]string{ - 0: "UNKNOWN", - 1: "XOR", - 2: "HISTOGRAM", - 3: "FLOAT_HISTOGRAM", -} - -var StreamChunk_Encoding_value = map[string]int32{ - "UNKNOWN": 0, - "XOR": 1, - "HISTOGRAM": 2, - "FLOAT_HISTOGRAM": 3, -} - -func (StreamChunk_Encoding) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{10, 0} -} - type ActiveSeriesRequest_RequestType int32 const ( @@ -151,7 +103,7 @@ var ActiveSeriesRequest_RequestType_value = map[string]int32{ } func (ActiveSeriesRequest_RequestType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{13, 0} + return fileDescriptor_60f6df4f3586b478, []int{8, 0} } type LabelNamesAndValuesRequest struct { @@ -452,255 +404,6 @@ func (m *LabelValueSeriesCount) GetLabelValueSeries() map[string]uint64 { return nil } -type ReadRequest struct { - Queries []*QueryRequest `protobuf:"bytes,1,rep,name=queries,proto3" json:"queries,omitempty"` - AcceptedResponseTypes []ReadRequest_ResponseType `protobuf:"varint,2,rep,packed,name=accepted_response_types,json=acceptedResponseTypes,proto3,enum=cortex.ReadRequest_ResponseType" json:"accepted_response_types,omitempty"` -} - -func (m *ReadRequest) Reset() { *m = ReadRequest{} } -func (*ReadRequest) ProtoMessage() {} -func (*ReadRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{6} -} -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.MarshalToSizedBuffer(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 - -func (m *ReadRequest) GetQueries() []*QueryRequest { - if m != nil { - return m.Queries - } - return nil -} - -func (m *ReadRequest) GetAcceptedResponseTypes() []ReadRequest_ResponseType { - if m != nil { - return m.AcceptedResponseTypes - } - return nil -} - -type ReadResponse struct { - Results []*QueryResponse `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"` -} - -func (m *ReadResponse) Reset() { *m = ReadResponse{} } -func (*ReadResponse) ProtoMessage() {} -func (*ReadResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{7} -} -func (m *ReadResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ReadResponse.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *ReadResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ReadResponse.Merge(m, src) -} -func (m *ReadResponse) XXX_Size() int { - return m.Size() -} -func (m *ReadResponse) XXX_DiscardUnknown() { - xxx_messageInfo_ReadResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_ReadResponse proto.InternalMessageInfo - -func (m *ReadResponse) GetResults() []*QueryResponse { - if m != nil { - return m.Results - } - return nil -} - -type StreamReadResponse struct { - ChunkedSeries []*StreamChunkedSeries `protobuf:"bytes,1,rep,name=chunked_series,json=chunkedSeries,proto3" json:"chunked_series,omitempty"` - QueryIndex int64 `protobuf:"varint,2,opt,name=query_index,json=queryIndex,proto3" json:"query_index,omitempty"` -} - -func (m *StreamReadResponse) Reset() { *m = StreamReadResponse{} } -func (*StreamReadResponse) ProtoMessage() {} -func (*StreamReadResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{8} -} -func (m *StreamReadResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StreamReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StreamReadResponse.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *StreamReadResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_StreamReadResponse.Merge(m, src) -} -func (m *StreamReadResponse) XXX_Size() int { - return m.Size() -} -func (m *StreamReadResponse) XXX_DiscardUnknown() { - xxx_messageInfo_StreamReadResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_StreamReadResponse proto.InternalMessageInfo - -func (m *StreamReadResponse) GetChunkedSeries() []*StreamChunkedSeries { - if m != nil { - return m.ChunkedSeries - } - return nil -} - -func (m *StreamReadResponse) GetQueryIndex() int64 { - if m != nil { - return m.QueryIndex - } - return 0 -} - -type StreamChunkedSeries struct { - Labels []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"labels"` - Chunks []StreamChunk `protobuf:"bytes,2,rep,name=chunks,proto3" json:"chunks"` -} - -func (m *StreamChunkedSeries) Reset() { *m = StreamChunkedSeries{} } -func (*StreamChunkedSeries) ProtoMessage() {} -func (*StreamChunkedSeries) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{9} -} -func (m *StreamChunkedSeries) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StreamChunkedSeries) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StreamChunkedSeries.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *StreamChunkedSeries) XXX_Merge(src proto.Message) { - xxx_messageInfo_StreamChunkedSeries.Merge(m, src) -} -func (m *StreamChunkedSeries) XXX_Size() int { - return m.Size() -} -func (m *StreamChunkedSeries) XXX_DiscardUnknown() { - xxx_messageInfo_StreamChunkedSeries.DiscardUnknown(m) -} - -var xxx_messageInfo_StreamChunkedSeries proto.InternalMessageInfo - -func (m *StreamChunkedSeries) GetChunks() []StreamChunk { - if m != nil { - return m.Chunks - } - return nil -} - -type StreamChunk struct { - MinTimeMs int64 `protobuf:"varint,1,opt,name=min_time_ms,json=minTimeMs,proto3" json:"min_time_ms,omitempty"` - MaxTimeMs int64 `protobuf:"varint,2,opt,name=max_time_ms,json=maxTimeMs,proto3" json:"max_time_ms,omitempty"` - Type StreamChunk_Encoding `protobuf:"varint,3,opt,name=type,proto3,enum=cortex.StreamChunk_Encoding" json:"type,omitempty"` - Data github_com_grafana_mimir_pkg_mimirpb.UnsafeByteSlice `protobuf:"bytes,4,opt,name=data,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.UnsafeByteSlice" json:"data"` -} - -func (m *StreamChunk) Reset() { *m = StreamChunk{} } -func (*StreamChunk) ProtoMessage() {} -func (*StreamChunk) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{10} -} -func (m *StreamChunk) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StreamChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StreamChunk.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *StreamChunk) XXX_Merge(src proto.Message) { - xxx_messageInfo_StreamChunk.Merge(m, src) -} -func (m *StreamChunk) XXX_Size() int { - return m.Size() -} -func (m *StreamChunk) XXX_DiscardUnknown() { - xxx_messageInfo_StreamChunk.DiscardUnknown(m) -} - -var xxx_messageInfo_StreamChunk proto.InternalMessageInfo - -func (m *StreamChunk) GetMinTimeMs() int64 { - if m != nil { - return m.MinTimeMs - } - return 0 -} - -func (m *StreamChunk) GetMaxTimeMs() int64 { - if m != nil { - return m.MaxTimeMs - } - return 0 -} - -func (m *StreamChunk) GetType() StreamChunk_Encoding { - if m != nil { - return m.Type - } - return UNKNOWN -} - type QueryRequest struct { StartTimestampMs int64 `protobuf:"varint,1,opt,name=start_timestamp_ms,json=startTimestampMs,proto3" json:"start_timestamp_ms,omitempty"` EndTimestampMs int64 `protobuf:"varint,2,opt,name=end_timestamp_ms,json=endTimestampMs,proto3" json:"end_timestamp_ms,omitempty"` @@ -712,7 +415,7 @@ type QueryRequest struct { func (m *QueryRequest) Reset() { *m = QueryRequest{} } func (*QueryRequest) ProtoMessage() {} func (*QueryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{11} + return fileDescriptor_60f6df4f3586b478, []int{6} } func (m *QueryRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -778,7 +481,7 @@ type ExemplarQueryRequest struct { func (m *ExemplarQueryRequest) Reset() { *m = ExemplarQueryRequest{} } func (*ExemplarQueryRequest) ProtoMessage() {} func (*ExemplarQueryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{12} + return fileDescriptor_60f6df4f3586b478, []int{7} } func (m *ExemplarQueryRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -836,7 +539,7 @@ type ActiveSeriesRequest struct { func (m *ActiveSeriesRequest) Reset() { *m = ActiveSeriesRequest{} } func (*ActiveSeriesRequest) ProtoMessage() {} func (*ActiveSeriesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{13} + return fileDescriptor_60f6df4f3586b478, []int{8} } func (m *ActiveSeriesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -886,7 +589,7 @@ type QueryResponse struct { func (m *QueryResponse) Reset() { *m = QueryResponse{} } func (*QueryResponse) ProtoMessage() {} func (*QueryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{14} + return fileDescriptor_60f6df4f3586b478, []int{9} } func (m *QueryResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -941,7 +644,7 @@ type QueryStreamResponse struct { func (m *QueryStreamResponse) Reset() { *m = QueryStreamResponse{} } func (*QueryStreamResponse) ProtoMessage() {} func (*QueryStreamResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{15} + return fileDescriptor_60f6df4f3586b478, []int{10} } func (m *QueryStreamResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1013,7 +716,7 @@ type QueryStreamSeries struct { func (m *QueryStreamSeries) Reset() { *m = QueryStreamSeries{} } func (*QueryStreamSeries) ProtoMessage() {} func (*QueryStreamSeries) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{16} + return fileDescriptor_60f6df4f3586b478, []int{11} } func (m *QueryStreamSeries) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1057,7 +760,7 @@ type QueryStreamSeriesChunks struct { func (m *QueryStreamSeriesChunks) Reset() { *m = QueryStreamSeriesChunks{} } func (*QueryStreamSeriesChunks) ProtoMessage() {} func (*QueryStreamSeriesChunks) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{17} + return fileDescriptor_60f6df4f3586b478, []int{12} } func (m *QueryStreamSeriesChunks) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1107,7 +810,7 @@ type ExemplarQueryResponse struct { func (m *ExemplarQueryResponse) Reset() { *m = ExemplarQueryResponse{} } func (*ExemplarQueryResponse) ProtoMessage() {} func (*ExemplarQueryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{18} + return fileDescriptor_60f6df4f3586b478, []int{13} } func (m *ExemplarQueryResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1153,7 +856,7 @@ type LabelValuesRequest struct { func (m *LabelValuesRequest) Reset() { *m = LabelValuesRequest{} } func (*LabelValuesRequest) ProtoMessage() {} func (*LabelValuesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{19} + return fileDescriptor_60f6df4f3586b478, []int{14} } func (m *LabelValuesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1217,7 +920,7 @@ type LabelValuesResponse struct { func (m *LabelValuesResponse) Reset() { *m = LabelValuesResponse{} } func (*LabelValuesResponse) ProtoMessage() {} func (*LabelValuesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{20} + return fileDescriptor_60f6df4f3586b478, []int{15} } func (m *LabelValuesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1262,7 +965,7 @@ type LabelNamesRequest struct { func (m *LabelNamesRequest) Reset() { *m = LabelNamesRequest{} } func (*LabelNamesRequest) ProtoMessage() {} func (*LabelNamesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{21} + return fileDescriptor_60f6df4f3586b478, []int{16} } func (m *LabelNamesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1319,7 +1022,7 @@ type LabelNamesResponse struct { func (m *LabelNamesResponse) Reset() { *m = LabelNamesResponse{} } func (*LabelNamesResponse) ProtoMessage() {} func (*LabelNamesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{22} + return fileDescriptor_60f6df4f3586b478, []int{17} } func (m *LabelNamesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1362,7 +1065,7 @@ type UserStatsRequest struct { func (m *UserStatsRequest) Reset() { *m = UserStatsRequest{} } func (*UserStatsRequest) ProtoMessage() {} func (*UserStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{23} + return fileDescriptor_60f6df4f3586b478, []int{18} } func (m *UserStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1408,7 +1111,7 @@ type UserStatsResponse struct { func (m *UserStatsResponse) Reset() { *m = UserStatsResponse{} } func (*UserStatsResponse) ProtoMessage() {} func (*UserStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{24} + return fileDescriptor_60f6df4f3586b478, []int{19} } func (m *UserStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1473,7 +1176,7 @@ type UserIDStatsResponse struct { func (m *UserIDStatsResponse) Reset() { *m = UserIDStatsResponse{} } func (*UserIDStatsResponse) ProtoMessage() {} func (*UserIDStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{25} + return fileDescriptor_60f6df4f3586b478, []int{20} } func (m *UserIDStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1523,7 +1226,7 @@ type UsersStatsResponse struct { func (m *UsersStatsResponse) Reset() { *m = UsersStatsResponse{} } func (*UsersStatsResponse) ProtoMessage() {} func (*UsersStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{26} + return fileDescriptor_60f6df4f3586b478, []int{21} } func (m *UsersStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1568,7 +1271,7 @@ type MetricsForLabelMatchersRequest struct { func (m *MetricsForLabelMatchersRequest) Reset() { *m = MetricsForLabelMatchersRequest{} } func (*MetricsForLabelMatchersRequest) ProtoMessage() {} func (*MetricsForLabelMatchersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{27} + return fileDescriptor_60f6df4f3586b478, []int{22} } func (m *MetricsForLabelMatchersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1625,7 +1328,7 @@ type MetricsForLabelMatchersResponse struct { func (m *MetricsForLabelMatchersResponse) Reset() { *m = MetricsForLabelMatchersResponse{} } func (*MetricsForLabelMatchersResponse) ProtoMessage() {} func (*MetricsForLabelMatchersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{28} + return fileDescriptor_60f6df4f3586b478, []int{23} } func (m *MetricsForLabelMatchersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1670,7 +1373,7 @@ type MetricsMetadataRequest struct { func (m *MetricsMetadataRequest) Reset() { *m = MetricsMetadataRequest{} } func (*MetricsMetadataRequest) ProtoMessage() {} func (*MetricsMetadataRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{29} + return fileDescriptor_60f6df4f3586b478, []int{24} } func (m *MetricsMetadataRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1727,7 +1430,7 @@ type MetricsMetadataResponse struct { func (m *MetricsMetadataResponse) Reset() { *m = MetricsMetadataResponse{} } func (*MetricsMetadataResponse) ProtoMessage() {} func (*MetricsMetadataResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{30} + return fileDescriptor_60f6df4f3586b478, []int{25} } func (m *MetricsMetadataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1773,7 +1476,7 @@ type ActiveSeriesResponse struct { func (m *ActiveSeriesResponse) Reset() { *m = ActiveSeriesResponse{} } func (*ActiveSeriesResponse) ProtoMessage() {} func (*ActiveSeriesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{31} + return fileDescriptor_60f6df4f3586b478, []int{26} } func (m *ActiveSeriesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1826,7 +1529,7 @@ type TimeSeriesChunk struct { func (m *TimeSeriesChunk) Reset() { *m = TimeSeriesChunk{} } func (*TimeSeriesChunk) ProtoMessage() {} func (*TimeSeriesChunk) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{32} + return fileDescriptor_60f6df4f3586b478, []int{27} } func (m *TimeSeriesChunk) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1886,7 +1589,7 @@ type Chunk struct { func (m *Chunk) Reset() { *m = Chunk{} } func (*Chunk) ProtoMessage() {} func (*Chunk) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{33} + return fileDescriptor_60f6df4f3586b478, []int{28} } func (m *Chunk) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1943,7 +1646,7 @@ type LabelMatchers struct { func (m *LabelMatchers) Reset() { *m = LabelMatchers{} } func (*LabelMatchers) ProtoMessage() {} func (*LabelMatchers) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{34} + return fileDescriptor_60f6df4f3586b478, []int{29} } func (m *LabelMatchers) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1988,7 +1691,7 @@ type LabelMatcher struct { func (m *LabelMatcher) Reset() { *m = LabelMatcher{} } func (*LabelMatcher) ProtoMessage() {} func (*LabelMatcher) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{35} + return fileDescriptor_60f6df4f3586b478, []int{30} } func (m *LabelMatcher) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2048,7 +1751,7 @@ type TimeSeriesFile struct { func (m *TimeSeriesFile) Reset() { *m = TimeSeriesFile{} } func (*TimeSeriesFile) ProtoMessage() {} func (*TimeSeriesFile) Descriptor() ([]byte, []int) { - return fileDescriptor_60f6df4f3586b478, []int{36} + return fileDescriptor_60f6df4f3586b478, []int{31} } func (m *TimeSeriesFile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2108,8 +1811,6 @@ func (m *TimeSeriesFile) GetData() []byte { func init() { proto.RegisterEnum("cortex.CountMethod", CountMethod_name, CountMethod_value) proto.RegisterEnum("cortex.MatchType", MatchType_name, MatchType_value) - proto.RegisterEnum("cortex.ReadRequest_ResponseType", ReadRequest_ResponseType_name, ReadRequest_ResponseType_value) - proto.RegisterEnum("cortex.StreamChunk_Encoding", StreamChunk_Encoding_name, StreamChunk_Encoding_value) proto.RegisterEnum("cortex.ActiveSeriesRequest_RequestType", ActiveSeriesRequest_RequestType_name, ActiveSeriesRequest_RequestType_value) proto.RegisterType((*LabelNamesAndValuesRequest)(nil), "cortex.LabelNamesAndValuesRequest") proto.RegisterType((*LabelNamesAndValuesResponse)(nil), "cortex.LabelNamesAndValuesResponse") @@ -2118,11 +1819,6 @@ func init() { proto.RegisterType((*LabelValuesCardinalityResponse)(nil), "cortex.LabelValuesCardinalityResponse") proto.RegisterType((*LabelValueSeriesCount)(nil), "cortex.LabelValueSeriesCount") proto.RegisterMapType((map[string]uint64)(nil), "cortex.LabelValueSeriesCount.LabelValueSeriesEntry") - proto.RegisterType((*ReadRequest)(nil), "cortex.ReadRequest") - proto.RegisterType((*ReadResponse)(nil), "cortex.ReadResponse") - proto.RegisterType((*StreamReadResponse)(nil), "cortex.StreamReadResponse") - proto.RegisterType((*StreamChunkedSeries)(nil), "cortex.StreamChunkedSeries") - proto.RegisterType((*StreamChunk)(nil), "cortex.StreamChunk") proto.RegisterType((*QueryRequest)(nil), "cortex.QueryRequest") proto.RegisterType((*ExemplarQueryRequest)(nil), "cortex.ExemplarQueryRequest") proto.RegisterType((*ActiveSeriesRequest)(nil), "cortex.ActiveSeriesRequest") @@ -2154,136 +1850,119 @@ func init() { func init() { proto.RegisterFile("ingester.proto", fileDescriptor_60f6df4f3586b478) } var fileDescriptor_60f6df4f3586b478 = []byte{ - // 2064 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x59, 0xcd, 0x6f, 0x1b, 0xc7, - 0x15, 0xe7, 0xf0, 0x43, 0x12, 0x1f, 0x29, 0x9a, 0x1a, 0x4a, 0x26, 0xb3, 0x8a, 0x29, 0x65, 0x0b, - 0x27, 0x6a, 0x9a, 0x50, 0xfe, 0x6a, 0xe0, 0xa4, 0x29, 0x02, 0x4a, 0xa2, 0x2d, 0xda, 0xa6, 0xa8, - 0x2c, 0xa9, 0xc4, 0x2d, 0x10, 0x2c, 0x96, 0xe4, 0x48, 0x5a, 0x88, 0xbb, 0x64, 0x76, 0x97, 0x81, - 0x94, 0x53, 0x81, 0x02, 0x3d, 0xf7, 0xd6, 0x4b, 0x51, 0xa0, 0xb7, 0xa2, 0xa7, 0xa2, 0x97, 0x5e, - 0x8a, 0x9e, 0x73, 0x09, 0xe0, 0x63, 0x50, 0xa0, 0x46, 0x2d, 0xf7, 0xd0, 0xde, 0x02, 0xf4, 0x1f, - 0x08, 0xe6, 0x63, 0x3f, 0xb9, 0xfa, 0x70, 0x10, 0xfb, 0x24, 0xce, 0xfb, 0x9a, 0xdf, 0x7b, 0xf3, - 0xe6, 0xbd, 0x37, 0x2b, 0x28, 0xe8, 0xe6, 0x01, 0xb1, 0x1d, 0x62, 0xd5, 0xc6, 0xd6, 0xc8, 0x19, - 0xe1, 0x99, 0xfe, 0xc8, 0x72, 0xc8, 0xb1, 0xf4, 0xee, 0x81, 0xee, 0x1c, 0x4e, 0x7a, 0xb5, 0xfe, - 0xc8, 0x58, 0x3f, 0x18, 0x1d, 0x8c, 0xd6, 0x19, 0xbb, 0x37, 0xd9, 0x67, 0x2b, 0xb6, 0x60, 0xbf, - 0xb8, 0x9a, 0x74, 0x23, 0x28, 0x6e, 0x69, 0xfb, 0x9a, 0xa9, 0xad, 0x1b, 0xba, 0xa1, 0x5b, 0xeb, - 0xe3, 0xa3, 0x03, 0xfe, 0x6b, 0xdc, 0xe3, 0x7f, 0xb9, 0x86, 0xfc, 0x1b, 0x04, 0xd2, 0x23, 0xad, - 0x47, 0x86, 0x3b, 0x9a, 0x41, 0xec, 0xba, 0x39, 0xf8, 0x44, 0x1b, 0x4e, 0x88, 0xad, 0x90, 0xcf, - 0x27, 0xc4, 0x76, 0xf0, 0x0d, 0x98, 0x33, 0x34, 0xa7, 0x7f, 0x48, 0x2c, 0xbb, 0x82, 0x56, 0x53, - 0x6b, 0xb9, 0x5b, 0x8b, 0x35, 0x0e, 0xad, 0xc6, 0xb4, 0x5a, 0x9c, 0xa9, 0x78, 0x52, 0xf8, 0x3d, - 0xc8, 0xf7, 0x47, 0x13, 0xd3, 0x51, 0x0d, 0xe2, 0x1c, 0x8e, 0x06, 0x95, 0xe4, 0x2a, 0x5a, 0x2b, - 0xdc, 0x2a, 0xb9, 0x5a, 0x9b, 0x94, 0xd7, 0x62, 0x2c, 0x25, 0xd7, 0xf7, 0x17, 0xf2, 0x36, 0x2c, - 0xc7, 0xe2, 0xb0, 0xc7, 0x23, 0xd3, 0x26, 0xf8, 0xc7, 0x90, 0xd1, 0x1d, 0x62, 0xb8, 0x28, 0x4a, - 0x21, 0x14, 0x42, 0x96, 0x4b, 0xc8, 0x5b, 0x90, 0x0b, 0x50, 0xf1, 0x35, 0x80, 0x21, 0x5d, 0xaa, - 0xa6, 0x66, 0x90, 0x0a, 0x5a, 0x45, 0x6b, 0x59, 0x25, 0x3b, 0x74, 0xb7, 0xc2, 0x57, 0x61, 0xe6, - 0x0b, 0x26, 0x58, 0x49, 0xae, 0xa6, 0xd6, 0xb2, 0x8a, 0x58, 0xc9, 0x7f, 0x46, 0x70, 0x2d, 0x60, - 0x66, 0x53, 0xb3, 0x06, 0xba, 0xa9, 0x0d, 0x75, 0xe7, 0xc4, 0x8d, 0xcd, 0x0a, 0xe4, 0x7c, 0xc3, - 0x1c, 0x58, 0x56, 0x01, 0xcf, 0xb2, 0x1d, 0x0a, 0x5e, 0xf2, 0x7b, 0x05, 0x2f, 0x75, 0xc9, 0xe0, - 0xed, 0x41, 0xf5, 0x2c, 0xac, 0x22, 0x7e, 0xb7, 0xc3, 0xf1, 0xbb, 0x36, 0x1d, 0xbf, 0x0e, 0xb1, - 0x74, 0x62, 0xb3, 0x2d, 0xdc, 0x48, 0x3e, 0x45, 0xb0, 0x14, 0x2b, 0x70, 0x51, 0x50, 0x35, 0xc0, - 0x9c, 0xcd, 0x82, 0xa9, 0xda, 0x4c, 0x53, 0xc4, 0xe0, 0xf6, 0xb9, 0x5b, 0x4f, 0x51, 0x1b, 0xa6, - 0x63, 0x9d, 0x28, 0xc5, 0x61, 0x84, 0x2c, 0x6d, 0x4e, 0x43, 0x63, 0xa2, 0xb8, 0x08, 0xa9, 0x23, - 0x72, 0x22, 0x30, 0xd1, 0x9f, 0x78, 0x11, 0x32, 0x0c, 0x07, 0xcb, 0xc5, 0xb4, 0xc2, 0x17, 0x1f, - 0x24, 0xef, 0x22, 0xf9, 0x6b, 0x04, 0x39, 0x85, 0x68, 0x03, 0xf7, 0x48, 0x6b, 0x30, 0xfb, 0xf9, - 0x84, 0x83, 0x8d, 0x64, 0xfb, 0xc7, 0x13, 0x62, 0xb9, 0x27, 0xaf, 0xb8, 0x42, 0xf8, 0x31, 0x94, - 0xb5, 0x7e, 0x9f, 0x8c, 0x1d, 0x32, 0x50, 0x2d, 0x11, 0x6a, 0xd5, 0x39, 0x19, 0x0b, 0x67, 0x0b, - 0xb7, 0x56, 0x5d, 0xfd, 0xc0, 0x2e, 0x35, 0xf7, 0x50, 0xba, 0x27, 0x63, 0xa2, 0x2c, 0xb9, 0x06, - 0x82, 0x54, 0x5b, 0xbe, 0x03, 0xf9, 0x20, 0x01, 0xe7, 0x60, 0xb6, 0x53, 0x6f, 0xed, 0x3e, 0x6a, - 0x74, 0x8a, 0x09, 0x5c, 0x86, 0x52, 0xa7, 0xab, 0x34, 0xea, 0xad, 0xc6, 0x96, 0xfa, 0xb8, 0xad, - 0xa8, 0x9b, 0xdb, 0x7b, 0x3b, 0x0f, 0x3b, 0x45, 0x24, 0x7f, 0x44, 0xb5, 0x34, 0xcf, 0x14, 0x5e, - 0x87, 0x59, 0x8b, 0xd8, 0x93, 0xa1, 0xe3, 0xfa, 0xb3, 0x14, 0xf1, 0x87, 0xcb, 0x29, 0xae, 0x94, - 0x7c, 0x02, 0xb8, 0xe3, 0x58, 0x44, 0x33, 0x42, 0x66, 0x36, 0xa0, 0xd0, 0x3f, 0x9c, 0x98, 0x47, - 0x64, 0xe0, 0x1e, 0x25, 0xb7, 0xb6, 0xec, 0x5a, 0xe3, 0x3a, 0x9b, 0x5c, 0x86, 0x1f, 0x86, 0x32, - 0xdf, 0x0f, 0x2e, 0xe9, 0x6d, 0xa1, 0x51, 0x3b, 0x51, 0x75, 0x73, 0x40, 0x8e, 0xd9, 0x51, 0xa4, - 0x14, 0x60, 0xa4, 0x26, 0xa5, 0xc8, 0x7f, 0x41, 0x50, 0x8a, 0xb1, 0x83, 0xf7, 0x61, 0x86, 0x1d, - 0x7e, 0xf4, 0xea, 0x8f, 0x7b, 0x3c, 0x57, 0x76, 0x35, 0xdd, 0xda, 0x78, 0xff, 0xab, 0xa7, 0x2b, - 0x89, 0x7f, 0x3e, 0x5d, 0xb9, 0x79, 0x99, 0x02, 0xc8, 0xf5, 0xea, 0x03, 0x6d, 0xec, 0x10, 0x4b, - 0x11, 0xd6, 0xf1, 0x4d, 0x98, 0x61, 0x88, 0xdd, 0x3c, 0x2d, 0xc5, 0x38, 0xb7, 0x91, 0xa6, 0xfb, - 0x28, 0x42, 0x50, 0xfe, 0x5d, 0x12, 0x72, 0x01, 0x2e, 0xae, 0x42, 0xce, 0xd0, 0x4d, 0xd5, 0xd1, - 0x0d, 0xa2, 0xb2, 0xab, 0x46, 0x7d, 0xcc, 0x1a, 0xba, 0xd9, 0xd5, 0x0d, 0xd2, 0xb2, 0x19, 0x5f, - 0x3b, 0xf6, 0xf8, 0x49, 0xc1, 0xd7, 0x8e, 0x05, 0xff, 0x06, 0xa4, 0x69, 0xf2, 0x88, 0x6b, 0xff, - 0x7a, 0x0c, 0x80, 0x5a, 0xc3, 0xec, 0x8f, 0x06, 0xba, 0x79, 0xa0, 0x30, 0x49, 0xbc, 0x0b, 0xe9, - 0x81, 0xe6, 0x68, 0x95, 0xf4, 0x2a, 0x5a, 0xcb, 0x6f, 0x7c, 0x28, 0xa2, 0x70, 0xe7, 0x52, 0x51, - 0xd8, 0x33, 0x6d, 0x6d, 0x9f, 0x6c, 0x9c, 0x38, 0xa4, 0x33, 0xd4, 0xfb, 0x44, 0x61, 0x96, 0xe4, - 0x2d, 0x98, 0x73, 0xf7, 0xa0, 0x49, 0xb7, 0xb7, 0xf3, 0x70, 0xa7, 0xfd, 0xe9, 0x4e, 0x31, 0x81, - 0x67, 0x21, 0xf5, 0xb8, 0xad, 0x14, 0x11, 0x9e, 0x87, 0xec, 0x76, 0xb3, 0xd3, 0x6d, 0xdf, 0x57, - 0xea, 0xad, 0x62, 0x12, 0x97, 0xe0, 0xca, 0xbd, 0x47, 0xed, 0x7a, 0x57, 0xf5, 0x89, 0x29, 0xf9, - 0x3f, 0x08, 0xf2, 0xc1, 0x2b, 0x83, 0xdf, 0x01, 0x6c, 0x3b, 0x9a, 0xe5, 0x30, 0xe7, 0x6d, 0x47, - 0x33, 0xc6, 0x7e, 0x84, 0x8a, 0x8c, 0xd3, 0x75, 0x19, 0x2d, 0x1b, 0xaf, 0x41, 0x91, 0x98, 0x83, - 0xb0, 0x2c, 0x8f, 0x56, 0x81, 0x98, 0x83, 0xa0, 0x64, 0xb0, 0xc6, 0xa6, 0x2e, 0x55, 0x63, 0x7f, - 0x0e, 0xcb, 0x36, 0x0b, 0xa8, 0x6e, 0x1e, 0xa8, 0xfc, 0x20, 0xd5, 0x1e, 0x65, 0xaa, 0xb6, 0xfe, - 0x25, 0xa9, 0x0c, 0x58, 0x8d, 0xa8, 0x78, 0x22, 0x2c, 0xec, 0xf6, 0x06, 0x15, 0xe8, 0xe8, 0x5f, - 0x92, 0x07, 0xe9, 0xb9, 0x74, 0x31, 0xa3, 0x64, 0x0e, 0x75, 0xd3, 0xb1, 0xe5, 0x3f, 0x22, 0x58, - 0x6c, 0x1c, 0x13, 0x63, 0x3c, 0xd4, 0xac, 0x57, 0xe2, 0xee, 0xcd, 0x29, 0x77, 0x97, 0xe2, 0xdc, - 0xb5, 0x7d, 0x7f, 0xe5, 0xbf, 0x23, 0x28, 0xd5, 0xfb, 0x8e, 0xfe, 0x85, 0xa8, 0x92, 0xdf, 0xbf, - 0xb5, 0xff, 0x4c, 0xa4, 0x27, 0x6f, 0xe9, 0x6f, 0xb9, 0xd2, 0x31, 0xc6, 0x6b, 0xe2, 0x2f, 0xab, - 0x70, 0x4c, 0x49, 0x7e, 0x8f, 0x56, 0x5a, 0x8f, 0x88, 0x01, 0x66, 0x3a, 0x0d, 0xa5, 0xc9, 0xca, - 0xd9, 0x32, 0x94, 0x77, 0xea, 0xdd, 0xe6, 0x27, 0x0d, 0x3f, 0x85, 0x54, 0xc1, 0x44, 0xf2, 0x43, - 0x98, 0x0f, 0xd5, 0x2a, 0xfc, 0x01, 0x00, 0x0b, 0x54, 0x5c, 0x99, 0x1e, 0xf7, 0x6a, 0x34, 0x5a, - 0x1c, 0x8b, 0xb8, 0xac, 0x01, 0x69, 0xf9, 0xff, 0x49, 0x28, 0x31, 0x6b, 0x6e, 0x91, 0x13, 0x36, - 0x3f, 0x82, 0x1c, 0xcf, 0x84, 0xa0, 0xd1, 0xb2, 0xeb, 0xa0, 0x6f, 0x32, 0x58, 0x04, 0x82, 0x1a, - 0x11, 0x50, 0xc9, 0x17, 0x01, 0x85, 0x1f, 0x40, 0xd1, 0x4f, 0x48, 0x61, 0x81, 0x9f, 0xed, 0x6b, - 0xa1, 0x6a, 0xcd, 0x31, 0x87, 0xcc, 0x5c, 0xf1, 0x14, 0x45, 0xb1, 0xbc, 0x03, 0x65, 0xdd, 0x56, - 0x69, 0x32, 0x8d, 0xf6, 0x85, 0x2d, 0x95, 0xcb, 0xb0, 0x12, 0x31, 0xa7, 0x94, 0x74, 0xbb, 0x61, - 0x0e, 0xda, 0xfb, 0x5c, 0x9e, 0x9b, 0xc4, 0x9f, 0x41, 0x39, 0x8a, 0x40, 0xdc, 0x8c, 0x4a, 0x86, - 0x01, 0x59, 0x39, 0x13, 0x88, 0xb8, 0x1e, 0x1c, 0xce, 0x52, 0x04, 0x0e, 0x67, 0xca, 0xbf, 0x47, - 0xb0, 0x30, 0xa5, 0xf8, 0xca, 0xea, 0xfa, 0x8a, 0x38, 0x5b, 0x95, 0x0d, 0x4c, 0x6e, 0xe3, 0x61, - 0x24, 0x36, 0x71, 0xc8, 0x3a, 0x94, 0xcf, 0x70, 0x0b, 0xbf, 0x01, 0x79, 0x11, 0x0e, 0xde, 0xb5, - 0x10, 0x2b, 0x0e, 0x39, 0x4e, 0x63, 0x6d, 0x0b, 0xff, 0x24, 0xd2, 0x36, 0xe6, 0xbd, 0x61, 0x2d, - 0xa6, 0x61, 0x74, 0x60, 0x29, 0x52, 0x2e, 0x7e, 0x80, 0xa4, 0xfe, 0x07, 0x02, 0x1c, 0x1c, 0x83, - 0xc5, 0xfd, 0xbe, 0x60, 0x44, 0x8b, 0xaf, 0x50, 0xc9, 0x17, 0xa8, 0x50, 0xa9, 0x0b, 0x2b, 0x14, - 0x4d, 0xb9, 0x4b, 0x54, 0xa8, 0xbb, 0x50, 0x0a, 0xe1, 0x17, 0x31, 0x79, 0x03, 0xf2, 0x81, 0x21, - 0xd2, 0x1d, 0xb0, 0x73, 0xfe, 0x24, 0x68, 0xcb, 0x7f, 0x40, 0xb0, 0xe0, 0xbf, 0x1a, 0x5e, 0x6d, - 0xf1, 0xbd, 0x94, 0x6b, 0x3f, 0x15, 0x47, 0x23, 0xf0, 0x09, 0xcf, 0x2e, 0x7a, 0x39, 0xc8, 0x0f, - 0xa0, 0xb8, 0x67, 0x13, 0xab, 0xe3, 0x68, 0x8e, 0xe7, 0x55, 0xf4, 0x6d, 0x80, 0x2e, 0xf9, 0x36, - 0xf8, 0x1b, 0x82, 0x85, 0x80, 0x31, 0x01, 0xe1, 0xba, 0xfb, 0xe4, 0xd4, 0x47, 0xa6, 0x6a, 0x69, - 0x0e, 0xcf, 0x10, 0xa4, 0xcc, 0x7b, 0x54, 0x45, 0x73, 0x08, 0x4d, 0x22, 0x73, 0x62, 0xf8, 0x03, - 0x3c, 0x4d, 0xff, 0xac, 0x39, 0x71, 0xef, 0xf0, 0x3b, 0x80, 0xb5, 0xb1, 0xae, 0x46, 0x2c, 0xa5, - 0x98, 0xa5, 0xa2, 0x36, 0xd6, 0x9b, 0x21, 0x63, 0x35, 0x28, 0x59, 0x93, 0x21, 0x89, 0x8a, 0xa7, - 0x99, 0xf8, 0x02, 0x65, 0x85, 0xe4, 0xe5, 0xcf, 0xa0, 0x44, 0x81, 0x37, 0xb7, 0xc2, 0xd0, 0xcb, - 0x30, 0x3b, 0xb1, 0x89, 0xa5, 0xea, 0x03, 0x91, 0xd5, 0x33, 0x74, 0xd9, 0x1c, 0xe0, 0x77, 0xc5, - 0x30, 0x94, 0x64, 0x67, 0xe3, 0x15, 0xcf, 0x29, 0xe7, 0xc5, 0xa4, 0x73, 0x1f, 0x30, 0x65, 0xd9, - 0x61, 0xeb, 0x37, 0x21, 0x63, 0x53, 0x42, 0x74, 0xc4, 0x8d, 0x41, 0xa2, 0x70, 0x49, 0xf9, 0xaf, - 0x08, 0xaa, 0x2d, 0xe2, 0x58, 0x7a, 0xdf, 0xbe, 0x37, 0xb2, 0xc2, 0xa9, 0xf0, 0x92, 0x53, 0xf2, - 0x2e, 0xe4, 0xdd, 0x5c, 0x53, 0x6d, 0xe2, 0x9c, 0x3f, 0x13, 0xe4, 0x5c, 0xd1, 0x0e, 0x71, 0xe4, - 0x87, 0xb0, 0x72, 0x26, 0x66, 0x11, 0x8a, 0x35, 0x98, 0x31, 0x98, 0x88, 0x88, 0x45, 0xd1, 0x2f, - 0x48, 0x5c, 0x55, 0x11, 0x7c, 0x79, 0x0c, 0x57, 0x85, 0xb1, 0x16, 0x71, 0x34, 0x1a, 0x5d, 0xd7, - 0xf1, 0x45, 0xc8, 0x0c, 0x75, 0x43, 0x77, 0x98, 0xaf, 0x0b, 0x0a, 0x5f, 0x50, 0x07, 0xd9, 0x0f, - 0x75, 0x4c, 0x2c, 0x55, 0xec, 0x91, 0x64, 0x02, 0x05, 0x46, 0xdf, 0x25, 0x16, 0xb7, 0x47, 0x9f, - 0xe7, 0x82, 0x9f, 0xe2, 0x67, 0x2d, 0x76, 0x6c, 0x43, 0x79, 0x6a, 0x47, 0x01, 0xfb, 0x0e, 0xcc, - 0x19, 0x82, 0x26, 0x80, 0x57, 0xa2, 0xc0, 0x3d, 0x1d, 0x4f, 0x52, 0xee, 0xc3, 0x62, 0x78, 0x90, - 0x79, 0xd1, 0x20, 0xd0, 0x7a, 0xd5, 0x9b, 0xf4, 0x8f, 0x88, 0xe3, 0x75, 0x9a, 0x14, 0x6d, 0x16, - 0x9c, 0xc6, 0x5b, 0xcd, 0xff, 0x10, 0x5c, 0x89, 0x4c, 0x13, 0x34, 0x16, 0xfb, 0xd6, 0xc8, 0x50, - 0xdd, 0x2f, 0x40, 0x7e, 0x5e, 0x17, 0x28, 0xbd, 0x29, 0xc8, 0xcd, 0x41, 0x30, 0xf1, 0x93, 0xa1, - 0xc4, 0xf7, 0x5b, 0x69, 0xea, 0xa5, 0xb6, 0x52, 0xbf, 0xd7, 0xa5, 0x2f, 0xee, 0x75, 0x5f, 0x23, - 0xc8, 0x70, 0x0f, 0x5f, 0x56, 0xf2, 0x4b, 0x30, 0x47, 0xc4, 0x53, 0x85, 0x65, 0x47, 0x46, 0xf1, - 0xd6, 0x2f, 0xe1, 0x61, 0x54, 0x87, 0xf9, 0xd0, 0x35, 0x79, 0xf1, 0x01, 0x5a, 0x56, 0x21, 0x1f, - 0xe4, 0xe0, 0xeb, 0x62, 0xa0, 0xe6, 0xa5, 0x7c, 0xc1, 0xd5, 0x66, 0x6c, 0x7f, 0x74, 0xc6, 0x18, - 0xd2, 0xac, 0x87, 0xf3, 0x43, 0x67, 0xbf, 0xfd, 0x6f, 0x1a, 0xfc, 0x5a, 0xf0, 0x85, 0xfc, 0x6b, - 0x04, 0x05, 0x3f, 0xbf, 0xee, 0xe9, 0x43, 0xf2, 0x43, 0xa4, 0x97, 0x04, 0x73, 0xfb, 0xfa, 0x90, - 0x30, 0x0c, 0x7c, 0x3b, 0x6f, 0x4d, 0xb1, 0xf9, 0x71, 0xe6, 0x91, 0x7a, 0x7b, 0x0d, 0x72, 0x81, - 0x6e, 0x44, 0xdf, 0x8b, 0xcd, 0x1d, 0xb5, 0xd5, 0x68, 0xb5, 0x95, 0x5f, 0x14, 0x13, 0x74, 0xf2, - 0xaf, 0x6f, 0xd2, 0x69, 0xbf, 0x88, 0xde, 0x7e, 0x00, 0x59, 0xcf, 0x59, 0x9c, 0x85, 0x4c, 0xe3, - 0xe3, 0xbd, 0xfa, 0xa3, 0x62, 0x82, 0xaa, 0xec, 0xb4, 0xbb, 0x2a, 0x5f, 0x22, 0x7c, 0x05, 0x72, - 0x4a, 0xe3, 0x7e, 0xe3, 0xb1, 0xda, 0xaa, 0x77, 0x37, 0xb7, 0x8b, 0x49, 0x8c, 0xa1, 0xc0, 0x09, - 0x3b, 0x6d, 0x41, 0x4b, 0xdd, 0xfa, 0xd7, 0x2c, 0xcc, 0xb9, 0xde, 0xe0, 0xf7, 0x21, 0xbd, 0x3b, - 0xb1, 0x0f, 0xf1, 0x55, 0xff, 0x26, 0x7c, 0x6a, 0xe9, 0x0e, 0x11, 0x65, 0x49, 0x2a, 0x4f, 0xd1, - 0xf9, 0x75, 0x97, 0x13, 0x78, 0x0b, 0x72, 0x81, 0x71, 0x10, 0xc7, 0x7e, 0x01, 0x92, 0x96, 0x63, - 0x06, 0x62, 0xdf, 0xc6, 0x0d, 0x84, 0xdb, 0x50, 0x60, 0x2c, 0x77, 0xdc, 0xb3, 0xb1, 0xf7, 0x9c, - 0x8f, 0x7b, 0x30, 0x4a, 0xd7, 0xce, 0xe0, 0x7a, 0xb0, 0xb6, 0xc3, 0x5f, 0x35, 0xa5, 0xb8, 0x0f, - 0xa0, 0x51, 0x70, 0x31, 0x53, 0x95, 0x9c, 0xc0, 0x0d, 0x00, 0x7f, 0x26, 0xc1, 0xaf, 0x85, 0x84, - 0x83, 0x73, 0x94, 0x24, 0xc5, 0xb1, 0x3c, 0x33, 0x1b, 0x90, 0xf5, 0x3a, 0x2b, 0xae, 0xc4, 0x34, - 0x5b, 0x6e, 0xe4, 0xec, 0x36, 0x2c, 0x27, 0xf0, 0x3d, 0xc8, 0xd7, 0x87, 0xc3, 0xcb, 0x98, 0x91, - 0x82, 0x1c, 0x3b, 0x6a, 0x67, 0xe8, 0x75, 0x83, 0x68, 0x33, 0xc3, 0x6f, 0x7a, 0xb7, 0xea, 0xdc, - 0x0e, 0x2d, 0xbd, 0x75, 0xa1, 0x9c, 0xb7, 0x5b, 0x17, 0xae, 0x44, 0x7a, 0x0f, 0xae, 0x46, 0xb4, - 0x23, 0x6d, 0x50, 0x5a, 0x39, 0x93, 0xef, 0x59, 0xed, 0x89, 0x29, 0x38, 0xfc, 0x01, 0x1c, 0xcb, - 0xd3, 0x87, 0x10, 0xfd, 0x4a, 0x2f, 0xfd, 0xe8, 0x5c, 0x99, 0x40, 0x56, 0x1e, 0xc1, 0xd5, 0xf8, - 0xef, 0xc4, 0xf8, 0x7a, 0x4c, 0xce, 0x4c, 0x7f, 0xf3, 0x96, 0xde, 0xbc, 0x48, 0x2c, 0xb0, 0x59, - 0x0b, 0xf2, 0xc1, 0x8e, 0x8a, 0x97, 0xcf, 0xf9, 0x60, 0x20, 0xbd, 0x1e, 0xcf, 0xf4, 0xcd, 0x6d, - 0x7c, 0xf8, 0xe4, 0x59, 0x35, 0xf1, 0xcd, 0xb3, 0x6a, 0xe2, 0xdb, 0x67, 0x55, 0xf4, 0xab, 0xd3, - 0x2a, 0xfa, 0xd3, 0x69, 0x15, 0x7d, 0x75, 0x5a, 0x45, 0x4f, 0x4e, 0xab, 0xe8, 0xdf, 0xa7, 0x55, - 0xf4, 0xdf, 0xd3, 0x6a, 0xe2, 0xdb, 0xd3, 0x2a, 0xfa, 0xed, 0xf3, 0x6a, 0xe2, 0xc9, 0xf3, 0x6a, - 0xe2, 0x9b, 0xe7, 0xd5, 0xc4, 0x2f, 0x67, 0xfa, 0x43, 0x9d, 0x98, 0x4e, 0x6f, 0x86, 0xfd, 0xbb, - 0xe3, 0xf6, 0x77, 0x01, 0x00, 0x00, 0xff, 0xff, 0x17, 0xc5, 0xfb, 0x24, 0x69, 0x19, 0x00, 0x00, + // 1790 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6f, 0x1b, 0xc7, + 0x15, 0xe7, 0xf0, 0x2b, 0xe2, 0x23, 0x25, 0x53, 0x43, 0xd9, 0x64, 0x56, 0xf1, 0x4a, 0xd9, 0xc2, + 0x09, 0x9b, 0x26, 0xf2, 0x67, 0x03, 0x27, 0x4d, 0x51, 0x50, 0x32, 0x6d, 0xd3, 0x09, 0x25, 0x67, + 0x29, 0xa7, 0x1f, 0x40, 0xb0, 0x58, 0x92, 0x43, 0x69, 0xa0, 0xdd, 0x25, 0xbb, 0x3b, 0x0c, 0xac, + 0x9c, 0x0a, 0x14, 0xe8, 0xb9, 0x7f, 0x40, 0x51, 0xa0, 0xb7, 0xa2, 0xc7, 0x5e, 0x7a, 0x29, 0x7a, + 0xce, 0xa5, 0x80, 0x8f, 0x41, 0x81, 0x1a, 0xb5, 0xdc, 0x43, 0x7b, 0x0b, 0xd0, 0x7f, 0xa0, 0xd8, + 0x99, 0xd9, 0x4f, 0x52, 0x12, 0x1d, 0xc4, 0x3e, 0x71, 0xe7, 0x7d, 0xcd, 0xef, 0xbd, 0x79, 0xf3, + 0xde, 0xe3, 0xc0, 0x0a, 0x75, 0x0e, 0x88, 0xc7, 0x88, 0xbb, 0x35, 0x71, 0xc7, 0x6c, 0x8c, 0x8b, + 0x83, 0xb1, 0xcb, 0xc8, 0x63, 0xe5, 0xbd, 0x03, 0xca, 0x0e, 0xa7, 0xfd, 0xad, 0xc1, 0xd8, 0xbe, + 0x7a, 0x30, 0x3e, 0x18, 0x5f, 0xe5, 0xec, 0xfe, 0x74, 0xc4, 0x57, 0x7c, 0xc1, 0xbf, 0x84, 0x9a, + 0x72, 0x2d, 0x2e, 0xee, 0x9a, 0x23, 0xd3, 0x31, 0xaf, 0xda, 0xd4, 0xa6, 0xee, 0xd5, 0xc9, 0xd1, + 0x81, 0xf8, 0x9a, 0xf4, 0xc5, 0xaf, 0xd0, 0xd0, 0x7e, 0x83, 0x40, 0xf9, 0xc4, 0xec, 0x13, 0x6b, + 0xd7, 0xb4, 0x89, 0xd7, 0x72, 0x86, 0x9f, 0x99, 0xd6, 0x94, 0x78, 0x3a, 0xf9, 0xe5, 0x94, 0x78, + 0x0c, 0x5f, 0x83, 0x25, 0xdb, 0x64, 0x83, 0x43, 0xe2, 0x7a, 0x0d, 0xb4, 0x99, 0x6b, 0x96, 0x6f, + 0xac, 0x6d, 0x09, 0x68, 0x5b, 0x5c, 0xab, 0x2b, 0x98, 0x7a, 0x28, 0x85, 0xdf, 0x87, 0xca, 0x60, + 0x3c, 0x75, 0x98, 0x61, 0x13, 0x76, 0x38, 0x1e, 0x36, 0xb2, 0x9b, 0xa8, 0xb9, 0x72, 0xa3, 0x16, + 0x68, 0xed, 0xf8, 0xbc, 0x2e, 0x67, 0xe9, 0xe5, 0x41, 0xb4, 0xd0, 0xee, 0xc3, 0xfa, 0x5c, 0x1c, + 0xde, 0x64, 0xec, 0x78, 0x04, 0x7f, 0x1f, 0x0a, 0x94, 0x11, 0x3b, 0x40, 0x51, 0x4b, 0xa0, 0x90, + 0xb2, 0x42, 0x42, 0xbb, 0x03, 0xe5, 0x18, 0x15, 0x5f, 0x06, 0xb0, 0xfc, 0xa5, 0xe1, 0x98, 0x36, + 0x69, 0xa0, 0x4d, 0xd4, 0x2c, 0xe9, 0x25, 0x2b, 0xd8, 0x0a, 0x5f, 0x82, 0xe2, 0x17, 0x5c, 0xb0, + 0x91, 0xdd, 0xcc, 0x35, 0x4b, 0xba, 0x5c, 0x69, 0x7f, 0x42, 0x70, 0x39, 0x66, 0x66, 0xc7, 0x74, + 0x87, 0xd4, 0x31, 0x2d, 0xca, 0x8e, 0x83, 0xd8, 0x6c, 0x40, 0x39, 0x32, 0x2c, 0x80, 0x95, 0x74, + 0x08, 0x2d, 0x7b, 0x89, 0xe0, 0x65, 0xbf, 0x55, 0xf0, 0x72, 0x0b, 0x06, 0xef, 0x11, 0xa8, 0xa7, + 0x61, 0x95, 0xf1, 0xbb, 0x99, 0x8c, 0xdf, 0xe5, 0xd9, 0xf8, 0xf5, 0x88, 0x4b, 0x89, 0xc7, 0xb7, + 0x08, 0x22, 0xf9, 0x14, 0xc1, 0xc5, 0xb9, 0x02, 0xe7, 0x05, 0xd5, 0x04, 0x2c, 0xd8, 0x3c, 0x98, + 0x86, 0xc7, 0x35, 0x65, 0x0c, 0x6e, 0x9e, 0xb9, 0xf5, 0x0c, 0xb5, 0xed, 0x30, 0xf7, 0x58, 0xaf, + 0x5a, 0x29, 0xb2, 0xb2, 0x33, 0x0b, 0x8d, 0x8b, 0xe2, 0x2a, 0xe4, 0x8e, 0xc8, 0xb1, 0xc4, 0xe4, + 0x7f, 0xe2, 0x35, 0x28, 0x70, 0x1c, 0x3c, 0x17, 0xf3, 0xba, 0x58, 0x7c, 0x98, 0xbd, 0x8d, 0xb4, + 0x7f, 0x23, 0xa8, 0x7c, 0x3a, 0x25, 0x6e, 0x78, 0xa6, 0xef, 0x02, 0xf6, 0x98, 0xe9, 0x32, 0x83, + 0x51, 0x9b, 0x78, 0xcc, 0xb4, 0x27, 0x06, 0x8f, 0x19, 0x6a, 0xe6, 0xf4, 0x2a, 0xe7, 0xec, 0x07, + 0x8c, 0xae, 0x87, 0x9b, 0x50, 0x25, 0xce, 0x30, 0x29, 0x9b, 0xe5, 0xb2, 0x2b, 0xc4, 0x19, 0xc6, + 0x25, 0xe3, 0xa9, 0x90, 0x5b, 0x28, 0x15, 0x7e, 0x0c, 0xeb, 0x1e, 0x73, 0x89, 0x69, 0x53, 0xe7, + 0xc0, 0x18, 0x1c, 0x4e, 0x9d, 0x23, 0xcf, 0xe8, 0xfb, 0x4c, 0xc3, 0xa3, 0x5f, 0x92, 0xc6, 0x90, + 0xbb, 0xd2, 0x08, 0x45, 0x76, 0xb8, 0xc4, 0xb6, 0x2f, 0xd0, 0xa3, 0x5f, 0x92, 0x07, 0xf9, 0xa5, + 0x7c, 0xb5, 0xa0, 0x17, 0x0e, 0xa9, 0xc3, 0x3c, 0xed, 0x0f, 0x08, 0xd6, 0xda, 0x8f, 0x89, 0x3d, + 0xb1, 0x4c, 0xf7, 0x95, 0xb8, 0x7b, 0x7d, 0xc6, 0xdd, 0x8b, 0xf3, 0xdc, 0xf5, 0x22, 0x7f, 0xb5, + 0xbf, 0x22, 0xa8, 0xb5, 0x06, 0x8c, 0x7e, 0x21, 0x0f, 0xf3, 0xdb, 0x57, 0xa0, 0x1f, 0x41, 0x9e, + 0x1d, 0x4f, 0x88, 0xac, 0x3c, 0x6f, 0x07, 0xd2, 0x73, 0x8c, 0x6f, 0xc9, 0xdf, 0xfd, 0xe3, 0x09, + 0xd1, 0xb9, 0x92, 0xf6, 0x3e, 0x94, 0x63, 0x44, 0x0c, 0x50, 0xec, 0xb5, 0xf5, 0x4e, 0xbb, 0x57, + 0xcd, 0xe0, 0x75, 0xa8, 0xef, 0xb6, 0xf6, 0x3b, 0x9f, 0xb5, 0x8d, 0xfb, 0x9d, 0xde, 0xfe, 0xde, + 0x3d, 0xbd, 0xd5, 0x35, 0x24, 0x13, 0x69, 0x1f, 0xc3, 0xb2, 0x8c, 0xac, 0xbc, 0x70, 0x1f, 0x02, + 0xf0, 0x40, 0x89, 0xd4, 0x4f, 0x22, 0x9f, 0xf4, 0xb7, 0xfc, 0x68, 0x09, 0x2c, 0xdb, 0xf9, 0xaf, + 0x9e, 0x6e, 0x64, 0xf4, 0x98, 0xb4, 0xf6, 0xbf, 0x2c, 0xd4, 0xb8, 0xb5, 0x1e, 0x3f, 0xde, 0xd0, + 0xe6, 0x4f, 0xa0, 0x2c, 0x32, 0x21, 0x6e, 0xb4, 0x1e, 0x38, 0x18, 0x99, 0xe4, 0xc9, 0x20, 0xed, + 0xc6, 0x35, 0x52, 0xa0, 0xb2, 0x2f, 0x02, 0x0a, 0x3f, 0x80, 0x6a, 0x94, 0x90, 0xd2, 0x82, 0x38, + 0xdb, 0xd7, 0x03, 0x04, 0x31, 0xcc, 0x09, 0x33, 0x17, 0x42, 0x45, 0x41, 0xc6, 0xb7, 0xa0, 0x4e, + 0x3d, 0xc3, 0x4f, 0xa6, 0xf1, 0x48, 0xda, 0x32, 0x84, 0x4c, 0x23, 0xbf, 0x89, 0x9a, 0x4b, 0x7a, + 0x8d, 0x7a, 0x6d, 0x67, 0xb8, 0x37, 0x12, 0xf2, 0xc2, 0x24, 0xfe, 0x1c, 0xea, 0x69, 0x04, 0xf2, + 0x66, 0x34, 0x0a, 0x1c, 0xc8, 0xc6, 0xa9, 0x40, 0xe4, 0xf5, 0x10, 0x70, 0x2e, 0xa6, 0xe0, 0x08, + 0xa6, 0xf6, 0x3b, 0x04, 0xab, 0x33, 0x8a, 0x78, 0x04, 0x45, 0x5e, 0x7b, 0xd2, 0x9d, 0x67, 0xd2, + 0x17, 0xf9, 0xf7, 0xd0, 0xa4, 0xee, 0xf6, 0x07, 0xbe, 0xdd, 0x7f, 0x3c, 0xdd, 0xb8, 0xbe, 0x48, + 0xff, 0x15, 0x7a, 0xad, 0xa1, 0x39, 0x61, 0xc4, 0xd5, 0xa5, 0x75, 0xbf, 0x9b, 0x70, 0x5f, 0x0c, + 0x5e, 0xd7, 0xe5, 0xbd, 0x02, 0x4e, 0xe2, 0x85, 0x51, 0xa3, 0x50, 0x3f, 0xc5, 0x2d, 0xfc, 0x26, + 0x54, 0x64, 0x38, 0xa8, 0x33, 0x24, 0x8f, 0xf9, 0x05, 0xce, 0xeb, 0x65, 0x41, 0xeb, 0xf8, 0x24, + 0xfc, 0x03, 0x28, 0xca, 0x50, 0x89, 0x53, 0x5f, 0x0e, 0x7b, 0x4a, 0x2c, 0x57, 0xa4, 0x88, 0xd6, + 0x83, 0x8b, 0xa9, 0x72, 0xf1, 0x1d, 0x24, 0xf5, 0xdf, 0x10, 0xe0, 0x78, 0xb7, 0x96, 0xf7, 0xfb, + 0x9c, 0x4e, 0x32, 0xbf, 0x42, 0x65, 0x5f, 0xa0, 0x42, 0xe5, 0xce, 0xad, 0x50, 0x7e, 0xca, 0x2d, + 0x50, 0xa1, 0x6e, 0x43, 0x2d, 0x81, 0x5f, 0xc6, 0xe4, 0x4d, 0xa8, 0xc4, 0x7a, 0x5d, 0x30, 0x07, + 0x94, 0xa3, 0x86, 0xe5, 0x69, 0xbf, 0x47, 0xb0, 0x1a, 0x0d, 0x37, 0xaf, 0xb6, 0xf8, 0x2e, 0xe4, + 0xda, 0x0f, 0xe5, 0xd1, 0x48, 0x7c, 0xd2, 0xb3, 0xf3, 0x06, 0x1c, 0xed, 0x01, 0x54, 0x1f, 0x79, + 0xc4, 0xed, 0x31, 0x93, 0x85, 0x5e, 0xa5, 0x47, 0x18, 0xb4, 0xe0, 0x08, 0xf3, 0x17, 0x04, 0xab, + 0x31, 0x63, 0x12, 0xc2, 0x95, 0x60, 0x32, 0xa6, 0x63, 0xc7, 0x70, 0x4d, 0x26, 0x32, 0x04, 0xe9, + 0xcb, 0x21, 0x55, 0x37, 0x19, 0xf1, 0x93, 0xc8, 0x99, 0xda, 0xd1, 0x9c, 0xe1, 0xa7, 0x7f, 0xc9, + 0x99, 0x06, 0x77, 0xf8, 0x5d, 0xc0, 0xe6, 0x84, 0x1a, 0x29, 0x4b, 0x39, 0x6e, 0xa9, 0x6a, 0x4e, + 0x68, 0x27, 0x61, 0x6c, 0x0b, 0x6a, 0xee, 0xd4, 0x22, 0x69, 0xf1, 0x3c, 0x17, 0x5f, 0xf5, 0x59, + 0x09, 0x79, 0xed, 0x73, 0xa8, 0xf9, 0xc0, 0x3b, 0x77, 0x92, 0xd0, 0xeb, 0xf0, 0xda, 0xd4, 0x23, + 0xae, 0x41, 0x87, 0x32, 0xab, 0x8b, 0xfe, 0xb2, 0x33, 0xc4, 0xef, 0x41, 0x7e, 0x68, 0x32, 0x93, + 0xc3, 0x8c, 0x15, 0xcf, 0x19, 0xe7, 0x75, 0x2e, 0xa6, 0xdd, 0x03, 0xec, 0xb3, 0xbc, 0xa4, 0xf5, + 0xeb, 0x50, 0xf0, 0x7c, 0x82, 0xbc, 0x84, 0xeb, 0x71, 0x2b, 0x29, 0x24, 0xba, 0x90, 0xd4, 0xfe, + 0x8c, 0x40, 0xed, 0x12, 0xe6, 0xd2, 0x81, 0x77, 0x77, 0xec, 0x26, 0x53, 0xe1, 0x25, 0xa7, 0xe4, + 0x6d, 0xa8, 0x04, 0xb9, 0x66, 0x78, 0x84, 0x9d, 0x3d, 0x13, 0x94, 0x03, 0xd1, 0x1e, 0x61, 0xda, + 0xc7, 0xb0, 0x71, 0x2a, 0x66, 0x19, 0x8a, 0x26, 0x14, 0x6d, 0x2e, 0x22, 0x63, 0x51, 0x8d, 0x0a, + 0x92, 0x50, 0xd5, 0x25, 0x5f, 0x9b, 0xc0, 0x25, 0x69, 0xac, 0x4b, 0x98, 0xe9, 0x47, 0x37, 0x70, + 0x7c, 0x0d, 0x0a, 0x16, 0xb5, 0x29, 0xe3, 0xbe, 0xae, 0xea, 0x62, 0xe1, 0x3b, 0xc8, 0x3f, 0x8c, + 0x09, 0x71, 0x0d, 0xb9, 0x47, 0x96, 0x0b, 0xac, 0x70, 0xfa, 0x43, 0xe2, 0x0a, 0x7b, 0xfe, 0xbf, + 0x08, 0xc9, 0xcf, 0x89, 0xb3, 0x96, 0x3b, 0xee, 0x41, 0x7d, 0x66, 0x47, 0x09, 0xfb, 0x16, 0x2c, + 0xd9, 0x92, 0x26, 0x81, 0x37, 0xd2, 0xc0, 0x43, 0x9d, 0x50, 0x52, 0x1b, 0xc0, 0x5a, 0x72, 0x90, + 0x79, 0xd1, 0x20, 0xf8, 0xf5, 0xaa, 0x3f, 0x1d, 0x1c, 0x11, 0x16, 0x76, 0x9a, 0x9c, 0xdf, 0x2c, + 0x04, 0x4d, 0xb4, 0x9a, 0xff, 0x22, 0xb8, 0x90, 0x9a, 0x26, 0xfc, 0x58, 0x8c, 0xdc, 0xb1, 0x6d, + 0x04, 0x7f, 0x54, 0xa3, 0xbc, 0x5e, 0xf1, 0xe9, 0x1d, 0x49, 0xee, 0x0c, 0xe3, 0x89, 0x9f, 0x4d, + 0x24, 0x7e, 0xd4, 0x4a, 0x73, 0x2f, 0xb5, 0x95, 0x46, 0xbd, 0x2e, 0x7f, 0x7e, 0xaf, 0xfb, 0x3b, + 0x82, 0x82, 0xf0, 0xf0, 0x65, 0x25, 0xbf, 0x02, 0x4b, 0xc4, 0x19, 0x8c, 0x87, 0xd4, 0x39, 0xe0, + 0xd9, 0x51, 0xd0, 0xc3, 0x35, 0x7e, 0x28, 0x6b, 0x81, 0x5f, 0x5c, 0x2a, 0xdb, 0x1f, 0x49, 0xdf, + 0x6f, 0x2d, 0xe4, 0xfb, 0x23, 0xc7, 0x33, 0x47, 0x64, 0xfb, 0x98, 0x91, 0x9e, 0x45, 0x07, 0x41, + 0xb9, 0x68, 0xc1, 0x72, 0xe2, 0x9a, 0xbc, 0xf8, 0x00, 0xad, 0x19, 0x50, 0x89, 0x73, 0xf0, 0x15, + 0x39, 0x50, 0x8b, 0x52, 0xbe, 0x1a, 0x68, 0x73, 0x76, 0x34, 0x3a, 0x63, 0x0c, 0x79, 0xde, 0xc3, + 0xc5, 0xa1, 0xf3, 0xef, 0xe8, 0xaf, 0x97, 0xb8, 0x16, 0x62, 0xa1, 0xfd, 0x1a, 0xc1, 0x4a, 0x94, + 0x5f, 0x77, 0xa9, 0x45, 0xbe, 0x8b, 0xf4, 0x52, 0x60, 0x69, 0x44, 0x2d, 0xc2, 0x31, 0x88, 0xed, + 0xc2, 0xb5, 0x8f, 0x2d, 0x8a, 0xb3, 0x88, 0xd4, 0x3b, 0x4d, 0x28, 0xc7, 0xba, 0x11, 0x5e, 0x86, + 0x52, 0x67, 0xd7, 0xe8, 0xb6, 0xbb, 0x7b, 0xfa, 0xcf, 0xab, 0x19, 0x7f, 0xf2, 0x6f, 0xed, 0xf8, + 0xd3, 0x7e, 0x15, 0xbd, 0xf3, 0x00, 0x4a, 0xa1, 0xb3, 0xb8, 0x04, 0x85, 0xf6, 0xa7, 0x8f, 0x5a, + 0x9f, 0x54, 0x33, 0xbe, 0xca, 0xee, 0xde, 0xbe, 0x21, 0x96, 0x08, 0x5f, 0x80, 0xb2, 0xde, 0xbe, + 0xd7, 0xfe, 0x99, 0xd1, 0x6d, 0xed, 0xef, 0xdc, 0xaf, 0x66, 0x31, 0x86, 0x15, 0x41, 0xd8, 0xdd, + 0x93, 0xb4, 0xdc, 0x8d, 0x7f, 0xbe, 0x06, 0x4b, 0x81, 0x37, 0xf8, 0x03, 0xc8, 0x3f, 0x9c, 0x7a, + 0x87, 0xf8, 0x52, 0x74, 0x13, 0x7e, 0xea, 0x52, 0x46, 0x64, 0x59, 0x52, 0xea, 0x33, 0x74, 0x71, + 0xdd, 0xb5, 0x0c, 0xbe, 0x03, 0xe5, 0xd8, 0x38, 0x88, 0xd7, 0x12, 0xa3, 0x6f, 0xa0, 0xbf, 0x3e, + 0x67, 0x20, 0x8e, 0x6c, 0x5c, 0x43, 0x78, 0x0f, 0x56, 0x38, 0x2b, 0x18, 0xf7, 0x3c, 0xfc, 0x46, + 0xa0, 0x32, 0xef, 0x0f, 0xa3, 0x72, 0xf9, 0x14, 0x6e, 0x08, 0xeb, 0x7e, 0xf2, 0xf1, 0x45, 0x99, + 0xf7, 0x4e, 0x93, 0x06, 0x37, 0x67, 0xaa, 0xd2, 0x32, 0xb8, 0x0d, 0x10, 0xcd, 0x24, 0xf8, 0xf5, + 0x84, 0x70, 0x7c, 0x8e, 0x52, 0x94, 0x79, 0xac, 0xd0, 0xcc, 0x36, 0x94, 0xc2, 0xce, 0x8a, 0x1b, + 0x73, 0x9a, 0xad, 0x30, 0x72, 0x7a, 0x1b, 0xd6, 0x32, 0xf8, 0x2e, 0x54, 0x5a, 0x96, 0xb5, 0x88, + 0x19, 0x25, 0xce, 0xf1, 0xd2, 0x76, 0xac, 0xb0, 0x1b, 0xa4, 0x9b, 0x19, 0x7e, 0x2b, 0xbc, 0x55, + 0x67, 0x76, 0x68, 0xe5, 0xed, 0x73, 0xe5, 0xc2, 0xdd, 0xf6, 0xe1, 0x42, 0xaa, 0xf7, 0x60, 0x35, + 0xa5, 0x9d, 0x6a, 0x83, 0xca, 0xc6, 0xa9, 0xfc, 0xd0, 0x6a, 0x5f, 0x4e, 0xc1, 0xc9, 0x77, 0x3a, + 0xac, 0xcd, 0x1e, 0x42, 0xfa, 0x31, 0x51, 0xf9, 0xde, 0x99, 0x32, 0xb1, 0xac, 0x3c, 0x82, 0x4b, + 0xf3, 0x9f, 0xb3, 0xf0, 0x95, 0x39, 0x39, 0x33, 0xfb, 0x34, 0xa7, 0xbc, 0x75, 0x9e, 0x58, 0x6c, + 0xb3, 0x2e, 0x54, 0xe2, 0x1d, 0x15, 0xaf, 0x9f, 0xf1, 0x60, 0xa0, 0xbc, 0x31, 0x9f, 0x19, 0x99, + 0xdb, 0xfe, 0xe8, 0xc9, 0x33, 0x35, 0xf3, 0xf5, 0x33, 0x35, 0xf3, 0xcd, 0x33, 0x15, 0xfd, 0xea, + 0x44, 0x45, 0x7f, 0x3c, 0x51, 0xd1, 0x57, 0x27, 0x2a, 0x7a, 0x72, 0xa2, 0xa2, 0x7f, 0x9d, 0xa8, + 0xe8, 0x3f, 0x27, 0x6a, 0xe6, 0x9b, 0x13, 0x15, 0xfd, 0xf6, 0xb9, 0x9a, 0x79, 0xf2, 0x5c, 0xcd, + 0x7c, 0xfd, 0x5c, 0xcd, 0xfc, 0xa2, 0x38, 0xb0, 0x28, 0x71, 0x58, 0xbf, 0xc8, 0x5f, 0x65, 0x6f, + 0xfe, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x38, 0x36, 0x00, 0x7c, 0x10, 0x16, 0x00, 0x00, } func (x CountMethod) String() string { @@ -2300,20 +1979,6 @@ func (x MatchType) String() string { } return strconv.Itoa(int(x)) } -func (x ReadRequest_ResponseType) String() string { - s, ok := ReadRequest_ResponseType_name[int32(x)] - if ok { - return s - } - return strconv.Itoa(int(x)) -} -func (x StreamChunk_Encoding) String() string { - s, ok := StreamChunk_Encoding_name[int32(x)] - if ok { - return s - } - return strconv.Itoa(int(x)) -} func (x ActiveSeriesRequest_RequestType) String() string { s, ok := ActiveSeriesRequest_RequestType_name[int32(x)] if ok { @@ -2515,14 +2180,14 @@ func (this *LabelValueSeriesCount) Equal(that interface{}) bool { } return true } -func (this *ReadRequest) Equal(that interface{}) bool { +func (this *QueryRequest) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*ReadRequest) + that1, ok := that.(*QueryRequest) if !ok { - that2, ok := that.(ReadRequest) + that2, ok := that.(QueryRequest) if ok { that1 = &that2 } else { @@ -2534,32 +2199,33 @@ func (this *ReadRequest) Equal(that interface{}) bool { } else if this == nil { return false } - if len(this.Queries) != len(that1.Queries) { + if this.StartTimestampMs != that1.StartTimestampMs { return false } - for i := range this.Queries { - if !this.Queries[i].Equal(that1.Queries[i]) { - return false - } + if this.EndTimestampMs != that1.EndTimestampMs { + return false } - if len(this.AcceptedResponseTypes) != len(that1.AcceptedResponseTypes) { + if len(this.Matchers) != len(that1.Matchers) { return false } - for i := range this.AcceptedResponseTypes { - if this.AcceptedResponseTypes[i] != that1.AcceptedResponseTypes[i] { + for i := range this.Matchers { + if !this.Matchers[i].Equal(that1.Matchers[i]) { return false } } + if this.StreamingChunksBatchSize != that1.StreamingChunksBatchSize { + return false + } return true } -func (this *ReadResponse) Equal(that interface{}) bool { +func (this *ExemplarQueryRequest) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*ReadResponse) + that1, ok := that.(*ExemplarQueryRequest) if !ok { - that2, ok := that.(ReadResponse) + that2, ok := that.(ExemplarQueryRequest) if ok { that1 = &that2 } else { @@ -2571,180 +2237,11 @@ func (this *ReadResponse) Equal(that interface{}) bool { } else if this == nil { return false } - if len(this.Results) != len(that1.Results) { + if this.StartTimestampMs != that1.StartTimestampMs { return false } - for i := range this.Results { - if !this.Results[i].Equal(that1.Results[i]) { - return false - } - } - return true -} -func (this *StreamReadResponse) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*StreamReadResponse) - if !ok { - that2, ok := that.(StreamReadResponse) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if len(this.ChunkedSeries) != len(that1.ChunkedSeries) { - return false - } - for i := range this.ChunkedSeries { - if !this.ChunkedSeries[i].Equal(that1.ChunkedSeries[i]) { - return false - } - } - if this.QueryIndex != that1.QueryIndex { - return false - } - return true -} -func (this *StreamChunkedSeries) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*StreamChunkedSeries) - if !ok { - that2, ok := that.(StreamChunkedSeries) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if len(this.Labels) != len(that1.Labels) { - return false - } - for i := range this.Labels { - if !this.Labels[i].Equal(that1.Labels[i]) { - return false - } - } - if len(this.Chunks) != len(that1.Chunks) { - return false - } - for i := range this.Chunks { - if !this.Chunks[i].Equal(&that1.Chunks[i]) { - return false - } - } - return true -} -func (this *StreamChunk) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*StreamChunk) - if !ok { - that2, ok := that.(StreamChunk) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.MinTimeMs != that1.MinTimeMs { - return false - } - if this.MaxTimeMs != that1.MaxTimeMs { - return false - } - if this.Type != that1.Type { - return false - } - if !this.Data.Equal(that1.Data) { - return false - } - return true -} -func (this *QueryRequest) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*QueryRequest) - if !ok { - that2, ok := that.(QueryRequest) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.StartTimestampMs != that1.StartTimestampMs { - return false - } - if this.EndTimestampMs != that1.EndTimestampMs { - return false - } - if len(this.Matchers) != len(that1.Matchers) { - return false - } - for i := range this.Matchers { - if !this.Matchers[i].Equal(that1.Matchers[i]) { - return false - } - } - if this.StreamingChunksBatchSize != that1.StreamingChunksBatchSize { - return false - } - return true -} -func (this *ExemplarQueryRequest) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ExemplarQueryRequest) - if !ok { - that2, ok := that.(ExemplarQueryRequest) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.StartTimestampMs != that1.StartTimestampMs { - return false - } - if this.EndTimestampMs != that1.EndTimestampMs { - return false + if this.EndTimestampMs != that1.EndTimestampMs { + return false } if len(this.Matchers) != len(that1.Matchers) { return false @@ -3613,74 +3110,6 @@ func (this *LabelValueSeriesCount) GoString() string { s = append(s, "}") return strings.Join(s, "") } -func (this *ReadRequest) GoString() string { - if this == nil { - return "nil" - } - s := make([]string, 0, 6) - s = append(s, "&client.ReadRequest{") - if this.Queries != nil { - s = append(s, "Queries: "+fmt.Sprintf("%#v", this.Queries)+",\n") - } - s = append(s, "AcceptedResponseTypes: "+fmt.Sprintf("%#v", this.AcceptedResponseTypes)+",\n") - s = append(s, "}") - return strings.Join(s, "") -} -func (this *ReadResponse) GoString() string { - if this == nil { - return "nil" - } - s := make([]string, 0, 5) - s = append(s, "&client.ReadResponse{") - if this.Results != nil { - s = append(s, "Results: "+fmt.Sprintf("%#v", this.Results)+",\n") - } - s = append(s, "}") - return strings.Join(s, "") -} -func (this *StreamReadResponse) GoString() string { - if this == nil { - return "nil" - } - s := make([]string, 0, 6) - s = append(s, "&client.StreamReadResponse{") - if this.ChunkedSeries != nil { - s = append(s, "ChunkedSeries: "+fmt.Sprintf("%#v", this.ChunkedSeries)+",\n") - } - s = append(s, "QueryIndex: "+fmt.Sprintf("%#v", this.QueryIndex)+",\n") - s = append(s, "}") - return strings.Join(s, "") -} -func (this *StreamChunkedSeries) GoString() string { - if this == nil { - return "nil" - } - s := make([]string, 0, 6) - s = append(s, "&client.StreamChunkedSeries{") - s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n") - if this.Chunks != nil { - vs := make([]*StreamChunk, len(this.Chunks)) - for i := range vs { - vs[i] = &this.Chunks[i] - } - s = append(s, "Chunks: "+fmt.Sprintf("%#v", vs)+",\n") - } - s = append(s, "}") - return strings.Join(s, "") -} -func (this *StreamChunk) GoString() string { - if this == nil { - return "nil" - } - s := make([]string, 0, 8) - s = append(s, "&client.StreamChunk{") - s = append(s, "MinTimeMs: "+fmt.Sprintf("%#v", this.MinTimeMs)+",\n") - s = append(s, "MaxTimeMs: "+fmt.Sprintf("%#v", this.MaxTimeMs)+",\n") - s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n") - s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") - s = append(s, "}") - return strings.Join(s, "") -} func (this *QueryRequest) GoString() string { if this == nil { return "nil" @@ -4907,7 +4336,7 @@ func (m *LabelValueSeriesCount) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ReadRequest) Marshal() (dAtA []byte, err error) { +func (m *QueryRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4917,38 +4346,27 @@ func (m *ReadRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ReadRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *QueryRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ReadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *QueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.AcceptedResponseTypes) > 0 { - dAtA2 := make([]byte, len(m.AcceptedResponseTypes)*10) - var j1 int - for _, num := range m.AcceptedResponseTypes { - for num >= 1<<7 { - dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j1++ - } - dAtA2[j1] = uint8(num) - j1++ - } - i -= j1 - copy(dAtA[i:], dAtA2[:j1]) - i = encodeVarintIngester(dAtA, i, uint64(j1)) + if m.StreamingChunksBatchSize != 0 { + i = encodeVarintIngester(dAtA, i, uint64(m.StreamingChunksBatchSize)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xa0 } - if len(m.Queries) > 0 { - for iNdEx := len(m.Queries) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Matchers) > 0 { + for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.Queries[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Matchers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4956,13 +4374,23 @@ func (m *ReadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintIngester(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x1a } } + if m.EndTimestampMs != 0 { + i = encodeVarintIngester(dAtA, i, uint64(m.EndTimestampMs)) + i-- + dAtA[i] = 0x10 + } + if m.StartTimestampMs != 0 { + i = encodeVarintIngester(dAtA, i, uint64(m.StartTimestampMs)) + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } -func (m *ReadResponse) Marshal() (dAtA []byte, err error) { +func (m *ExemplarQueryRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4972,20 +4400,20 @@ func (m *ReadResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ReadResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *ExemplarQueryRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ReadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ExemplarQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Results) > 0 { - for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Matchers) > 0 { + for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.Results[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Matchers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4993,13 +4421,23 @@ func (m *ReadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintIngester(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x1a } } + if m.EndTimestampMs != 0 { + i = encodeVarintIngester(dAtA, i, uint64(m.EndTimestampMs)) + i-- + dAtA[i] = 0x10 + } + if m.StartTimestampMs != 0 { + i = encodeVarintIngester(dAtA, i, uint64(m.StartTimestampMs)) + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } -func (m *StreamReadResponse) Marshal() (dAtA []byte, err error) { +func (m *ActiveSeriesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5009,25 +4447,25 @@ func (m *StreamReadResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *StreamReadResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *ActiveSeriesRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *StreamReadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActiveSeriesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.QueryIndex != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.QueryIndex)) + if m.Type != 0 { + i = encodeVarintIngester(dAtA, i, uint64(m.Type)) i-- dAtA[i] = 0x10 } - if len(m.ChunkedSeries) > 0 { - for iNdEx := len(m.ChunkedSeries) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Matchers) > 0 { + for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.ChunkedSeries[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Matchers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5041,7 +4479,7 @@ func (m *StreamReadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *StreamChunkedSeries) Marshal() (dAtA []byte, err error) { +func (m *QueryResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5051,254 +4489,12 @@ func (m *StreamChunkedSeries) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *StreamChunkedSeries) MarshalTo(dAtA []byte) (int, error) { +func (m *QueryResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *StreamChunkedSeries) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Chunks) > 0 { - for iNdEx := len(m.Chunks) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Chunks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintIngester(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if len(m.Labels) > 0 { - for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- { - { - size := m.Labels[iNdEx].Size() - i -= size - if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintIngester(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil -} - -func (m *StreamChunk) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *StreamChunk) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StreamChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.Data.Size() - i -= size - if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintIngester(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - if m.Type != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.Type)) - i-- - dAtA[i] = 0x18 - } - if m.MaxTimeMs != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.MaxTimeMs)) - i-- - dAtA[i] = 0x10 - } - if m.MinTimeMs != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.MinTimeMs)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *QueryRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *QueryRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *QueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.StreamingChunksBatchSize != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.StreamingChunksBatchSize)) - i-- - dAtA[i] = 0x6 - i-- - dAtA[i] = 0xa0 - } - if len(m.Matchers) > 0 { - for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Matchers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintIngester(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - } - if m.EndTimestampMs != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.EndTimestampMs)) - i-- - dAtA[i] = 0x10 - } - if m.StartTimestampMs != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.StartTimestampMs)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *ExemplarQueryRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *ExemplarQueryRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ExemplarQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Matchers) > 0 { - for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Matchers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintIngester(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - } - if m.EndTimestampMs != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.EndTimestampMs)) - i-- - dAtA[i] = 0x10 - } - if m.StartTimestampMs != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.StartTimestampMs)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *ActiveSeriesRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *ActiveSeriesRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ActiveSeriesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Type != 0 { - i = encodeVarintIngester(dAtA, i, uint64(m.Type)) - i-- - dAtA[i] = 0x10 - } - if len(m.Matchers) > 0 { - for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Matchers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintIngester(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil -} - -func (m *QueryResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *QueryResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *QueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *QueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6026,20 +5222,20 @@ func (m *ActiveSeriesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.BucketCount) > 0 { - dAtA7 := make([]byte, len(m.BucketCount)*10) - var j6 int + dAtA5 := make([]byte, len(m.BucketCount)*10) + var j4 int for _, num := range m.BucketCount { for num >= 1<<7 { - dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80) + dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j6++ + j4++ } - dAtA7[j6] = uint8(num) - j6++ + dAtA5[j4] = uint8(num) + j4++ } - i -= j6 - copy(dAtA[i:], dAtA7[:j6]) - i = encodeVarintIngester(dAtA, i, uint64(j6)) + i -= j4 + copy(dAtA[i:], dAtA5[:j4]) + i = encodeVarintIngester(dAtA, i, uint64(j4)) i-- dAtA[i] = 0x12 } @@ -6426,134 +5622,38 @@ func (m *LabelValueSeriesCount) Size() (n int) { return n } -func (m *ReadRequest) Size() (n int) { +func (m *QueryRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.Queries) > 0 { - for _, e := range m.Queries { + if m.StartTimestampMs != 0 { + n += 1 + sovIngester(uint64(m.StartTimestampMs)) + } + if m.EndTimestampMs != 0 { + n += 1 + sovIngester(uint64(m.EndTimestampMs)) + } + if len(m.Matchers) > 0 { + for _, e := range m.Matchers { l = e.Size() n += 1 + l + sovIngester(uint64(l)) } } - if len(m.AcceptedResponseTypes) > 0 { - l = 0 - for _, e := range m.AcceptedResponseTypes { - l += sovIngester(uint64(e)) - } - n += 1 + sovIngester(uint64(l)) + l + if m.StreamingChunksBatchSize != 0 { + n += 2 + sovIngester(uint64(m.StreamingChunksBatchSize)) } return n } -func (m *ReadResponse) Size() (n int) { +func (m *ExemplarQueryRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.Results) > 0 { - for _, e := range m.Results { - l = e.Size() - n += 1 + l + sovIngester(uint64(l)) - } - } - return n -} - -func (m *StreamReadResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.ChunkedSeries) > 0 { - for _, e := range m.ChunkedSeries { - l = e.Size() - n += 1 + l + sovIngester(uint64(l)) - } - } - if m.QueryIndex != 0 { - n += 1 + sovIngester(uint64(m.QueryIndex)) - } - return n -} - -func (m *StreamChunkedSeries) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Labels) > 0 { - for _, e := range m.Labels { - l = e.Size() - n += 1 + l + sovIngester(uint64(l)) - } - } - if len(m.Chunks) > 0 { - for _, e := range m.Chunks { - l = e.Size() - n += 1 + l + sovIngester(uint64(l)) - } - } - return n -} - -func (m *StreamChunk) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.MinTimeMs != 0 { - n += 1 + sovIngester(uint64(m.MinTimeMs)) - } - if m.MaxTimeMs != 0 { - n += 1 + sovIngester(uint64(m.MaxTimeMs)) - } - if m.Type != 0 { - n += 1 + sovIngester(uint64(m.Type)) - } - l = m.Data.Size() - n += 1 + l + sovIngester(uint64(l)) - return n -} - -func (m *QueryRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.StartTimestampMs != 0 { - n += 1 + sovIngester(uint64(m.StartTimestampMs)) - } - if m.EndTimestampMs != 0 { - n += 1 + sovIngester(uint64(m.EndTimestampMs)) - } - if len(m.Matchers) > 0 { - for _, e := range m.Matchers { - l = e.Size() - n += 1 + l + sovIngester(uint64(l)) - } - } - if m.StreamingChunksBatchSize != 0 { - n += 2 + sovIngester(uint64(m.StreamingChunksBatchSize)) - } - return n -} - -func (m *ExemplarQueryRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.StartTimestampMs != 0 { - n += 1 + sovIngester(uint64(m.StartTimestampMs)) + if m.StartTimestampMs != 0 { + n += 1 + sovIngester(uint64(m.StartTimestampMs)) } if m.EndTimestampMs != 0 { n += 1 + sovIngester(uint64(m.EndTimestampMs)) @@ -7126,82 +6226,6 @@ func (this *LabelValueSeriesCount) String() string { }, "") return s } -func (this *ReadRequest) String() string { - if this == nil { - return "nil" - } - repeatedStringForQueries := "[]*QueryRequest{" - for _, f := range this.Queries { - repeatedStringForQueries += strings.Replace(f.String(), "QueryRequest", "QueryRequest", 1) + "," - } - repeatedStringForQueries += "}" - s := strings.Join([]string{`&ReadRequest{`, - `Queries:` + repeatedStringForQueries + `,`, - `AcceptedResponseTypes:` + fmt.Sprintf("%v", this.AcceptedResponseTypes) + `,`, - `}`, - }, "") - return s -} -func (this *ReadResponse) String() string { - if this == nil { - return "nil" - } - repeatedStringForResults := "[]*QueryResponse{" - for _, f := range this.Results { - repeatedStringForResults += strings.Replace(f.String(), "QueryResponse", "QueryResponse", 1) + "," - } - repeatedStringForResults += "}" - s := strings.Join([]string{`&ReadResponse{`, - `Results:` + repeatedStringForResults + `,`, - `}`, - }, "") - return s -} -func (this *StreamReadResponse) String() string { - if this == nil { - return "nil" - } - repeatedStringForChunkedSeries := "[]*StreamChunkedSeries{" - for _, f := range this.ChunkedSeries { - repeatedStringForChunkedSeries += strings.Replace(f.String(), "StreamChunkedSeries", "StreamChunkedSeries", 1) + "," - } - repeatedStringForChunkedSeries += "}" - s := strings.Join([]string{`&StreamReadResponse{`, - `ChunkedSeries:` + repeatedStringForChunkedSeries + `,`, - `QueryIndex:` + fmt.Sprintf("%v", this.QueryIndex) + `,`, - `}`, - }, "") - return s -} -func (this *StreamChunkedSeries) String() string { - if this == nil { - return "nil" - } - repeatedStringForChunks := "[]StreamChunk{" - for _, f := range this.Chunks { - repeatedStringForChunks += strings.Replace(strings.Replace(f.String(), "StreamChunk", "StreamChunk", 1), `&`, ``, 1) + "," - } - repeatedStringForChunks += "}" - s := strings.Join([]string{`&StreamChunkedSeries{`, - `Labels:` + fmt.Sprintf("%v", this.Labels) + `,`, - `Chunks:` + repeatedStringForChunks + `,`, - `}`, - }, "") - return s -} -func (this *StreamChunk) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&StreamChunk{`, - `MinTimeMs:` + fmt.Sprintf("%v", this.MinTimeMs) + `,`, - `MaxTimeMs:` + fmt.Sprintf("%v", this.MaxTimeMs) + `,`, - `Type:` + fmt.Sprintf("%v", this.Type) + `,`, - `Data:` + fmt.Sprintf("%v", this.Data) + `,`, - `}`, - }, "") - return s -} func (this *QueryRequest) String() string { if this == nil { return "nil" @@ -8325,619 +7349,6 @@ func (m *LabelValueSeriesCount) 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 ErrIntOverflowIngester - } - 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 { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Queries", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthIngester - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthIngester - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Queries = append(m.Queries, &QueryRequest{}) - if err := m.Queries[len(m.Queries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType == 0 { - var v ReadRequest_ResponseType - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= ReadRequest_ResponseType(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.AcceptedResponseTypes = append(m.AcceptedResponseTypes, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthIngester - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthIngester - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - var elementCount int - if elementCount != 0 && len(m.AcceptedResponseTypes) == 0 { - m.AcceptedResponseTypes = make([]ReadRequest_ResponseType, 0, elementCount) - } - for iNdEx < postIndex { - var v ReadRequest_ResponseType - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= ReadRequest_ResponseType(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.AcceptedResponseTypes = append(m.AcceptedResponseTypes, v) - } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field AcceptedResponseTypes", wireType) - } - default: - iNdEx = preIndex - skippy, err := skipIngester(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ReadResponse) 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 ErrIntOverflowIngester - } - 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: ReadResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ReadResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthIngester - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthIngester - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Results = append(m.Results, &QueryResponse{}) - if err := m.Results[len(m.Results)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipIngester(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StreamReadResponse) 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 ErrIntOverflowIngester - } - 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: StreamReadResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StreamReadResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChunkedSeries", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthIngester - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthIngester - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ChunkedSeries = append(m.ChunkedSeries, &StreamChunkedSeries{}) - if err := m.ChunkedSeries[len(m.ChunkedSeries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field QueryIndex", wireType) - } - m.QueryIndex = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.QueryIndex |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipIngester(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StreamChunkedSeries) 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 ErrIntOverflowIngester - } - 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: StreamChunkedSeries: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StreamChunkedSeries: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthIngester - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthIngester - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Labels = append(m.Labels, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{}) - if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthIngester - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthIngester - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Chunks = append(m.Chunks, StreamChunk{}) - if err := m.Chunks[len(m.Chunks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipIngester(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StreamChunk) 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 ErrIntOverflowIngester - } - 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: StreamChunk: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StreamChunk: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MinTimeMs", wireType) - } - m.MinTimeMs = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MinTimeMs |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxTimeMs", wireType) - } - m.MaxTimeMs = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MaxTimeMs |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) - } - m.Type = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Type |= StreamChunk_Encoding(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowIngester - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthIngester - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthIngester - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipIngester(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthIngester - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *QueryRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/pkg/ingester/client/ingester.proto b/pkg/ingester/client/ingester.proto index 3cfc24e2d3..634746fea4 100644 --- a/pkg/ingester/client/ingester.proto +++ b/pkg/ingester/client/ingester.proto @@ -76,47 +76,9 @@ message LabelValueSeriesCount { map label_value_series = 2; } -message ReadRequest { - repeated QueryRequest queries = 1; - - enum ResponseType { - SAMPLES = 0; - STREAMED_XOR_CHUNKS = 1; - } - repeated ResponseType accepted_response_types = 2; -} - -message ReadResponse { - repeated QueryResponse results = 1; -} - -message StreamReadResponse { - repeated StreamChunkedSeries chunked_series = 1; - - int64 query_index = 2; -} - -message StreamChunkedSeries { - repeated cortexpb.LabelPair labels = 1 [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"]; - repeated StreamChunk chunks = 2 [(gogoproto.nullable) = false]; -} - -message StreamChunk { - int64 min_time_ms = 1; - int64 max_time_ms = 2; - - enum Encoding { - UNKNOWN = 0; - XOR = 1; - HISTOGRAM = 2; - FLOAT_HISTOGRAM = 3; - } - Encoding type = 3; - bytes data = 4 [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.UnsafeByteSlice"]; -} - message QueryRequest { // This QueryRequest message is also used for remote read requests, which includes a hints field we don't support. + // TODO update this comment reserved 4; reserved "hints"; diff --git a/pkg/querier/remote_read.go b/pkg/querier/remote_read.go index fbb1a4d9d3..0c4e50fed1 100644 --- a/pkg/querier/remote_read.go +++ b/pkg/querier/remote_read.go @@ -15,14 +15,15 @@ import ( "github.com/go-kit/log/level" "github.com/gogo/protobuf/proto" "github.com/pkg/errors" + "github.com/prometheus/common/model" + "github.com/prometheus/prometheus/model/labels" + "github.com/prometheus/prometheus/prompb" "github.com/prometheus/prometheus/promql" "github.com/prometheus/prometheus/storage" prom_remote "github.com/prometheus/prometheus/storage/remote" "github.com/prometheus/prometheus/tsdb/chunkenc" "github.com/prometheus/prometheus/tsdb/chunks" - "github.com/grafana/mimir/pkg/ingester/client" - "github.com/grafana/mimir/pkg/mimirpb" "github.com/grafana/mimir/pkg/querier/api" "github.com/grafana/mimir/pkg/util" util_log "github.com/grafana/mimir/pkg/util/log" @@ -49,7 +50,7 @@ func RemoteReadHandler(q storage.SampleAndChunkQueryable, logger log.Logger) htt func remoteReadHandler(q storage.SampleAndChunkQueryable, maxBytesInFrame int, lg log.Logger) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { ctx := r.Context() - var req client.ReadRequest + var req prompb.ReadRequest logger := util_log.WithContext(r.Context(), lg) if _, err := util.ParseProtoReader(ctx, r.Body, int(r.ContentLength), MaxRemoteReadQuerySize, nil, &req, util.RawSnappy); err != nil { level.Error(logger).Log("msg", "failed to parse proto", "err", err.Error()) @@ -64,7 +65,7 @@ func remoteReadHandler(q storage.SampleAndChunkQueryable, maxBytesInFrame int, l } switch respType { - case client.STREAMED_XOR_CHUNKS: + case prompb.ReadRequest_STREAMED_XOR_CHUNKS: remoteReadStreamedXORChunks(ctx, q, w, &req, maxBytesInFrame, logger) default: remoteReadSamples(ctx, q, w, &req, logger) @@ -76,18 +77,18 @@ func remoteReadSamples( ctx context.Context, q storage.Queryable, w http.ResponseWriter, - req *client.ReadRequest, + req *prompb.ReadRequest, logger log.Logger, ) { - resp := client.ReadResponse{ - Results: make([]*client.QueryResponse, len(req.Queries)), + resp := prompb.ReadResponse{ + Results: make([]*prompb.QueryResult, len(req.Queries)), } // Fetch samples for all queries in parallel. errCh := make(chan error) for i, qr := range req.Queries { - go func(i int, qr *client.QueryRequest) { - from, to, matchers, err := client.FromQueryRequest(qr) + go func(i int, qr *prompb.Query) { + from, to, matchers, err := fromRemoteReadQuery(qr) if err != nil { errCh <- err return @@ -104,7 +105,7 @@ func remoteReadSamples( End: int64(to), } seriesSet := querier.Select(ctx, false, params, matchers...) - resp.Results[i], err = seriesSetToQueryResponse(seriesSet) + resp.Results[i], err = seriesSetToQueryResult(seriesSet) errCh <- err }(i, qr) } @@ -136,7 +137,7 @@ func remoteReadStreamedXORChunks( ctx context.Context, q storage.ChunkQueryable, w http.ResponseWriter, - req *client.ReadRequest, + req *prompb.ReadRequest, maxBytesInFrame int, logger log.Logger, ) { @@ -178,13 +179,13 @@ func remoteReadErrorStatusCode(err error) int { func processReadStreamedQueryRequest( ctx context.Context, idx int, - queryReq *client.QueryRequest, + queryReq *prompb.Query, q storage.ChunkQueryable, w http.ResponseWriter, f http.Flusher, maxBytesInFrame int, ) error { - from, to, matchers, err := client.FromQueryRequest(queryReq) + from, to, matchers, err := fromRemoteReadQuery(queryReq) if err != nil { return err } @@ -208,29 +209,29 @@ func processReadStreamedQueryRequest( ) } -func seriesSetToQueryResponse(s storage.SeriesSet) (*client.QueryResponse, error) { - result := &client.QueryResponse{} +func seriesSetToQueryResult(s storage.SeriesSet) (*prompb.QueryResult, error) { + result := &prompb.QueryResult{} var it chunkenc.Iterator for s.Next() { series := s.At() - samples := []mimirpb.Sample{} - histograms := []mimirpb.Histogram{} + samples := []prompb.Sample{} + histograms := []prompb.Histogram{} it = series.Iterator(it) for valType := it.Next(); valType != chunkenc.ValNone; valType = it.Next() { switch valType { case chunkenc.ValFloat: t, v := it.At() - samples = append(samples, mimirpb.Sample{ - TimestampMs: t, - Value: v, + samples = append(samples, prompb.Sample{ + Timestamp: t, + Value: v, }) case chunkenc.ValHistogram: t, h := it.AtHistogram(nil) // Nil argument as we pass the data to the protobuf as-is without copy. - histograms = append(histograms, mimirpb.FromHistogramToHistogramProto(t, h)) + histograms = append(histograms, prom_remote.HistogramToHistogramProto(t, h)) case chunkenc.ValFloatHistogram: t, h := it.AtFloatHistogram(nil) // Nil argument as we pass the data to the protobuf as-is without copy. - histograms = append(histograms, mimirpb.FromFloatHistogramToHistogramProto(t, h)) + histograms = append(histograms, prom_remote.FloatHistogramToHistogramProto(t, h)) default: return nil, fmt.Errorf("unsupported value type: %v", valType) } @@ -240,8 +241,8 @@ func seriesSetToQueryResponse(s storage.SeriesSet) (*client.QueryResponse, error return nil, err } - ts := mimirpb.TimeSeries{ - Labels: mimirpb.FromLabelsToLabelAdapters(series.Labels()), + ts := &prompb.TimeSeries{ + Labels: labelsToLabelsProto(series.Labels(), nil), Samples: samples, Histograms: histograms, } @@ -252,14 +253,14 @@ func seriesSetToQueryResponse(s storage.SeriesSet) (*client.QueryResponse, error return result, s.Err() } -func negotiateResponseType(accepted []client.ReadRequest_ResponseType) (client.ReadRequest_ResponseType, error) { +func negotiateResponseType(accepted []prompb.ReadRequest_ResponseType) (prompb.ReadRequest_ResponseType, error) { if len(accepted) == 0 { - return client.SAMPLES, nil + return prompb.ReadRequest_SAMPLES, nil } - supported := map[client.ReadRequest_ResponseType]struct{}{ - client.SAMPLES: {}, - client.STREAMED_XOR_CHUNKS: {}, + supported := map[prompb.ReadRequest_ResponseType]struct{}{ + prompb.ReadRequest_SAMPLES: {}, + prompb.ReadRequest_STREAMED_XOR_CHUNKS: {}, } for _, resType := range accepted { @@ -272,15 +273,15 @@ func negotiateResponseType(accepted []client.ReadRequest_ResponseType) (client.R func streamChunkedReadResponses(stream io.Writer, ss storage.ChunkSeriesSet, queryIndex, maxBytesInFrame int) error { var ( - chks []client.StreamChunk - lbls []mimirpb.LabelAdapter + chks []prompb.Chunk + lbls []prompb.Label ) var iter chunks.Iterator for ss.Next() { series := ss.At() iter = series.Iterator(iter) - lbls = mimirpb.FromLabelsToLabelAdapters(series.Labels()) + lbls = labelsToLabelsProto(series.Labels(), nil) frameBytesRemaining := initializedFrameBytesRemaining(maxBytesInFrame, lbls) isNext := iter.Next() @@ -293,10 +294,10 @@ func streamChunkedReadResponses(stream io.Writer, ss storage.ChunkSeriesSet, que } // Cut the chunk. - chks = append(chks, client.StreamChunk{ + chks = append(chks, prompb.Chunk{ MinTimeMs: chk.MinTime, MaxTimeMs: chk.MaxTime, - Type: client.StreamChunk_Encoding(chk.Chunk.Encoding()), + Type: prompb.Chunk_Encoding(chk.Chunk.Encoding()), Data: chk.Chunk.Bytes(), }) frameBytesRemaining -= chks[len(chks)-1].Size() @@ -307,8 +308,8 @@ func streamChunkedReadResponses(stream io.Writer, ss storage.ChunkSeriesSet, que continue } - b, err := proto.Marshal(&client.StreamReadResponse{ - ChunkedSeries: []*client.StreamChunkedSeries{ + b, err := proto.Marshal(&prompb.ChunkedReadResponse{ + ChunkedSeries: []*prompb.ChunkedSeries{ { Labels: lbls, Chunks: chks, @@ -333,10 +334,34 @@ func streamChunkedReadResponses(stream io.Writer, ss storage.ChunkSeriesSet, que return ss.Err() } -func initializedFrameBytesRemaining(maxBytesInFrame int, lbls []mimirpb.LabelAdapter) int { +func initializedFrameBytesRemaining(maxBytesInFrame int, lbls []prompb.Label) int { frameBytesLeft := maxBytesInFrame for _, lbl := range lbls { frameBytesLeft -= lbl.Size() } return frameBytesLeft } + +// TODO what's the right package for this utility? +// TODO unit test +func fromRemoteReadQuery(req *prompb.Query) (model.Time, model.Time, []*labels.Matcher, error) { + matchers, err := prom_remote.FromLabelMatchers(req.Matchers) + if err != nil { + return 0, 0, nil, err + } + from := model.Time(req.StartTimestampMs) + to := model.Time(req.EndTimestampMs) + return from, to, matchers, nil +} + +// TODO copied from Prometheus. We could export it too. +func labelsToLabelsProto(lbls labels.Labels, buf []prompb.Label) []prompb.Label { + result := buf[:0] + lbls.Range(func(l labels.Label) { + result = append(result, prompb.Label{ + Name: l.Name, + Value: l.Value, + }) + }) + return result +} diff --git a/pkg/querier/remote_read_test.go b/pkg/querier/remote_read_test.go index 1f071f6161..9443057f2a 100644 --- a/pkg/querier/remote_read_test.go +++ b/pkg/querier/remote_read_test.go @@ -20,6 +20,7 @@ import ( "github.com/pkg/errors" "github.com/prometheus/common/model" "github.com/prometheus/prometheus/model/labels" + "github.com/prometheus/prometheus/prompb" "github.com/prometheus/prometheus/promql" "github.com/prometheus/prometheus/storage" prom_remote "github.com/prometheus/prometheus/storage/remote" @@ -27,7 +28,6 @@ import ( "github.com/prometheus/prometheus/util/annotations" "github.com/stretchr/testify/require" - "github.com/grafana/mimir/pkg/ingester/client" "github.com/grafana/mimir/pkg/mimirpb" "github.com/grafana/mimir/pkg/querier/api" "github.com/grafana/mimir/pkg/storage/series" @@ -116,8 +116,8 @@ func TestSampledRemoteRead(t *testing.T) { } handler := RemoteReadHandler(q, log.NewNopLogger()) - requestBody, err := proto.Marshal(&client.ReadRequest{ - Queries: []*client.QueryRequest{ + requestBody, err := proto.Marshal(&prompb.ReadRequest{ + Queries: []*prompb.Query{ {StartTimestampMs: 0, EndTimestampMs: 10}, }, }) @@ -131,31 +131,31 @@ func TestSampledRemoteRead(t *testing.T) { handler.ServeHTTP(recorder, request) require.Equal(t, 200, recorder.Result().StatusCode) - require.Equal(t, []string([]string{"application/x-protobuf"}), recorder.Result().Header["Content-Type"]) + require.Equal(t, []string{"application/x-protobuf"}, recorder.Result().Header["Content-Type"]) responseBody, err := io.ReadAll(recorder.Result().Body) require.NoError(t, err) responseBody, err = snappy.Decode(nil, responseBody) require.NoError(t, err) - var response client.ReadResponse + var response prompb.ReadResponse err = proto.Unmarshal(responseBody, &response) require.NoError(t, err) - expected := client.ReadResponse{ - Results: []*client.QueryResponse{ + expected := prompb.ReadResponse{ + Results: []*prompb.QueryResult{ { - Timeseries: []mimirpb.TimeSeries{ + Timeseries: []*prompb.TimeSeries{ { - Labels: []mimirpb.LabelAdapter{ + Labels: []prompb.Label{ {Name: "foo", Value: "bar"}, }, - Samples: []mimirpb.Sample{ - {Value: 0, TimestampMs: 0}, - {Value: 1, TimestampMs: 1}, - {Value: 2, TimestampMs: 2}, - {Value: 3, TimestampMs: 3}, + Samples: []prompb.Sample{ + {Value: 0, Timestamp: 0}, + {Value: 1, Timestamp: 1}, + {Value: 2, Timestamp: 2}, + {Value: 3, Timestamp: 3}, }, - Histograms: []mimirpb.Histogram{ - mimirpb.FromHistogramToHistogramProto(4, test.GenerateTestHistogram(4)), + Histograms: []prompb.Histogram{ + prom_remote.HistogramToHistogramProto(4, test.GenerateTestHistogram(4)), }, }, }, @@ -169,20 +169,20 @@ func TestStreamedRemoteRead(t *testing.T) { tcs := map[string]struct { samples []model.SamplePair histograms []mimirpb.Histogram - expectedResults []*client.StreamReadResponse + expectedResults []*prompb.ChunkedReadResponse }{ "with 120 samples, we expect 1 frame with 1 chunk": { samples: getNSamples(120), - expectedResults: []*client.StreamReadResponse{ + expectedResults: []*prompb.ChunkedReadResponse{ { - ChunkedSeries: []*client.StreamChunkedSeries{ + ChunkedSeries: []*prompb.ChunkedSeries{ { - Labels: []mimirpb.LabelAdapter{{Name: "foo", Value: "bar"}}, - Chunks: []client.StreamChunk{ + Labels: []prompb.Label{{Name: "foo", Value: "bar"}}, + Chunks: []prompb.Chunk{ { MinTimeMs: 0, MaxTimeMs: 119, - Type: client.XOR, + Type: prompb.Chunk_XOR, Data: getIndexedChunk(0, 120, chunkenc.EncXOR), }, }, @@ -194,22 +194,22 @@ func TestStreamedRemoteRead(t *testing.T) { }, "with 121 samples, we expect 1 frame with 2 chunks": { samples: getNSamples(121), - expectedResults: []*client.StreamReadResponse{ + expectedResults: []*prompb.ChunkedReadResponse{ { - ChunkedSeries: []*client.StreamChunkedSeries{ + ChunkedSeries: []*prompb.ChunkedSeries{ { - Labels: []mimirpb.LabelAdapter{{Name: "foo", Value: "bar"}}, - Chunks: []client.StreamChunk{ + Labels: []prompb.Label{{Name: "foo", Value: "bar"}}, + Chunks: []prompb.Chunk{ { MinTimeMs: 0, MaxTimeMs: 119, - Type: client.XOR, + Type: prompb.Chunk_XOR, Data: getIndexedChunk(0, 121, chunkenc.EncXOR), }, { MinTimeMs: 120, MaxTimeMs: 120, - Type: client.XOR, + Type: prompb.Chunk_XOR, Data: getIndexedChunk(1, 121, chunkenc.EncXOR), }, }, @@ -221,22 +221,22 @@ func TestStreamedRemoteRead(t *testing.T) { }, "with 481 samples, we expect 2 frames with 2 chunks, and 1 frame with 1 chunk due to frame limit": { samples: getNSamples(481), - expectedResults: []*client.StreamReadResponse{ + expectedResults: []*prompb.ChunkedReadResponse{ { - ChunkedSeries: []*client.StreamChunkedSeries{ + ChunkedSeries: []*prompb.ChunkedSeries{ { - Labels: []mimirpb.LabelAdapter{{Name: "foo", Value: "bar"}}, - Chunks: []client.StreamChunk{ + Labels: []prompb.Label{{Name: "foo", Value: "bar"}}, + Chunks: []prompb.Chunk{ { MinTimeMs: 0, MaxTimeMs: 119, - Type: client.XOR, + Type: prompb.Chunk_XOR, Data: getIndexedChunk(0, 481, chunkenc.EncXOR), }, { MinTimeMs: 120, MaxTimeMs: 239, - Type: client.XOR, + Type: prompb.Chunk_XOR, Data: getIndexedChunk(1, 481, chunkenc.EncXOR), }, }, @@ -244,20 +244,20 @@ func TestStreamedRemoteRead(t *testing.T) { }, }, { - ChunkedSeries: []*client.StreamChunkedSeries{ + ChunkedSeries: []*prompb.ChunkedSeries{ { - Labels: []mimirpb.LabelAdapter{{Name: "foo", Value: "bar"}}, - Chunks: []client.StreamChunk{ + Labels: []prompb.Label{{Name: "foo", Value: "bar"}}, + Chunks: []prompb.Chunk{ { MinTimeMs: 240, MaxTimeMs: 359, - Type: client.XOR, + Type: prompb.Chunk_XOR, Data: getIndexedChunk(2, 481, chunkenc.EncXOR), }, { MinTimeMs: 360, MaxTimeMs: 479, - Type: client.XOR, + Type: prompb.Chunk_XOR, Data: getIndexedChunk(3, 481, chunkenc.EncXOR), }, }, @@ -265,14 +265,14 @@ func TestStreamedRemoteRead(t *testing.T) { }, }, { - ChunkedSeries: []*client.StreamChunkedSeries{ + ChunkedSeries: []*prompb.ChunkedSeries{ { - Labels: []mimirpb.LabelAdapter{{Name: "foo", Value: "bar"}}, - Chunks: []client.StreamChunk{ + Labels: []prompb.Label{{Name: "foo", Value: "bar"}}, + Chunks: []prompb.Chunk{ { MinTimeMs: 480, MaxTimeMs: 480, - Type: client.XOR, + Type: prompb.Chunk_XOR, Data: getIndexedChunk(4, 481, chunkenc.EncXOR), }, }, @@ -283,16 +283,16 @@ func TestStreamedRemoteRead(t *testing.T) { }, "120 native histograms": { histograms: getNHistogramSamples(120), - expectedResults: []*client.StreamReadResponse{ + expectedResults: []*prompb.ChunkedReadResponse{ { - ChunkedSeries: []*client.StreamChunkedSeries{ + ChunkedSeries: []*prompb.ChunkedSeries{ { - Labels: []mimirpb.LabelAdapter{{Name: "foo", Value: "bar"}}, - Chunks: []client.StreamChunk{ + Labels: []prompb.Label{{Name: "foo", Value: "bar"}}, + Chunks: []prompb.Chunk{ { MinTimeMs: 0, MaxTimeMs: 119, - Type: client.HISTOGRAM, + Type: prompb.Chunk_HISTOGRAM, Data: getIndexedChunk(0, 120, chunkenc.EncHistogram), }, }, @@ -304,16 +304,16 @@ func TestStreamedRemoteRead(t *testing.T) { }, "120 native float histograms": { histograms: getNFloatHistogramSamples(120), - expectedResults: []*client.StreamReadResponse{ + expectedResults: []*prompb.ChunkedReadResponse{ { - ChunkedSeries: []*client.StreamChunkedSeries{ + ChunkedSeries: []*prompb.ChunkedSeries{ { - Labels: []mimirpb.LabelAdapter{{Name: "foo", Value: "bar"}}, - Chunks: []client.StreamChunk{ + Labels: []prompb.Label{{Name: "foo", Value: "bar"}}, + Chunks: []prompb.Chunk{ { MinTimeMs: 0, MaxTimeMs: 119, - Type: client.FLOAT_HISTOGRAM, + Type: prompb.Chunk_FLOAT_HISTOGRAM, Data: getIndexedChunk(0, 120, chunkenc.EncFloatHistogram), }, }, @@ -344,11 +344,11 @@ func TestStreamedRemoteRead(t *testing.T) { handler := remoteReadHandler(q, maxBytesInFrame, log.NewNopLogger()) - requestBody, err := proto.Marshal(&client.ReadRequest{ - Queries: []*client.QueryRequest{ + requestBody, err := proto.Marshal(&prompb.ReadRequest{ + Queries: []*prompb.Query{ {StartTimestampMs: 0, EndTimestampMs: 10}, }, - AcceptedResponseTypes: []client.ReadRequest_ResponseType{client.STREAMED_XOR_CHUNKS}, + AcceptedResponseTypes: []prompb.ReadRequest_ResponseType{prompb.ReadRequest_STREAMED_XOR_CHUNKS}, }) require.NoError(t, err) requestBody = snappy.Encode(nil, requestBody) @@ -366,7 +366,7 @@ func TestStreamedRemoteRead(t *testing.T) { i := 0 for { - var res client.StreamReadResponse + var res prompb.ChunkedReadResponse err := stream.NextProto(&res) if errors.Is(err, io.EOF) { break @@ -527,11 +527,11 @@ func TestRemoteReadErrorParsing(t *testing.T) { } handler := remoteReadHandler(q, 1024*1024, log.NewNopLogger()) - requestBody, err := proto.Marshal(&client.ReadRequest{ - Queries: []*client.QueryRequest{ + requestBody, err := proto.Marshal(&prompb.ReadRequest{ + Queries: []*prompb.Query{ {StartTimestampMs: 0, EndTimestampMs: 10}, }, - AcceptedResponseTypes: []client.ReadRequest_ResponseType{client.SAMPLES}, + AcceptedResponseTypes: []prompb.ReadRequest_ResponseType{prompb.ReadRequest_SAMPLES}, }) require.NoError(t, err) requestBody = snappy.Encode(nil, requestBody) @@ -563,11 +563,11 @@ func TestRemoteReadErrorParsing(t *testing.T) { } handler := remoteReadHandler(q, 1024*1024, log.NewNopLogger()) - requestBody, err := proto.Marshal(&client.ReadRequest{ - Queries: []*client.QueryRequest{ + requestBody, err := proto.Marshal(&prompb.ReadRequest{ + Queries: []*prompb.Query{ {StartTimestampMs: 0, EndTimestampMs: 10}, }, - AcceptedResponseTypes: []client.ReadRequest_ResponseType{client.STREAMED_XOR_CHUNKS}, + AcceptedResponseTypes: []prompb.ReadRequest_ResponseType{prompb.ReadRequest_STREAMED_XOR_CHUNKS}, }) require.NoError(t, err) requestBody = snappy.Encode(nil, requestBody)