mirror of https://github.com/grafana/loki
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
14270 lines
337 KiB
14270 lines
337 KiB
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
|
// source: pkg/logproto/logproto.proto
|
|
|
|
package logproto
|
|
|
|
import (
|
|
bytes "bytes"
|
|
context "context"
|
|
encoding_binary "encoding/binary"
|
|
fmt "fmt"
|
|
_ "github.com/gogo/protobuf/gogoproto"
|
|
proto "github.com/gogo/protobuf/proto"
|
|
github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
|
|
_ "github.com/gogo/protobuf/types"
|
|
github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
|
|
stats "github.com/grafana/loki/pkg/logqlmodel/stats"
|
|
_ "github.com/grafana/loki/pkg/push"
|
|
github_com_grafana_loki_pkg_push "github.com/grafana/loki/pkg/push"
|
|
github_com_prometheus_common_model "github.com/prometheus/common/model"
|
|
grpc "google.golang.org/grpc"
|
|
codes "google.golang.org/grpc/codes"
|
|
status "google.golang.org/grpc/status"
|
|
io "io"
|
|
math "math"
|
|
math_bits "math/bits"
|
|
reflect "reflect"
|
|
strconv "strconv"
|
|
strings "strings"
|
|
time "time"
|
|
)
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
var _ = time.Kitchen
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the proto package it is being compiled against.
|
|
// A compilation error at this line likely means your copy of the
|
|
// proto package needs to be updated.
|
|
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
|
|
|
|
type Direction int32
|
|
|
|
const (
|
|
FORWARD Direction = 0
|
|
BACKWARD Direction = 1
|
|
)
|
|
|
|
var Direction_name = map[int32]string{
|
|
0: "FORWARD",
|
|
1: "BACKWARD",
|
|
}
|
|
|
|
var Direction_value = map[string]int32{
|
|
"FORWARD": 0,
|
|
"BACKWARD": 1,
|
|
}
|
|
|
|
func (Direction) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{0}
|
|
}
|
|
|
|
type StreamRatesRequest struct {
|
|
}
|
|
|
|
func (m *StreamRatesRequest) Reset() { *m = StreamRatesRequest{} }
|
|
func (*StreamRatesRequest) ProtoMessage() {}
|
|
func (*StreamRatesRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{0}
|
|
}
|
|
func (m *StreamRatesRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *StreamRatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_StreamRatesRequest.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 *StreamRatesRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StreamRatesRequest.Merge(m, src)
|
|
}
|
|
func (m *StreamRatesRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *StreamRatesRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StreamRatesRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StreamRatesRequest proto.InternalMessageInfo
|
|
|
|
type StreamRatesResponse struct {
|
|
StreamRates []*StreamRate `protobuf:"bytes,1,rep,name=streamRates,proto3" json:"streamRates,omitempty"`
|
|
}
|
|
|
|
func (m *StreamRatesResponse) Reset() { *m = StreamRatesResponse{} }
|
|
func (*StreamRatesResponse) ProtoMessage() {}
|
|
func (*StreamRatesResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{1}
|
|
}
|
|
func (m *StreamRatesResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *StreamRatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_StreamRatesResponse.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 *StreamRatesResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StreamRatesResponse.Merge(m, src)
|
|
}
|
|
func (m *StreamRatesResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *StreamRatesResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StreamRatesResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StreamRatesResponse proto.InternalMessageInfo
|
|
|
|
func (m *StreamRatesResponse) GetStreamRates() []*StreamRate {
|
|
if m != nil {
|
|
return m.StreamRates
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type StreamRate struct {
|
|
StreamHash uint64 `protobuf:"varint,1,opt,name=streamHash,proto3" json:"streamHash,omitempty"`
|
|
StreamHashNoShard uint64 `protobuf:"varint,2,opt,name=streamHashNoShard,proto3" json:"streamHashNoShard,omitempty"`
|
|
Rate int64 `protobuf:"varint,3,opt,name=rate,proto3" json:"rate,omitempty"`
|
|
Tenant string `protobuf:"bytes,4,opt,name=tenant,proto3" json:"tenant,omitempty"`
|
|
Pushes uint32 `protobuf:"varint,5,opt,name=pushes,proto3" json:"pushes,omitempty"`
|
|
}
|
|
|
|
func (m *StreamRate) Reset() { *m = StreamRate{} }
|
|
func (*StreamRate) ProtoMessage() {}
|
|
func (*StreamRate) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{2}
|
|
}
|
|
func (m *StreamRate) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *StreamRate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_StreamRate.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 *StreamRate) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StreamRate.Merge(m, src)
|
|
}
|
|
func (m *StreamRate) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *StreamRate) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StreamRate.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StreamRate proto.InternalMessageInfo
|
|
|
|
func (m *StreamRate) GetStreamHash() uint64 {
|
|
if m != nil {
|
|
return m.StreamHash
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *StreamRate) GetStreamHashNoShard() uint64 {
|
|
if m != nil {
|
|
return m.StreamHashNoShard
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *StreamRate) GetRate() int64 {
|
|
if m != nil {
|
|
return m.Rate
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *StreamRate) GetTenant() string {
|
|
if m != nil {
|
|
return m.Tenant
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *StreamRate) GetPushes() uint32 {
|
|
if m != nil {
|
|
return m.Pushes
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QueryRequest struct {
|
|
Selector string `protobuf:"bytes,1,opt,name=selector,proto3" json:"selector,omitempty"`
|
|
Limit uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
|
|
Start time.Time `protobuf:"bytes,3,opt,name=start,proto3,stdtime" json:"start"`
|
|
End time.Time `protobuf:"bytes,4,opt,name=end,proto3,stdtime" json:"end"`
|
|
Direction Direction `protobuf:"varint,5,opt,name=direction,proto3,enum=logproto.Direction" json:"direction,omitempty"`
|
|
Shards []string `protobuf:"bytes,7,rep,name=shards,proto3" json:"shards,omitempty"`
|
|
Deletes []*Delete `protobuf:"bytes,8,rep,name=deletes,proto3" json:"deletes,omitempty"`
|
|
}
|
|
|
|
func (m *QueryRequest) Reset() { *m = QueryRequest{} }
|
|
func (*QueryRequest) ProtoMessage() {}
|
|
func (*QueryRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{3}
|
|
}
|
|
func (m *QueryRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *QueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_QueryRequest.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 *QueryRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_QueryRequest.Merge(m, src)
|
|
}
|
|
func (m *QueryRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *QueryRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_QueryRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_QueryRequest proto.InternalMessageInfo
|
|
|
|
func (m *QueryRequest) GetSelector() string {
|
|
if m != nil {
|
|
return m.Selector
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *QueryRequest) GetLimit() uint32 {
|
|
if m != nil {
|
|
return m.Limit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryRequest) GetStart() time.Time {
|
|
if m != nil {
|
|
return m.Start
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (m *QueryRequest) GetEnd() time.Time {
|
|
if m != nil {
|
|
return m.End
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (m *QueryRequest) GetDirection() Direction {
|
|
if m != nil {
|
|
return m.Direction
|
|
}
|
|
return FORWARD
|
|
}
|
|
|
|
func (m *QueryRequest) GetShards() []string {
|
|
if m != nil {
|
|
return m.Shards
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryRequest) GetDeletes() []*Delete {
|
|
if m != nil {
|
|
return m.Deletes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SampleQueryRequest struct {
|
|
Selector string `protobuf:"bytes,1,opt,name=selector,proto3" json:"selector,omitempty"`
|
|
Start time.Time `protobuf:"bytes,2,opt,name=start,proto3,stdtime" json:"start"`
|
|
End time.Time `protobuf:"bytes,3,opt,name=end,proto3,stdtime" json:"end"`
|
|
Shards []string `protobuf:"bytes,4,rep,name=shards,proto3" json:"shards,omitempty"`
|
|
Deletes []*Delete `protobuf:"bytes,5,rep,name=deletes,proto3" json:"deletes,omitempty"`
|
|
}
|
|
|
|
func (m *SampleQueryRequest) Reset() { *m = SampleQueryRequest{} }
|
|
func (*SampleQueryRequest) ProtoMessage() {}
|
|
func (*SampleQueryRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{4}
|
|
}
|
|
func (m *SampleQueryRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SampleQueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SampleQueryRequest.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 *SampleQueryRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SampleQueryRequest.Merge(m, src)
|
|
}
|
|
func (m *SampleQueryRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SampleQueryRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SampleQueryRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SampleQueryRequest proto.InternalMessageInfo
|
|
|
|
func (m *SampleQueryRequest) GetSelector() string {
|
|
if m != nil {
|
|
return m.Selector
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *SampleQueryRequest) GetStart() time.Time {
|
|
if m != nil {
|
|
return m.Start
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (m *SampleQueryRequest) GetEnd() time.Time {
|
|
if m != nil {
|
|
return m.End
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (m *SampleQueryRequest) GetShards() []string {
|
|
if m != nil {
|
|
return m.Shards
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *SampleQueryRequest) GetDeletes() []*Delete {
|
|
if m != nil {
|
|
return m.Deletes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Delete struct {
|
|
Selector string `protobuf:"bytes,1,opt,name=selector,proto3" json:"selector,omitempty"`
|
|
Start int64 `protobuf:"varint,2,opt,name=start,proto3" json:"start,omitempty"`
|
|
End int64 `protobuf:"varint,3,opt,name=end,proto3" json:"end,omitempty"`
|
|
}
|
|
|
|
func (m *Delete) Reset() { *m = Delete{} }
|
|
func (*Delete) ProtoMessage() {}
|
|
func (*Delete) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{5}
|
|
}
|
|
func (m *Delete) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Delete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Delete.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 *Delete) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Delete.Merge(m, src)
|
|
}
|
|
func (m *Delete) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Delete) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Delete.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Delete proto.InternalMessageInfo
|
|
|
|
func (m *Delete) GetSelector() string {
|
|
if m != nil {
|
|
return m.Selector
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Delete) GetStart() int64 {
|
|
if m != nil {
|
|
return m.Start
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Delete) GetEnd() int64 {
|
|
if m != nil {
|
|
return m.End
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QueryResponse struct {
|
|
Streams []github_com_grafana_loki_pkg_push.Stream `protobuf:"bytes,1,rep,name=streams,proto3,customtype=github.com/grafana/loki/pkg/push.Stream" json:"streams,omitempty"`
|
|
Stats stats.Ingester `protobuf:"bytes,2,opt,name=stats,proto3" json:"stats"`
|
|
}
|
|
|
|
func (m *QueryResponse) Reset() { *m = QueryResponse{} }
|
|
func (*QueryResponse) ProtoMessage() {}
|
|
func (*QueryResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{6}
|
|
}
|
|
func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *QueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_QueryResponse.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 *QueryResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_QueryResponse.Merge(m, src)
|
|
}
|
|
func (m *QueryResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *QueryResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_QueryResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_QueryResponse proto.InternalMessageInfo
|
|
|
|
func (m *QueryResponse) GetStats() stats.Ingester {
|
|
if m != nil {
|
|
return m.Stats
|
|
}
|
|
return stats.Ingester{}
|
|
}
|
|
|
|
type SampleQueryResponse struct {
|
|
Series []Series `protobuf:"bytes,1,rep,name=series,proto3,customtype=Series" json:"series,omitempty"`
|
|
Stats stats.Ingester `protobuf:"bytes,2,opt,name=stats,proto3" json:"stats"`
|
|
}
|
|
|
|
func (m *SampleQueryResponse) Reset() { *m = SampleQueryResponse{} }
|
|
func (*SampleQueryResponse) ProtoMessage() {}
|
|
func (*SampleQueryResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{7}
|
|
}
|
|
func (m *SampleQueryResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SampleQueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SampleQueryResponse.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 *SampleQueryResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SampleQueryResponse.Merge(m, src)
|
|
}
|
|
func (m *SampleQueryResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SampleQueryResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SampleQueryResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SampleQueryResponse proto.InternalMessageInfo
|
|
|
|
func (m *SampleQueryResponse) GetStats() stats.Ingester {
|
|
if m != nil {
|
|
return m.Stats
|
|
}
|
|
return stats.Ingester{}
|
|
}
|
|
|
|
type LabelRequest struct {
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Values bool `protobuf:"varint,2,opt,name=values,proto3" json:"values,omitempty"`
|
|
Start *time.Time `protobuf:"bytes,3,opt,name=start,proto3,stdtime" json:"start,omitempty"`
|
|
End *time.Time `protobuf:"bytes,4,opt,name=end,proto3,stdtime" json:"end,omitempty"`
|
|
Query string `protobuf:"bytes,5,opt,name=query,proto3" json:"query,omitempty"`
|
|
}
|
|
|
|
func (m *LabelRequest) Reset() { *m = LabelRequest{} }
|
|
func (*LabelRequest) ProtoMessage() {}
|
|
func (*LabelRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{8}
|
|
}
|
|
func (m *LabelRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *LabelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_LabelRequest.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 *LabelRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LabelRequest.Merge(m, src)
|
|
}
|
|
func (m *LabelRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *LabelRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LabelRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LabelRequest proto.InternalMessageInfo
|
|
|
|
func (m *LabelRequest) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *LabelRequest) GetValues() bool {
|
|
if m != nil {
|
|
return m.Values
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *LabelRequest) GetStart() *time.Time {
|
|
if m != nil {
|
|
return m.Start
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LabelRequest) GetEnd() *time.Time {
|
|
if m != nil {
|
|
return m.End
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LabelRequest) GetQuery() string {
|
|
if m != nil {
|
|
return m.Query
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type LabelResponse struct {
|
|
Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
|
|
}
|
|
|
|
func (m *LabelResponse) Reset() { *m = LabelResponse{} }
|
|
func (*LabelResponse) ProtoMessage() {}
|
|
func (*LabelResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{9}
|
|
}
|
|
func (m *LabelResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *LabelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_LabelResponse.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 *LabelResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LabelResponse.Merge(m, src)
|
|
}
|
|
func (m *LabelResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *LabelResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LabelResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LabelResponse proto.InternalMessageInfo
|
|
|
|
func (m *LabelResponse) GetValues() []string {
|
|
if m != nil {
|
|
return m.Values
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Sample struct {
|
|
Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"ts"`
|
|
Value float64 `protobuf:"fixed64,2,opt,name=value,proto3" json:"value"`
|
|
Hash uint64 `protobuf:"varint,3,opt,name=hash,proto3" json:"hash"`
|
|
}
|
|
|
|
func (m *Sample) Reset() { *m = Sample{} }
|
|
func (*Sample) ProtoMessage() {}
|
|
func (*Sample) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{10}
|
|
}
|
|
func (m *Sample) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Sample) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Sample.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 *Sample) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Sample.Merge(m, src)
|
|
}
|
|
func (m *Sample) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Sample) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Sample.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Sample proto.InternalMessageInfo
|
|
|
|
func (m *Sample) GetTimestamp() int64 {
|
|
if m != nil {
|
|
return m.Timestamp
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Sample) GetValue() float64 {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Sample) GetHash() uint64 {
|
|
if m != nil {
|
|
return m.Hash
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// LegacySample exists for backwards compatibility reasons and is deprecated. Do not use.
|
|
type LegacySample struct {
|
|
Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
|
|
TimestampMs int64 `protobuf:"varint,2,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
|
|
}
|
|
|
|
func (m *LegacySample) Reset() { *m = LegacySample{} }
|
|
func (*LegacySample) ProtoMessage() {}
|
|
func (*LegacySample) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{11}
|
|
}
|
|
func (m *LegacySample) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *LegacySample) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_LegacySample.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 *LegacySample) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LegacySample.Merge(m, src)
|
|
}
|
|
func (m *LegacySample) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *LegacySample) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LegacySample.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LegacySample proto.InternalMessageInfo
|
|
|
|
func (m *LegacySample) GetValue() float64 {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *LegacySample) GetTimestampMs() int64 {
|
|
if m != nil {
|
|
return m.TimestampMs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Series struct {
|
|
Labels string `protobuf:"bytes,1,opt,name=labels,proto3" json:"labels"`
|
|
Samples []Sample `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples"`
|
|
StreamHash uint64 `protobuf:"varint,3,opt,name=streamHash,proto3" json:"streamHash"`
|
|
}
|
|
|
|
func (m *Series) Reset() { *m = Series{} }
|
|
func (*Series) ProtoMessage() {}
|
|
func (*Series) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{12}
|
|
}
|
|
func (m *Series) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Series) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Series.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 *Series) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Series.Merge(m, src)
|
|
}
|
|
func (m *Series) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Series) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Series.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Series proto.InternalMessageInfo
|
|
|
|
func (m *Series) GetLabels() string {
|
|
if m != nil {
|
|
return m.Labels
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Series) GetSamples() []Sample {
|
|
if m != nil {
|
|
return m.Samples
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Series) GetStreamHash() uint64 {
|
|
if m != nil {
|
|
return m.StreamHash
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type TailRequest struct {
|
|
Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
|
|
DelayFor uint32 `protobuf:"varint,3,opt,name=delayFor,proto3" json:"delayFor,omitempty"`
|
|
Limit uint32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
|
|
Start time.Time `protobuf:"bytes,5,opt,name=start,proto3,stdtime" json:"start"`
|
|
}
|
|
|
|
func (m *TailRequest) Reset() { *m = TailRequest{} }
|
|
func (*TailRequest) ProtoMessage() {}
|
|
func (*TailRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{13}
|
|
}
|
|
func (m *TailRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *TailRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_TailRequest.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 *TailRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TailRequest.Merge(m, src)
|
|
}
|
|
func (m *TailRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *TailRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TailRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TailRequest proto.InternalMessageInfo
|
|
|
|
func (m *TailRequest) GetQuery() string {
|
|
if m != nil {
|
|
return m.Query
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TailRequest) GetDelayFor() uint32 {
|
|
if m != nil {
|
|
return m.DelayFor
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *TailRequest) GetLimit() uint32 {
|
|
if m != nil {
|
|
return m.Limit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *TailRequest) GetStart() time.Time {
|
|
if m != nil {
|
|
return m.Start
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
type TailResponse struct {
|
|
Stream *github_com_grafana_loki_pkg_push.Stream `protobuf:"bytes,1,opt,name=stream,proto3,customtype=github.com/grafana/loki/pkg/push.Stream" json:"stream,omitempty"`
|
|
DroppedStreams []*DroppedStream `protobuf:"bytes,2,rep,name=droppedStreams,proto3" json:"droppedStreams,omitempty"`
|
|
}
|
|
|
|
func (m *TailResponse) Reset() { *m = TailResponse{} }
|
|
func (*TailResponse) ProtoMessage() {}
|
|
func (*TailResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{14}
|
|
}
|
|
func (m *TailResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *TailResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_TailResponse.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 *TailResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TailResponse.Merge(m, src)
|
|
}
|
|
func (m *TailResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *TailResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TailResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TailResponse proto.InternalMessageInfo
|
|
|
|
func (m *TailResponse) GetDroppedStreams() []*DroppedStream {
|
|
if m != nil {
|
|
return m.DroppedStreams
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SeriesRequest struct {
|
|
Start time.Time `protobuf:"bytes,1,opt,name=start,proto3,stdtime" json:"start"`
|
|
End time.Time `protobuf:"bytes,2,opt,name=end,proto3,stdtime" json:"end"`
|
|
Groups []string `protobuf:"bytes,3,rep,name=groups,proto3" json:"groups,omitempty"`
|
|
Shards []string `protobuf:"bytes,4,rep,name=shards,proto3" json:"shards,omitempty"`
|
|
}
|
|
|
|
func (m *SeriesRequest) Reset() { *m = SeriesRequest{} }
|
|
func (*SeriesRequest) ProtoMessage() {}
|
|
func (*SeriesRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{15}
|
|
}
|
|
func (m *SeriesRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SeriesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SeriesRequest.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 *SeriesRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SeriesRequest.Merge(m, src)
|
|
}
|
|
func (m *SeriesRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SeriesRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SeriesRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SeriesRequest proto.InternalMessageInfo
|
|
|
|
func (m *SeriesRequest) GetStart() time.Time {
|
|
if m != nil {
|
|
return m.Start
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (m *SeriesRequest) GetEnd() time.Time {
|
|
if m != nil {
|
|
return m.End
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (m *SeriesRequest) GetGroups() []string {
|
|
if m != nil {
|
|
return m.Groups
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *SeriesRequest) GetShards() []string {
|
|
if m != nil {
|
|
return m.Shards
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SeriesResponse struct {
|
|
Series []SeriesIdentifier `protobuf:"bytes,1,rep,name=series,proto3" json:"series"`
|
|
}
|
|
|
|
func (m *SeriesResponse) Reset() { *m = SeriesResponse{} }
|
|
func (*SeriesResponse) ProtoMessage() {}
|
|
func (*SeriesResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{16}
|
|
}
|
|
func (m *SeriesResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SeriesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SeriesResponse.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 *SeriesResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SeriesResponse.Merge(m, src)
|
|
}
|
|
func (m *SeriesResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SeriesResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SeriesResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SeriesResponse proto.InternalMessageInfo
|
|
|
|
func (m *SeriesResponse) GetSeries() []SeriesIdentifier {
|
|
if m != nil {
|
|
return m.Series
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SeriesIdentifier struct {
|
|
Labels map[string]string `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
}
|
|
|
|
func (m *SeriesIdentifier) Reset() { *m = SeriesIdentifier{} }
|
|
func (*SeriesIdentifier) ProtoMessage() {}
|
|
func (*SeriesIdentifier) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{17}
|
|
}
|
|
func (m *SeriesIdentifier) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SeriesIdentifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SeriesIdentifier.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 *SeriesIdentifier) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SeriesIdentifier.Merge(m, src)
|
|
}
|
|
func (m *SeriesIdentifier) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SeriesIdentifier) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SeriesIdentifier.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SeriesIdentifier proto.InternalMessageInfo
|
|
|
|
func (m *SeriesIdentifier) GetLabels() map[string]string {
|
|
if m != nil {
|
|
return m.Labels
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type DroppedStream struct {
|
|
From time.Time `protobuf:"bytes,1,opt,name=from,proto3,stdtime" json:"from"`
|
|
To time.Time `protobuf:"bytes,2,opt,name=to,proto3,stdtime" json:"to"`
|
|
Labels string `protobuf:"bytes,3,opt,name=labels,proto3" json:"labels,omitempty"`
|
|
}
|
|
|
|
func (m *DroppedStream) Reset() { *m = DroppedStream{} }
|
|
func (*DroppedStream) ProtoMessage() {}
|
|
func (*DroppedStream) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{18}
|
|
}
|
|
func (m *DroppedStream) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *DroppedStream) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_DroppedStream.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 *DroppedStream) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_DroppedStream.Merge(m, src)
|
|
}
|
|
func (m *DroppedStream) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *DroppedStream) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_DroppedStream.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_DroppedStream proto.InternalMessageInfo
|
|
|
|
func (m *DroppedStream) GetFrom() time.Time {
|
|
if m != nil {
|
|
return m.From
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (m *DroppedStream) GetTo() time.Time {
|
|
if m != nil {
|
|
return m.To
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (m *DroppedStream) GetLabels() string {
|
|
if m != nil {
|
|
return m.Labels
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type LabelPair struct {
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
|
}
|
|
|
|
func (m *LabelPair) Reset() { *m = LabelPair{} }
|
|
func (*LabelPair) ProtoMessage() {}
|
|
func (*LabelPair) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{19}
|
|
}
|
|
func (m *LabelPair) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *LabelPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_LabelPair.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 *LabelPair) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LabelPair.Merge(m, src)
|
|
}
|
|
func (m *LabelPair) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *LabelPair) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LabelPair.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LabelPair proto.InternalMessageInfo
|
|
|
|
func (m *LabelPair) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *LabelPair) GetValue() string {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// LegacyLabelPair exists for backwards compatibility reasons and is deprecated. Do not use.
|
|
// Use LabelPair instead.
|
|
type LegacyLabelPair struct {
|
|
Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
|
}
|
|
|
|
func (m *LegacyLabelPair) Reset() { *m = LegacyLabelPair{} }
|
|
func (*LegacyLabelPair) ProtoMessage() {}
|
|
func (*LegacyLabelPair) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{20}
|
|
}
|
|
func (m *LegacyLabelPair) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *LegacyLabelPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_LegacyLabelPair.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 *LegacyLabelPair) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LegacyLabelPair.Merge(m, src)
|
|
}
|
|
func (m *LegacyLabelPair) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *LegacyLabelPair) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LegacyLabelPair.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LegacyLabelPair proto.InternalMessageInfo
|
|
|
|
func (m *LegacyLabelPair) GetName() []byte {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LegacyLabelPair) GetValue() []byte {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Chunk struct {
|
|
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
|
|
}
|
|
|
|
func (m *Chunk) Reset() { *m = Chunk{} }
|
|
func (*Chunk) ProtoMessage() {}
|
|
func (*Chunk) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{21}
|
|
}
|
|
func (m *Chunk) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Chunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Chunk.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 *Chunk) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Chunk.Merge(m, src)
|
|
}
|
|
func (m *Chunk) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Chunk) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Chunk.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Chunk proto.InternalMessageInfo
|
|
|
|
func (m *Chunk) GetData() []byte {
|
|
if m != nil {
|
|
return m.Data
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type TailersCountRequest struct {
|
|
}
|
|
|
|
func (m *TailersCountRequest) Reset() { *m = TailersCountRequest{} }
|
|
func (*TailersCountRequest) ProtoMessage() {}
|
|
func (*TailersCountRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{22}
|
|
}
|
|
func (m *TailersCountRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *TailersCountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_TailersCountRequest.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 *TailersCountRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TailersCountRequest.Merge(m, src)
|
|
}
|
|
func (m *TailersCountRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *TailersCountRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TailersCountRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TailersCountRequest proto.InternalMessageInfo
|
|
|
|
type TailersCountResponse struct {
|
|
Count uint32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
|
|
}
|
|
|
|
func (m *TailersCountResponse) Reset() { *m = TailersCountResponse{} }
|
|
func (*TailersCountResponse) ProtoMessage() {}
|
|
func (*TailersCountResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{23}
|
|
}
|
|
func (m *TailersCountResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *TailersCountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_TailersCountResponse.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 *TailersCountResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TailersCountResponse.Merge(m, src)
|
|
}
|
|
func (m *TailersCountResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *TailersCountResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TailersCountResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TailersCountResponse proto.InternalMessageInfo
|
|
|
|
func (m *TailersCountResponse) GetCount() uint32 {
|
|
if m != nil {
|
|
return m.Count
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type GetChunkIDsRequest struct {
|
|
Matchers string `protobuf:"bytes,1,opt,name=matchers,proto3" json:"matchers,omitempty"`
|
|
Start time.Time `protobuf:"bytes,2,opt,name=start,proto3,stdtime" json:"start"`
|
|
End time.Time `protobuf:"bytes,3,opt,name=end,proto3,stdtime" json:"end"`
|
|
}
|
|
|
|
func (m *GetChunkIDsRequest) Reset() { *m = GetChunkIDsRequest{} }
|
|
func (*GetChunkIDsRequest) ProtoMessage() {}
|
|
func (*GetChunkIDsRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{24}
|
|
}
|
|
func (m *GetChunkIDsRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetChunkIDsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetChunkIDsRequest.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 *GetChunkIDsRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetChunkIDsRequest.Merge(m, src)
|
|
}
|
|
func (m *GetChunkIDsRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetChunkIDsRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetChunkIDsRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetChunkIDsRequest proto.InternalMessageInfo
|
|
|
|
func (m *GetChunkIDsRequest) GetMatchers() string {
|
|
if m != nil {
|
|
return m.Matchers
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *GetChunkIDsRequest) GetStart() time.Time {
|
|
if m != nil {
|
|
return m.Start
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (m *GetChunkIDsRequest) GetEnd() time.Time {
|
|
if m != nil {
|
|
return m.End
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
type GetChunkIDsResponse struct {
|
|
ChunkIDs []string `protobuf:"bytes,1,rep,name=chunkIDs,proto3" json:"chunkIDs,omitempty"`
|
|
}
|
|
|
|
func (m *GetChunkIDsResponse) Reset() { *m = GetChunkIDsResponse{} }
|
|
func (*GetChunkIDsResponse) ProtoMessage() {}
|
|
func (*GetChunkIDsResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{25}
|
|
}
|
|
func (m *GetChunkIDsResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetChunkIDsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetChunkIDsResponse.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 *GetChunkIDsResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetChunkIDsResponse.Merge(m, src)
|
|
}
|
|
func (m *GetChunkIDsResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetChunkIDsResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetChunkIDsResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetChunkIDsResponse proto.InternalMessageInfo
|
|
|
|
func (m *GetChunkIDsResponse) GetChunkIDs() []string {
|
|
if m != nil {
|
|
return m.ChunkIDs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ChunkRef contains the metadata to reference a Chunk.
|
|
// It is embedded by the Chunk type itself and used to generate the Chunk
|
|
// checksum. So it is imported to take care of the JSON representation of the
|
|
// resulting Go struct.
|
|
type ChunkRef struct {
|
|
Fingerprint uint64 `protobuf:"varint,1,opt,name=fingerprint,proto3" json:"fingerprint"`
|
|
UserID string `protobuf:"bytes,2,opt,name=user_id,json=userId,proto3" json:"userID"`
|
|
From github_com_prometheus_common_model.Time `protobuf:"varint,3,opt,name=from,proto3,customtype=github.com/prometheus/common/model.Time" json:"from"`
|
|
Through github_com_prometheus_common_model.Time `protobuf:"varint,4,opt,name=through,proto3,customtype=github.com/prometheus/common/model.Time" json:"through"`
|
|
// The checksum is not written to the external storage. We use crc32,
|
|
// Castagnoli table. See http://www.evanjones.ca/crc32c.html.
|
|
Checksum uint32 `protobuf:"varint,5,opt,name=checksum,proto3" json:"-"`
|
|
}
|
|
|
|
func (m *ChunkRef) Reset() { *m = ChunkRef{} }
|
|
func (*ChunkRef) ProtoMessage() {}
|
|
func (*ChunkRef) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{26}
|
|
}
|
|
func (m *ChunkRef) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ChunkRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ChunkRef.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 *ChunkRef) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ChunkRef.Merge(m, src)
|
|
}
|
|
func (m *ChunkRef) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ChunkRef) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ChunkRef.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ChunkRef proto.InternalMessageInfo
|
|
|
|
func (m *ChunkRef) GetFingerprint() uint64 {
|
|
if m != nil {
|
|
return m.Fingerprint
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ChunkRef) GetUserID() string {
|
|
if m != nil {
|
|
return m.UserID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ChunkRef) GetChecksum() uint32 {
|
|
if m != nil {
|
|
return m.Checksum
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type LabelValuesForMetricNameRequest struct {
|
|
MetricName string `protobuf:"bytes,1,opt,name=metric_name,json=metricName,proto3" json:"metric_name,omitempty"`
|
|
LabelName string `protobuf:"bytes,2,opt,name=label_name,json=labelName,proto3" json:"label_name,omitempty"`
|
|
From github_com_prometheus_common_model.Time `protobuf:"varint,3,opt,name=from,proto3,customtype=github.com/prometheus/common/model.Time" json:"from"`
|
|
Through github_com_prometheus_common_model.Time `protobuf:"varint,4,opt,name=through,proto3,customtype=github.com/prometheus/common/model.Time" json:"through"`
|
|
Matchers string `protobuf:"bytes,5,opt,name=matchers,proto3" json:"matchers,omitempty"`
|
|
}
|
|
|
|
func (m *LabelValuesForMetricNameRequest) Reset() { *m = LabelValuesForMetricNameRequest{} }
|
|
func (*LabelValuesForMetricNameRequest) ProtoMessage() {}
|
|
func (*LabelValuesForMetricNameRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{27}
|
|
}
|
|
func (m *LabelValuesForMetricNameRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *LabelValuesForMetricNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_LabelValuesForMetricNameRequest.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 *LabelValuesForMetricNameRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LabelValuesForMetricNameRequest.Merge(m, src)
|
|
}
|
|
func (m *LabelValuesForMetricNameRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *LabelValuesForMetricNameRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LabelValuesForMetricNameRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LabelValuesForMetricNameRequest proto.InternalMessageInfo
|
|
|
|
func (m *LabelValuesForMetricNameRequest) GetMetricName() string {
|
|
if m != nil {
|
|
return m.MetricName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *LabelValuesForMetricNameRequest) GetLabelName() string {
|
|
if m != nil {
|
|
return m.LabelName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *LabelValuesForMetricNameRequest) GetMatchers() string {
|
|
if m != nil {
|
|
return m.Matchers
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type LabelNamesForMetricNameRequest struct {
|
|
MetricName string `protobuf:"bytes,1,opt,name=metric_name,json=metricName,proto3" json:"metric_name,omitempty"`
|
|
From github_com_prometheus_common_model.Time `protobuf:"varint,2,opt,name=from,proto3,customtype=github.com/prometheus/common/model.Time" json:"from"`
|
|
Through github_com_prometheus_common_model.Time `protobuf:"varint,3,opt,name=through,proto3,customtype=github.com/prometheus/common/model.Time" json:"through"`
|
|
}
|
|
|
|
func (m *LabelNamesForMetricNameRequest) Reset() { *m = LabelNamesForMetricNameRequest{} }
|
|
func (*LabelNamesForMetricNameRequest) ProtoMessage() {}
|
|
func (*LabelNamesForMetricNameRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{28}
|
|
}
|
|
func (m *LabelNamesForMetricNameRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *LabelNamesForMetricNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_LabelNamesForMetricNameRequest.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 *LabelNamesForMetricNameRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LabelNamesForMetricNameRequest.Merge(m, src)
|
|
}
|
|
func (m *LabelNamesForMetricNameRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *LabelNamesForMetricNameRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LabelNamesForMetricNameRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LabelNamesForMetricNameRequest proto.InternalMessageInfo
|
|
|
|
func (m *LabelNamesForMetricNameRequest) GetMetricName() string {
|
|
if m != nil {
|
|
return m.MetricName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type LineFilterExpression struct {
|
|
Operator int64 `protobuf:"varint,1,opt,name=operator,proto3" json:"operator,omitempty"`
|
|
Match string `protobuf:"bytes,2,opt,name=match,proto3" json:"match,omitempty"`
|
|
}
|
|
|
|
func (m *LineFilterExpression) Reset() { *m = LineFilterExpression{} }
|
|
func (*LineFilterExpression) ProtoMessage() {}
|
|
func (*LineFilterExpression) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{29}
|
|
}
|
|
func (m *LineFilterExpression) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *LineFilterExpression) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_LineFilterExpression.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 *LineFilterExpression) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LineFilterExpression.Merge(m, src)
|
|
}
|
|
func (m *LineFilterExpression) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *LineFilterExpression) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LineFilterExpression.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LineFilterExpression proto.InternalMessageInfo
|
|
|
|
func (m *LineFilterExpression) GetOperator() int64 {
|
|
if m != nil {
|
|
return m.Operator
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *LineFilterExpression) GetMatch() string {
|
|
if m != nil {
|
|
return m.Match
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type GetChunkRefRequest struct {
|
|
From github_com_prometheus_common_model.Time `protobuf:"varint,1,opt,name=from,proto3,customtype=github.com/prometheus/common/model.Time" json:"from"`
|
|
Through github_com_prometheus_common_model.Time `protobuf:"varint,2,opt,name=through,proto3,customtype=github.com/prometheus/common/model.Time" json:"through"`
|
|
Matchers string `protobuf:"bytes,3,opt,name=matchers,proto3" json:"matchers,omitempty"`
|
|
Filters []*LineFilterExpression `protobuf:"bytes,4,rep,name=filters,proto3" json:"filters,omitempty"`
|
|
}
|
|
|
|
func (m *GetChunkRefRequest) Reset() { *m = GetChunkRefRequest{} }
|
|
func (*GetChunkRefRequest) ProtoMessage() {}
|
|
func (*GetChunkRefRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{30}
|
|
}
|
|
func (m *GetChunkRefRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetChunkRefRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetChunkRefRequest.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 *GetChunkRefRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetChunkRefRequest.Merge(m, src)
|
|
}
|
|
func (m *GetChunkRefRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetChunkRefRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetChunkRefRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetChunkRefRequest proto.InternalMessageInfo
|
|
|
|
func (m *GetChunkRefRequest) GetMatchers() string {
|
|
if m != nil {
|
|
return m.Matchers
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *GetChunkRefRequest) GetFilters() []*LineFilterExpression {
|
|
if m != nil {
|
|
return m.Filters
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type GetChunkRefResponse struct {
|
|
Refs []*ChunkRef `protobuf:"bytes,1,rep,name=refs,proto3" json:"refs,omitempty"`
|
|
}
|
|
|
|
func (m *GetChunkRefResponse) Reset() { *m = GetChunkRefResponse{} }
|
|
func (*GetChunkRefResponse) ProtoMessage() {}
|
|
func (*GetChunkRefResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{31}
|
|
}
|
|
func (m *GetChunkRefResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetChunkRefResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetChunkRefResponse.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 *GetChunkRefResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetChunkRefResponse.Merge(m, src)
|
|
}
|
|
func (m *GetChunkRefResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetChunkRefResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetChunkRefResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetChunkRefResponse proto.InternalMessageInfo
|
|
|
|
func (m *GetChunkRefResponse) GetRefs() []*ChunkRef {
|
|
if m != nil {
|
|
return m.Refs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type GetSeriesRequest struct {
|
|
From github_com_prometheus_common_model.Time `protobuf:"varint,1,opt,name=from,proto3,customtype=github.com/prometheus/common/model.Time" json:"from"`
|
|
Through github_com_prometheus_common_model.Time `protobuf:"varint,2,opt,name=through,proto3,customtype=github.com/prometheus/common/model.Time" json:"through"`
|
|
Matchers string `protobuf:"bytes,3,opt,name=matchers,proto3" json:"matchers,omitempty"`
|
|
}
|
|
|
|
func (m *GetSeriesRequest) Reset() { *m = GetSeriesRequest{} }
|
|
func (*GetSeriesRequest) ProtoMessage() {}
|
|
func (*GetSeriesRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{32}
|
|
}
|
|
func (m *GetSeriesRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetSeriesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetSeriesRequest.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 *GetSeriesRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetSeriesRequest.Merge(m, src)
|
|
}
|
|
func (m *GetSeriesRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetSeriesRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetSeriesRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetSeriesRequest proto.InternalMessageInfo
|
|
|
|
func (m *GetSeriesRequest) GetMatchers() string {
|
|
if m != nil {
|
|
return m.Matchers
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type GetSeriesResponse struct {
|
|
Series []IndexSeries `protobuf:"bytes,1,rep,name=series,proto3" json:"series"`
|
|
}
|
|
|
|
func (m *GetSeriesResponse) Reset() { *m = GetSeriesResponse{} }
|
|
func (*GetSeriesResponse) ProtoMessage() {}
|
|
func (*GetSeriesResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{33}
|
|
}
|
|
func (m *GetSeriesResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetSeriesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetSeriesResponse.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 *GetSeriesResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetSeriesResponse.Merge(m, src)
|
|
}
|
|
func (m *GetSeriesResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetSeriesResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetSeriesResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetSeriesResponse proto.InternalMessageInfo
|
|
|
|
func (m *GetSeriesResponse) GetSeries() []IndexSeries {
|
|
if m != nil {
|
|
return m.Series
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Series calls to the TSDB Index
|
|
type IndexSeries struct {
|
|
Labels []LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=LabelAdapter" json:"labels"`
|
|
}
|
|
|
|
func (m *IndexSeries) Reset() { *m = IndexSeries{} }
|
|
func (*IndexSeries) ProtoMessage() {}
|
|
func (*IndexSeries) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{34}
|
|
}
|
|
func (m *IndexSeries) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *IndexSeries) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_IndexSeries.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 *IndexSeries) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_IndexSeries.Merge(m, src)
|
|
}
|
|
func (m *IndexSeries) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *IndexSeries) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_IndexSeries.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_IndexSeries proto.InternalMessageInfo
|
|
|
|
type QueryIndexResponse struct {
|
|
QueryKey string `protobuf:"bytes,1,opt,name=QueryKey,proto3" json:"QueryKey,omitempty"`
|
|
Rows []*Row `protobuf:"bytes,2,rep,name=rows,proto3" json:"rows,omitempty"`
|
|
}
|
|
|
|
func (m *QueryIndexResponse) Reset() { *m = QueryIndexResponse{} }
|
|
func (*QueryIndexResponse) ProtoMessage() {}
|
|
func (*QueryIndexResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{35}
|
|
}
|
|
func (m *QueryIndexResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *QueryIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_QueryIndexResponse.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 *QueryIndexResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_QueryIndexResponse.Merge(m, src)
|
|
}
|
|
func (m *QueryIndexResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *QueryIndexResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_QueryIndexResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_QueryIndexResponse proto.InternalMessageInfo
|
|
|
|
func (m *QueryIndexResponse) GetQueryKey() string {
|
|
if m != nil {
|
|
return m.QueryKey
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *QueryIndexResponse) GetRows() []*Row {
|
|
if m != nil {
|
|
return m.Rows
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Row struct {
|
|
RangeValue []byte `protobuf:"bytes,1,opt,name=rangeValue,proto3" json:"rangeValue,omitempty"`
|
|
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
|
}
|
|
|
|
func (m *Row) Reset() { *m = Row{} }
|
|
func (*Row) ProtoMessage() {}
|
|
func (*Row) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{36}
|
|
}
|
|
func (m *Row) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Row.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 *Row) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Row.Merge(m, src)
|
|
}
|
|
func (m *Row) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Row) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Row.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Row proto.InternalMessageInfo
|
|
|
|
func (m *Row) GetRangeValue() []byte {
|
|
if m != nil {
|
|
return m.RangeValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Row) GetValue() []byte {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QueryIndexRequest struct {
|
|
Queries []*IndexQuery `protobuf:"bytes,1,rep,name=Queries,proto3" json:"Queries,omitempty"`
|
|
}
|
|
|
|
func (m *QueryIndexRequest) Reset() { *m = QueryIndexRequest{} }
|
|
func (*QueryIndexRequest) ProtoMessage() {}
|
|
func (*QueryIndexRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{37}
|
|
}
|
|
func (m *QueryIndexRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *QueryIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_QueryIndexRequest.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 *QueryIndexRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_QueryIndexRequest.Merge(m, src)
|
|
}
|
|
func (m *QueryIndexRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *QueryIndexRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_QueryIndexRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_QueryIndexRequest proto.InternalMessageInfo
|
|
|
|
func (m *QueryIndexRequest) GetQueries() []*IndexQuery {
|
|
if m != nil {
|
|
return m.Queries
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type IndexQuery struct {
|
|
TableName string `protobuf:"bytes,1,opt,name=tableName,proto3" json:"tableName,omitempty"`
|
|
HashValue string `protobuf:"bytes,2,opt,name=hashValue,proto3" json:"hashValue,omitempty"`
|
|
RangeValuePrefix []byte `protobuf:"bytes,3,opt,name=rangeValuePrefix,proto3" json:"rangeValuePrefix,omitempty"`
|
|
RangeValueStart []byte `protobuf:"bytes,4,opt,name=rangeValueStart,proto3" json:"rangeValueStart,omitempty"`
|
|
ValueEqual []byte `protobuf:"bytes,5,opt,name=valueEqual,proto3" json:"valueEqual,omitempty"`
|
|
}
|
|
|
|
func (m *IndexQuery) Reset() { *m = IndexQuery{} }
|
|
func (*IndexQuery) ProtoMessage() {}
|
|
func (*IndexQuery) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{38}
|
|
}
|
|
func (m *IndexQuery) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *IndexQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_IndexQuery.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 *IndexQuery) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_IndexQuery.Merge(m, src)
|
|
}
|
|
func (m *IndexQuery) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *IndexQuery) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_IndexQuery.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_IndexQuery proto.InternalMessageInfo
|
|
|
|
func (m *IndexQuery) GetTableName() string {
|
|
if m != nil {
|
|
return m.TableName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *IndexQuery) GetHashValue() string {
|
|
if m != nil {
|
|
return m.HashValue
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *IndexQuery) GetRangeValuePrefix() []byte {
|
|
if m != nil {
|
|
return m.RangeValuePrefix
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *IndexQuery) GetRangeValueStart() []byte {
|
|
if m != nil {
|
|
return m.RangeValueStart
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *IndexQuery) GetValueEqual() []byte {
|
|
if m != nil {
|
|
return m.ValueEqual
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type IndexStatsRequest struct {
|
|
From github_com_prometheus_common_model.Time `protobuf:"varint,1,opt,name=from,proto3,customtype=github.com/prometheus/common/model.Time" json:"from"`
|
|
Through github_com_prometheus_common_model.Time `protobuf:"varint,2,opt,name=through,proto3,customtype=github.com/prometheus/common/model.Time" json:"through"`
|
|
Matchers string `protobuf:"bytes,3,opt,name=matchers,proto3" json:"matchers,omitempty"`
|
|
}
|
|
|
|
func (m *IndexStatsRequest) Reset() { *m = IndexStatsRequest{} }
|
|
func (*IndexStatsRequest) ProtoMessage() {}
|
|
func (*IndexStatsRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{39}
|
|
}
|
|
func (m *IndexStatsRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *IndexStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_IndexStatsRequest.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 *IndexStatsRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_IndexStatsRequest.Merge(m, src)
|
|
}
|
|
func (m *IndexStatsRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *IndexStatsRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_IndexStatsRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_IndexStatsRequest proto.InternalMessageInfo
|
|
|
|
func (m *IndexStatsRequest) GetMatchers() string {
|
|
if m != nil {
|
|
return m.Matchers
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type IndexStatsResponse struct {
|
|
Streams uint64 `protobuf:"varint,1,opt,name=streams,proto3" json:"streams"`
|
|
Chunks uint64 `protobuf:"varint,2,opt,name=chunks,proto3" json:"chunks"`
|
|
Bytes uint64 `protobuf:"varint,3,opt,name=bytes,proto3" json:"bytes"`
|
|
Entries uint64 `protobuf:"varint,4,opt,name=entries,proto3" json:"entries"`
|
|
}
|
|
|
|
func (m *IndexStatsResponse) Reset() { *m = IndexStatsResponse{} }
|
|
func (*IndexStatsResponse) ProtoMessage() {}
|
|
func (*IndexStatsResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{40}
|
|
}
|
|
func (m *IndexStatsResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *IndexStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_IndexStatsResponse.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 *IndexStatsResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_IndexStatsResponse.Merge(m, src)
|
|
}
|
|
func (m *IndexStatsResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *IndexStatsResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_IndexStatsResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_IndexStatsResponse proto.InternalMessageInfo
|
|
|
|
func (m *IndexStatsResponse) GetStreams() uint64 {
|
|
if m != nil {
|
|
return m.Streams
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *IndexStatsResponse) GetChunks() uint64 {
|
|
if m != nil {
|
|
return m.Chunks
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *IndexStatsResponse) GetBytes() uint64 {
|
|
if m != nil {
|
|
return m.Bytes
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *IndexStatsResponse) GetEntries() uint64 {
|
|
if m != nil {
|
|
return m.Entries
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type VolumeRequest struct {
|
|
From github_com_prometheus_common_model.Time `protobuf:"varint,1,opt,name=from,proto3,customtype=github.com/prometheus/common/model.Time" json:"from"`
|
|
Through github_com_prometheus_common_model.Time `protobuf:"varint,2,opt,name=through,proto3,customtype=github.com/prometheus/common/model.Time" json:"through"`
|
|
Matchers string `protobuf:"bytes,3,opt,name=matchers,proto3" json:"matchers,omitempty"`
|
|
Limit int32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
|
|
Step int64 `protobuf:"varint,5,opt,name=step,proto3" json:"step,omitempty"`
|
|
TargetLabels []string `protobuf:"bytes,6,rep,name=targetLabels,proto3" json:"targetLabels,omitempty"`
|
|
AggregateBy string `protobuf:"bytes,7,opt,name=aggregateBy,proto3" json:"aggregateBy,omitempty"`
|
|
}
|
|
|
|
func (m *VolumeRequest) Reset() { *m = VolumeRequest{} }
|
|
func (*VolumeRequest) ProtoMessage() {}
|
|
func (*VolumeRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{41}
|
|
}
|
|
func (m *VolumeRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *VolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_VolumeRequest.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 *VolumeRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_VolumeRequest.Merge(m, src)
|
|
}
|
|
func (m *VolumeRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *VolumeRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_VolumeRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_VolumeRequest proto.InternalMessageInfo
|
|
|
|
func (m *VolumeRequest) GetMatchers() string {
|
|
if m != nil {
|
|
return m.Matchers
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *VolumeRequest) GetLimit() int32 {
|
|
if m != nil {
|
|
return m.Limit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *VolumeRequest) GetStep() int64 {
|
|
if m != nil {
|
|
return m.Step
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *VolumeRequest) GetTargetLabels() []string {
|
|
if m != nil {
|
|
return m.TargetLabels
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *VolumeRequest) GetAggregateBy() string {
|
|
if m != nil {
|
|
return m.AggregateBy
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type VolumeResponse struct {
|
|
Volumes []Volume `protobuf:"bytes,1,rep,name=volumes,proto3" json:"volumes"`
|
|
Limit int32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
|
|
}
|
|
|
|
func (m *VolumeResponse) Reset() { *m = VolumeResponse{} }
|
|
func (*VolumeResponse) ProtoMessage() {}
|
|
func (*VolumeResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{42}
|
|
}
|
|
func (m *VolumeResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *VolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_VolumeResponse.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 *VolumeResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_VolumeResponse.Merge(m, src)
|
|
}
|
|
func (m *VolumeResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *VolumeResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_VolumeResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_VolumeResponse proto.InternalMessageInfo
|
|
|
|
func (m *VolumeResponse) GetVolumes() []Volume {
|
|
if m != nil {
|
|
return m.Volumes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *VolumeResponse) GetLimit() int32 {
|
|
if m != nil {
|
|
return m.Limit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Volume struct {
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name"`
|
|
Volume uint64 `protobuf:"varint,3,opt,name=volume,proto3" json:"volume"`
|
|
}
|
|
|
|
func (m *Volume) Reset() { *m = Volume{} }
|
|
func (*Volume) ProtoMessage() {}
|
|
func (*Volume) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_c28a5f14f1f4c79a, []int{43}
|
|
}
|
|
func (m *Volume) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Volume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Volume.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 *Volume) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Volume.Merge(m, src)
|
|
}
|
|
func (m *Volume) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Volume) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Volume.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Volume proto.InternalMessageInfo
|
|
|
|
func (m *Volume) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Volume) GetVolume() uint64 {
|
|
if m != nil {
|
|
return m.Volume
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterEnum("logproto.Direction", Direction_name, Direction_value)
|
|
proto.RegisterType((*StreamRatesRequest)(nil), "logproto.StreamRatesRequest")
|
|
proto.RegisterType((*StreamRatesResponse)(nil), "logproto.StreamRatesResponse")
|
|
proto.RegisterType((*StreamRate)(nil), "logproto.StreamRate")
|
|
proto.RegisterType((*QueryRequest)(nil), "logproto.QueryRequest")
|
|
proto.RegisterType((*SampleQueryRequest)(nil), "logproto.SampleQueryRequest")
|
|
proto.RegisterType((*Delete)(nil), "logproto.Delete")
|
|
proto.RegisterType((*QueryResponse)(nil), "logproto.QueryResponse")
|
|
proto.RegisterType((*SampleQueryResponse)(nil), "logproto.SampleQueryResponse")
|
|
proto.RegisterType((*LabelRequest)(nil), "logproto.LabelRequest")
|
|
proto.RegisterType((*LabelResponse)(nil), "logproto.LabelResponse")
|
|
proto.RegisterType((*Sample)(nil), "logproto.Sample")
|
|
proto.RegisterType((*LegacySample)(nil), "logproto.LegacySample")
|
|
proto.RegisterType((*Series)(nil), "logproto.Series")
|
|
proto.RegisterType((*TailRequest)(nil), "logproto.TailRequest")
|
|
proto.RegisterType((*TailResponse)(nil), "logproto.TailResponse")
|
|
proto.RegisterType((*SeriesRequest)(nil), "logproto.SeriesRequest")
|
|
proto.RegisterType((*SeriesResponse)(nil), "logproto.SeriesResponse")
|
|
proto.RegisterType((*SeriesIdentifier)(nil), "logproto.SeriesIdentifier")
|
|
proto.RegisterMapType((map[string]string)(nil), "logproto.SeriesIdentifier.LabelsEntry")
|
|
proto.RegisterType((*DroppedStream)(nil), "logproto.DroppedStream")
|
|
proto.RegisterType((*LabelPair)(nil), "logproto.LabelPair")
|
|
proto.RegisterType((*LegacyLabelPair)(nil), "logproto.LegacyLabelPair")
|
|
proto.RegisterType((*Chunk)(nil), "logproto.Chunk")
|
|
proto.RegisterType((*TailersCountRequest)(nil), "logproto.TailersCountRequest")
|
|
proto.RegisterType((*TailersCountResponse)(nil), "logproto.TailersCountResponse")
|
|
proto.RegisterType((*GetChunkIDsRequest)(nil), "logproto.GetChunkIDsRequest")
|
|
proto.RegisterType((*GetChunkIDsResponse)(nil), "logproto.GetChunkIDsResponse")
|
|
proto.RegisterType((*ChunkRef)(nil), "logproto.ChunkRef")
|
|
proto.RegisterType((*LabelValuesForMetricNameRequest)(nil), "logproto.LabelValuesForMetricNameRequest")
|
|
proto.RegisterType((*LabelNamesForMetricNameRequest)(nil), "logproto.LabelNamesForMetricNameRequest")
|
|
proto.RegisterType((*LineFilterExpression)(nil), "logproto.LineFilterExpression")
|
|
proto.RegisterType((*GetChunkRefRequest)(nil), "logproto.GetChunkRefRequest")
|
|
proto.RegisterType((*GetChunkRefResponse)(nil), "logproto.GetChunkRefResponse")
|
|
proto.RegisterType((*GetSeriesRequest)(nil), "logproto.GetSeriesRequest")
|
|
proto.RegisterType((*GetSeriesResponse)(nil), "logproto.GetSeriesResponse")
|
|
proto.RegisterType((*IndexSeries)(nil), "logproto.IndexSeries")
|
|
proto.RegisterType((*QueryIndexResponse)(nil), "logproto.QueryIndexResponse")
|
|
proto.RegisterType((*Row)(nil), "logproto.Row")
|
|
proto.RegisterType((*QueryIndexRequest)(nil), "logproto.QueryIndexRequest")
|
|
proto.RegisterType((*IndexQuery)(nil), "logproto.IndexQuery")
|
|
proto.RegisterType((*IndexStatsRequest)(nil), "logproto.IndexStatsRequest")
|
|
proto.RegisterType((*IndexStatsResponse)(nil), "logproto.IndexStatsResponse")
|
|
proto.RegisterType((*VolumeRequest)(nil), "logproto.VolumeRequest")
|
|
proto.RegisterType((*VolumeResponse)(nil), "logproto.VolumeResponse")
|
|
proto.RegisterType((*Volume)(nil), "logproto.Volume")
|
|
}
|
|
|
|
func init() { proto.RegisterFile("pkg/logproto/logproto.proto", fileDescriptor_c28a5f14f1f4c79a) }
|
|
|
|
var fileDescriptor_c28a5f14f1f4c79a = []byte{
|
|
// 2202 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x19, 0x4d, 0x8f, 0x1b, 0x49,
|
|
0xd5, 0x6d, 0xb7, 0xbf, 0x9e, 0x3d, 0x93, 0x49, 0x8d, 0x37, 0xb1, 0x9c, 0xc4, 0x9e, 0x94, 0x96,
|
|
0xec, 0x28, 0x9b, 0xb5, 0x37, 0xb3, 0xb0, 0x64, 0x13, 0x16, 0x88, 0x67, 0xf2, 0x31, 0xc9, 0xe4,
|
|
0x83, 0x9a, 0x10, 0xd0, 0x0a, 0x14, 0xf5, 0xd8, 0x65, 0xbb, 0x15, 0xb7, 0xdb, 0xe9, 0x2e, 0x6f,
|
|
0x32, 0x12, 0x07, 0xfe, 0xc0, 0x4a, 0x7b, 0x43, 0x5c, 0x10, 0x07, 0x24, 0x90, 0x10, 0x17, 0x7e,
|
|
0x00, 0x5c, 0x90, 0x08, 0xb7, 0x70, 0x5b, 0x71, 0x30, 0x64, 0x72, 0x41, 0x73, 0xda, 0x1b, 0x12,
|
|
0x07, 0x84, 0xea, 0xab, 0xbb, 0xec, 0xf1, 0xec, 0xae, 0x43, 0x24, 0x94, 0x8b, 0xbb, 0xde, 0xab,
|
|
0x57, 0xaf, 0xde, 0x77, 0xd5, 0x2b, 0xc3, 0x89, 0xe1, 0xc3, 0x6e, 0xa3, 0xef, 0x77, 0x87, 0x81,
|
|
0xcf, 0xfc, 0x68, 0x50, 0x17, 0xbf, 0x28, 0xa7, 0xe1, 0x4a, 0xa9, 0xeb, 0x77, 0x7d, 0x49, 0xc3,
|
|
0x47, 0x72, 0xbe, 0x52, 0xeb, 0xfa, 0x7e, 0xb7, 0x4f, 0x1b, 0x02, 0xda, 0x19, 0x75, 0x1a, 0xcc,
|
|
0xf5, 0x68, 0xc8, 0x1c, 0x6f, 0xa8, 0x08, 0x56, 0x14, 0xf7, 0x47, 0x7d, 0xcf, 0x6f, 0xd3, 0x7e,
|
|
0x23, 0x64, 0x0e, 0x0b, 0xe5, 0xaf, 0xa2, 0x58, 0xe6, 0x14, 0xc3, 0x51, 0xd8, 0x13, 0x3f, 0x12,
|
|
0x89, 0x4b, 0x80, 0xb6, 0x59, 0x40, 0x1d, 0x8f, 0x38, 0x8c, 0x86, 0x84, 0x3e, 0x1a, 0xd1, 0x90,
|
|
0xe1, 0x5b, 0xb0, 0x3c, 0x81, 0x0d, 0x87, 0xfe, 0x20, 0xa4, 0xe8, 0x7d, 0x28, 0x84, 0x31, 0xba,
|
|
0x6c, 0xad, 0xa4, 0x56, 0x0b, 0x6b, 0xa5, 0x7a, 0xa4, 0x4a, 0xbc, 0x86, 0x98, 0x84, 0xf8, 0x17,
|
|
0x16, 0x40, 0x3c, 0x87, 0xaa, 0x00, 0x72, 0xf6, 0xba, 0x13, 0xf6, 0xca, 0xd6, 0x8a, 0xb5, 0x6a,
|
|
0x13, 0x03, 0x83, 0xce, 0xc1, 0xd1, 0x18, 0xba, 0xed, 0x6f, 0xf7, 0x9c, 0xa0, 0x5d, 0x4e, 0x0a,
|
|
0xb2, 0x83, 0x13, 0x08, 0x81, 0x1d, 0x38, 0x8c, 0x96, 0x53, 0x2b, 0xd6, 0x6a, 0x8a, 0x88, 0x31,
|
|
0x3a, 0x06, 0x19, 0x46, 0x07, 0xce, 0x80, 0x95, 0xed, 0x15, 0x6b, 0x35, 0x4f, 0x14, 0xc4, 0xf1,
|
|
0x5c, 0x77, 0x1a, 0x96, 0xd3, 0x2b, 0xd6, 0xea, 0x02, 0x51, 0x10, 0xfe, 0x73, 0x12, 0x8a, 0xdf,
|
|
0x1b, 0xd1, 0x60, 0x57, 0x19, 0x00, 0x55, 0x20, 0x17, 0xd2, 0x3e, 0x6d, 0x31, 0x3f, 0x10, 0x02,
|
|
0xe6, 0x49, 0x04, 0xa3, 0x12, 0xa4, 0xfb, 0xae, 0xe7, 0x32, 0x21, 0xd2, 0x02, 0x91, 0x00, 0xba,
|
|
0x08, 0xe9, 0x90, 0x39, 0x01, 0x13, 0x72, 0x14, 0xd6, 0x2a, 0x75, 0xe9, 0xb0, 0xba, 0x76, 0x58,
|
|
0xfd, 0x9e, 0x76, 0x58, 0x33, 0xf7, 0x74, 0x5c, 0x4b, 0x7c, 0xfa, 0xf7, 0x9a, 0x45, 0xe4, 0x12,
|
|
0xf4, 0x3e, 0xa4, 0xe8, 0xa0, 0x2d, 0x64, 0xfd, 0xaa, 0x2b, 0xf9, 0x02, 0x74, 0x1e, 0xf2, 0x6d,
|
|
0x37, 0xa0, 0x2d, 0xe6, 0xfa, 0x03, 0xa1, 0xd1, 0xe2, 0xda, 0x72, 0xec, 0x8d, 0x0d, 0x3d, 0x45,
|
|
0x62, 0x2a, 0x74, 0x0e, 0x32, 0x21, 0x37, 0x5b, 0x58, 0xce, 0xae, 0xa4, 0x56, 0xf3, 0xcd, 0xd2,
|
|
0xfe, 0xb8, 0xb6, 0x24, 0x31, 0xe7, 0x7c, 0xcf, 0x65, 0xd4, 0x1b, 0xb2, 0x5d, 0xa2, 0x68, 0xd0,
|
|
0x59, 0xc8, 0xb6, 0x69, 0x9f, 0x72, 0x67, 0xe7, 0x84, 0xb3, 0x97, 0x0c, 0xf6, 0x62, 0x82, 0x68,
|
|
0x82, 0x1b, 0x76, 0x2e, 0xb3, 0x94, 0xc5, 0xff, 0xb1, 0x00, 0x6d, 0x3b, 0xde, 0xb0, 0x4f, 0xbf,
|
|
0xb2, 0x3d, 0x23, 0xcb, 0x25, 0x5f, 0xda, 0x72, 0xa9, 0x79, 0x2d, 0x17, 0x9b, 0xc1, 0x9e, 0xcf,
|
|
0x0c, 0xe9, 0x2f, 0x31, 0x03, 0xde, 0x82, 0x8c, 0x44, 0x7d, 0x59, 0x0c, 0xc5, 0x3a, 0xa7, 0xb4,
|
|
0x36, 0x4b, 0xb1, 0x36, 0x29, 0x21, 0x27, 0xfe, 0xa5, 0x05, 0x0b, 0xca, 0x90, 0x2a, 0x07, 0x77,
|
|
0x20, 0x2b, 0x73, 0x40, 0xe7, 0xdf, 0xf1, 0xe9, 0xfc, 0xbb, 0xdc, 0x76, 0x86, 0x8c, 0x06, 0xcd,
|
|
0xc6, 0xd3, 0x71, 0xcd, 0xfa, 0xdb, 0xb8, 0xf6, 0x56, 0xd7, 0x65, 0xbd, 0xd1, 0x4e, 0xbd, 0xe5,
|
|
0x7b, 0x8d, 0x6e, 0xe0, 0x74, 0x9c, 0x81, 0xd3, 0xe8, 0xfb, 0x0f, 0xdd, 0x86, 0xae, 0x07, 0x3a,
|
|
0x6f, 0x35, 0x63, 0xf4, 0xb6, 0x90, 0x8e, 0x85, 0xca, 0x23, 0x47, 0xea, 0xb2, 0x8c, 0x6c, 0x0e,
|
|
0xba, 0x34, 0xe4, 0x9c, 0x6d, 0x6e, 0x4c, 0x22, 0x69, 0xf0, 0x4f, 0x60, 0x79, 0xc2, 0xe1, 0x4a,
|
|
0xce, 0x0b, 0x90, 0x09, 0x69, 0xe0, 0x46, 0x65, 0xc2, 0x30, 0xd9, 0xb6, 0xc0, 0x37, 0x17, 0x95,
|
|
0x7c, 0x19, 0x09, 0x13, 0x45, 0x3f, 0xdf, 0xee, 0x7f, 0xb2, 0xa0, 0xb8, 0xe5, 0xec, 0xd0, 0xbe,
|
|
0x8e, 0x34, 0x04, 0xf6, 0xc0, 0xf1, 0xa8, 0xb2, 0xb8, 0x18, 0xf3, 0xb4, 0xff, 0xd8, 0xe9, 0x8f,
|
|
0xa8, 0x64, 0x99, 0x23, 0x0a, 0x9a, 0x37, 0x67, 0xad, 0x97, 0xce, 0x59, 0x2b, 0x8e, 0xbc, 0x12,
|
|
0xa4, 0x1f, 0x71, 0x43, 0x89, 0x7c, 0xcd, 0x13, 0x09, 0xe0, 0xb7, 0x60, 0x41, 0x69, 0xa1, 0xcc,
|
|
0x17, 0x8b, 0xcc, 0xcd, 0x97, 0xd7, 0x22, 0x63, 0x0f, 0x32, 0xd2, 0xda, 0xe8, 0x4d, 0xc8, 0x47,
|
|
0x67, 0x80, 0xd0, 0x36, 0xd5, 0xcc, 0xec, 0x8f, 0x6b, 0x49, 0x16, 0x92, 0x78, 0x02, 0xd5, 0x20,
|
|
0x2d, 0x56, 0x0a, 0xcd, 0xad, 0x66, 0x7e, 0x7f, 0x5c, 0x93, 0x08, 0x22, 0x3f, 0xe8, 0x24, 0xd8,
|
|
0x3d, 0x5e, 0x86, 0xb9, 0x09, 0xec, 0x66, 0x6e, 0x7f, 0x5c, 0x13, 0x30, 0x11, 0xbf, 0xf8, 0x1a,
|
|
0x14, 0xb7, 0x68, 0xd7, 0x69, 0xed, 0xaa, 0x4d, 0x4b, 0x9a, 0x1d, 0xdf, 0xd0, 0xd2, 0x3c, 0x4e,
|
|
0x43, 0x31, 0xda, 0xf1, 0x81, 0x17, 0xaa, 0xa0, 0x2e, 0x44, 0xb8, 0x5b, 0x21, 0xfe, 0xb9, 0x05,
|
|
0xca, 0xcf, 0x08, 0x43, 0xa6, 0xcf, 0x75, 0x0d, 0xa5, 0x8f, 0x9a, 0xb0, 0x3f, 0xae, 0x29, 0x0c,
|
|
0x51, 0x5f, 0x74, 0x09, 0xb2, 0xa1, 0xd8, 0x91, 0x33, 0x9b, 0x0e, 0x1f, 0x31, 0xd1, 0x3c, 0xc2,
|
|
0xc3, 0x60, 0x7f, 0x5c, 0xd3, 0x84, 0x44, 0x0f, 0x50, 0x7d, 0xe2, 0x7c, 0x91, 0x8a, 0x2d, 0xee,
|
|
0x8f, 0x6b, 0x06, 0xd6, 0x3c, 0x6f, 0xf0, 0xcf, 0x2c, 0x28, 0xdc, 0x73, 0xdc, 0x28, 0x84, 0x22,
|
|
0x17, 0x59, 0x86, 0x8b, 0x78, 0x3a, 0xb7, 0x69, 0xdf, 0xd9, 0xbd, 0xea, 0x07, 0x82, 0xe7, 0x02,
|
|
0x89, 0xe0, 0xf8, 0x48, 0xb0, 0x67, 0x1e, 0x09, 0xe9, 0xb9, 0x0b, 0xdb, 0x0d, 0x3b, 0x97, 0x5c,
|
|
0x4a, 0xe1, 0xdf, 0x59, 0x50, 0x94, 0x92, 0xa9, 0xb0, 0xf8, 0x11, 0x64, 0xa4, 0xe0, 0x42, 0xb6,
|
|
0x2f, 0x48, 0xfe, 0xb7, 0xe7, 0x49, 0x7c, 0xc5, 0x13, 0x7d, 0x07, 0x16, 0xdb, 0x81, 0x3f, 0x1c,
|
|
0xd2, 0xf6, 0xb6, 0x2a, 0x31, 0xc9, 0xe9, 0x12, 0xb3, 0x61, 0xce, 0x93, 0x29, 0x72, 0xfc, 0x17,
|
|
0x0b, 0x16, 0x54, 0x36, 0x2b, 0x5b, 0x46, 0x36, 0xb0, 0x5e, 0xba, 0xb8, 0x27, 0xe7, 0x2d, 0xee,
|
|
0xc7, 0x20, 0xd3, 0x0d, 0xfc, 0xd1, 0x30, 0x2c, 0xa7, 0x64, 0xee, 0x48, 0x68, 0xbe, 0xa2, 0x8f,
|
|
0x6f, 0xc0, 0xa2, 0x56, 0xe5, 0x90, 0x92, 0x56, 0x99, 0x2e, 0x69, 0x9b, 0x6d, 0x3a, 0x60, 0x6e,
|
|
0xc7, 0x8d, 0x8a, 0x94, 0xa2, 0xc7, 0x9f, 0x58, 0xb0, 0x34, 0x4d, 0x82, 0xbe, 0x6d, 0xe4, 0x01,
|
|
0x67, 0x77, 0xe6, 0x70, 0x76, 0x75, 0x51, 0x1c, 0xc2, 0x2b, 0x03, 0x16, 0xec, 0xea, 0x1c, 0xa9,
|
|
0x7c, 0x00, 0x05, 0x03, 0xcd, 0x0f, 0x8f, 0x87, 0x54, 0xc7, 0x2c, 0x1f, 0xc6, 0xc9, 0x9a, 0x94,
|
|
0x71, 0x2c, 0x80, 0x8b, 0xc9, 0x0b, 0x16, 0x8f, 0xf8, 0x85, 0x09, 0x4f, 0xa2, 0x0b, 0x60, 0x77,
|
|
0x02, 0xdf, 0x9b, 0xcb, 0x4d, 0x62, 0x05, 0xfa, 0x3a, 0x24, 0x99, 0x3f, 0x97, 0x93, 0x92, 0xcc,
|
|
0xe7, 0x3e, 0x52, 0xca, 0xa7, 0xe4, 0x0d, 0x4d, 0x42, 0xf8, 0x1b, 0x90, 0x17, 0x4a, 0xdd, 0x75,
|
|
0xdc, 0x60, 0x66, 0x2d, 0x9f, 0xa9, 0x14, 0xbe, 0x04, 0x47, 0x64, 0x9d, 0x9a, 0xbd, 0xb8, 0x38,
|
|
0x6b, 0x71, 0x51, 0x2f, 0x3e, 0x01, 0xe9, 0xf5, 0xde, 0x68, 0xf0, 0x90, 0x2f, 0x69, 0x3b, 0xcc,
|
|
0xd1, 0x4b, 0xf8, 0x18, 0xbf, 0x01, 0xcb, 0x3c, 0x03, 0x69, 0x10, 0xae, 0xfb, 0xa3, 0x01, 0xd3,
|
|
0x37, 0xe4, 0x73, 0x50, 0x9a, 0x44, 0xab, 0x18, 0x29, 0x41, 0xba, 0xc5, 0x11, 0x82, 0xc7, 0x02,
|
|
0x91, 0x00, 0xfe, 0x95, 0x05, 0xe8, 0x1a, 0x65, 0x62, 0x97, 0xcd, 0x8d, 0xd0, 0xb8, 0x15, 0x79,
|
|
0x0e, 0x6b, 0xf5, 0x68, 0x10, 0xea, 0x1b, 0x82, 0x86, 0xff, 0x1f, 0xb7, 0x22, 0x7c, 0x1e, 0x96,
|
|
0x27, 0xa4, 0x54, 0x3a, 0x55, 0x20, 0xd7, 0x52, 0x38, 0x75, 0x1a, 0x45, 0x30, 0xfe, 0x7d, 0x12,
|
|
0x72, 0x62, 0x01, 0xa1, 0x1d, 0x74, 0x1e, 0x0a, 0x1d, 0x77, 0xd0, 0xa5, 0xc1, 0x30, 0x70, 0x95,
|
|
0x09, 0xec, 0xe6, 0x91, 0xfd, 0x71, 0xcd, 0x44, 0x13, 0x13, 0x40, 0xef, 0x40, 0x76, 0x14, 0xd2,
|
|
0xe0, 0x81, 0x2b, 0xf3, 0x3c, 0xdf, 0x2c, 0xed, 0x8d, 0x6b, 0x99, 0xef, 0x87, 0x34, 0xd8, 0xdc,
|
|
0xe0, 0xe7, 0xc2, 0x48, 0x8c, 0x88, 0xfc, 0xb6, 0xd1, 0x4d, 0x15, 0xa6, 0xe2, 0x8a, 0xd4, 0xfc,
|
|
0x26, 0x17, 0x7f, 0xaa, 0xd0, 0x0d, 0x03, 0xdf, 0xa3, 0xac, 0x47, 0x47, 0x61, 0xa3, 0xe5, 0x7b,
|
|
0x9e, 0x3f, 0x68, 0x88, 0x7e, 0x48, 0x28, 0xcd, 0x0f, 0x37, 0xbe, 0x5c, 0x45, 0xee, 0x3d, 0xc8,
|
|
0xb2, 0x5e, 0xe0, 0x8f, 0xba, 0x3d, 0x51, 0xb7, 0x53, 0xcd, 0x8b, 0xf3, 0xf3, 0xd3, 0x1c, 0x88,
|
|
0x1e, 0xa0, 0xd3, 0xdc, 0x5a, 0xb4, 0xf5, 0x30, 0x1c, 0x79, 0xb2, 0xcb, 0x68, 0xa6, 0xf7, 0xc7,
|
|
0x35, 0xeb, 0x1d, 0x12, 0xa1, 0xf1, 0x27, 0x49, 0xa8, 0x89, 0x40, 0xbd, 0x2f, 0x0e, 0xf5, 0xab,
|
|
0x7e, 0x70, 0x8b, 0xb2, 0xc0, 0x6d, 0xdd, 0x76, 0x3c, 0xaa, 0x63, 0xa3, 0x06, 0x05, 0x4f, 0x20,
|
|
0x1f, 0x18, 0x29, 0x00, 0x5e, 0x44, 0x87, 0x4e, 0x01, 0x88, 0x9c, 0x91, 0xf3, 0x32, 0x1b, 0xf2,
|
|
0x02, 0x23, 0xa6, 0xd7, 0x27, 0x2c, 0xd5, 0x98, 0x53, 0x33, 0x65, 0xa1, 0xcd, 0x69, 0x0b, 0xcd,
|
|
0xcd, 0x27, 0x32, 0x8b, 0x19, 0xeb, 0xe9, 0xc9, 0x58, 0xc7, 0x7f, 0xb5, 0xa0, 0xba, 0xa5, 0x25,
|
|
0x7f, 0x49, 0x73, 0x68, 0x7d, 0x93, 0xaf, 0x48, 0xdf, 0xd4, 0xff, 0xa6, 0x2f, 0xbe, 0x0e, 0xa5,
|
|
0x2d, 0x77, 0x40, 0xaf, 0xba, 0x7d, 0x46, 0x83, 0x2b, 0x4f, 0x86, 0x01, 0x0d, 0x43, 0xde, 0x80,
|
|
0x55, 0x20, 0xe7, 0x0f, 0x69, 0xe0, 0xe8, 0xae, 0x20, 0x45, 0x22, 0x98, 0x17, 0x0f, 0x61, 0x13,
|
|
0x5d, 0xdb, 0x04, 0x80, 0xff, 0x6d, 0x14, 0x0f, 0x42, 0x3b, 0xda, 0x22, 0xeb, 0x46, 0xc5, 0x7e,
|
|
0x15, 0x0a, 0x27, 0x5f, 0xa1, 0x83, 0x53, 0x53, 0xc5, 0xec, 0x02, 0x64, 0x3b, 0xc2, 0x10, 0xf2,
|
|
0xe8, 0x2d, 0xac, 0x55, 0xe3, 0xb3, 0x6e, 0x96, 0x95, 0x88, 0x26, 0xc7, 0x1f, 0xc6, 0x25, 0x49,
|
|
0xe8, 0xae, 0x4a, 0xd2, 0x19, 0xb0, 0x03, 0xda, 0xd1, 0x27, 0x27, 0x8a, 0xb9, 0x45, 0x94, 0x62,
|
|
0x1e, 0xff, 0xc1, 0x82, 0xa5, 0x6b, 0x94, 0x4d, 0xde, 0x49, 0x5e, 0x23, 0xcb, 0xe1, 0xeb, 0x70,
|
|
0xd4, 0x90, 0x5f, 0x69, 0xff, 0xde, 0xd4, 0x45, 0xe4, 0x8d, 0x58, 0xff, 0xcd, 0x41, 0x9b, 0x3e,
|
|
0x51, 0x0d, 0xd6, 0xe4, 0x1d, 0xe4, 0x2e, 0x14, 0x8c, 0x49, 0x74, 0x79, 0xea, 0xf6, 0x61, 0x3c,
|
|
0x1c, 0x44, 0x67, 0x68, 0xb3, 0xa4, 0x74, 0x92, 0x2d, 0x96, 0xba, 0x5b, 0x46, 0x67, 0xf5, 0x36,
|
|
0x20, 0xd1, 0xf3, 0x09, 0xb6, 0xe6, 0x69, 0x21, 0xb0, 0x37, 0xa3, 0xcb, 0x48, 0x04, 0xa3, 0xd3,
|
|
0x60, 0x07, 0xfe, 0x63, 0x7d, 0xad, 0x5c, 0x88, 0xb7, 0x24, 0xfe, 0x63, 0x22, 0xa6, 0xf0, 0x25,
|
|
0x48, 0x11, 0xff, 0x31, 0xaa, 0x02, 0x04, 0xce, 0xa0, 0x4b, 0xef, 0x47, 0xdd, 0x46, 0x91, 0x18,
|
|
0x98, 0x43, 0x4e, 0xf2, 0x75, 0x38, 0x6a, 0x4a, 0x24, 0xdd, 0x5d, 0x87, 0x2c, 0x47, 0xba, 0xb3,
|
|
0x5e, 0xac, 0x04, 0xa1, 0x6c, 0x5c, 0x35, 0x11, 0x8f, 0x19, 0x88, 0xf1, 0xe8, 0x24, 0xe4, 0x99,
|
|
0xb3, 0xd3, 0xa7, 0xb7, 0xe3, 0xba, 0x13, 0x23, 0xf8, 0x2c, 0x6f, 0x94, 0xee, 0x1b, 0x57, 0x92,
|
|
0x18, 0x81, 0xce, 0xc2, 0x52, 0x2c, 0xf3, 0xdd, 0x80, 0x76, 0xdc, 0x27, 0xc2, 0xc3, 0x45, 0x72,
|
|
0x00, 0x8f, 0x56, 0xe1, 0x48, 0x8c, 0xdb, 0x16, 0x47, 0xbf, 0x2d, 0x48, 0xa7, 0xd1, 0xdc, 0x36,
|
|
0x42, 0xdd, 0x2b, 0x8f, 0x46, 0x4e, 0x5f, 0x14, 0xd3, 0x22, 0x31, 0x30, 0xf8, 0x8f, 0x16, 0x1c,
|
|
0x95, 0xae, 0xe6, 0x2d, 0xf2, 0xeb, 0x18, 0xf5, 0xbf, 0xb6, 0x00, 0x99, 0x1a, 0xa8, 0xd0, 0xfa,
|
|
0x9a, 0xf9, 0xf6, 0xc1, 0xef, 0x16, 0x05, 0xd1, 0xff, 0x49, 0x54, 0xfc, 0x7c, 0x81, 0x21, 0x23,
|
|
0xee, 0x27, 0xb2, 0x11, 0xb5, 0x65, 0x83, 0x29, 0x31, 0x44, 0x7d, 0x79, 0x5f, 0xbc, 0xb3, 0xcb,
|
|
0x68, 0xa8, 0xda, 0x43, 0xd1, 0x17, 0x0b, 0x04, 0x91, 0x1f, 0xbe, 0x17, 0x1d, 0x30, 0x11, 0x35,
|
|
0x76, 0xbc, 0x97, 0x42, 0x11, 0x3d, 0xc0, 0xbf, 0x4d, 0xc2, 0xc2, 0x7d, 0xbf, 0x3f, 0x8a, 0x4f,
|
|
0xaa, 0xd7, 0xa9, 0x2e, 0x4f, 0xf4, 0xad, 0x69, 0xdd, 0xb7, 0x22, 0xb0, 0x43, 0x46, 0x87, 0x22,
|
|
0xb2, 0x52, 0x44, 0x8c, 0x11, 0x86, 0x22, 0x73, 0x82, 0x2e, 0x65, 0xb2, 0xe5, 0x28, 0x67, 0xc4,
|
|
0x3d, 0x70, 0x02, 0x87, 0x56, 0xa0, 0xe0, 0x74, 0xbb, 0x01, 0xed, 0x3a, 0x8c, 0x36, 0x77, 0xcb,
|
|
0x59, 0xb1, 0x99, 0x89, 0xc2, 0x3f, 0x84, 0x45, 0x6d, 0x2c, 0xe5, 0xd2, 0x77, 0x21, 0xfb, 0xb1,
|
|
0xc0, 0xcc, 0x78, 0x27, 0x92, 0xa4, 0xaa, 0x8c, 0x69, 0xb2, 0xc9, 0xe7, 0x57, 0x2d, 0x33, 0xbe,
|
|
0x01, 0x19, 0x49, 0x8e, 0x4e, 0x9a, 0x4d, 0x83, 0x7c, 0xd0, 0xe0, 0xb0, 0xea, 0x00, 0x30, 0x64,
|
|
0x24, 0x23, 0xe5, 0x78, 0x11, 0x1b, 0x12, 0x43, 0xd4, 0xf7, 0xec, 0x19, 0xc8, 0x47, 0x6f, 0xa7,
|
|
0xa8, 0x00, 0xd9, 0xab, 0x77, 0xc8, 0x0f, 0x2e, 0x93, 0x8d, 0xa5, 0x04, 0x2a, 0x42, 0xae, 0x79,
|
|
0x79, 0xfd, 0xa6, 0x80, 0xac, 0xb5, 0x7f, 0xd9, 0xba, 0xb2, 0x04, 0xe8, 0x5b, 0x90, 0x96, 0xe5,
|
|
0xe2, 0x58, 0x2c, 0xbf, 0xf9, 0x02, 0x5a, 0x39, 0x7e, 0x00, 0x2f, 0x2d, 0x80, 0x13, 0xef, 0x5a,
|
|
0xe8, 0x36, 0x14, 0x04, 0x52, 0xbd, 0xb2, 0x9c, 0x9c, 0x7e, 0xec, 0x98, 0xe0, 0x74, 0xea, 0x90,
|
|
0x59, 0x83, 0xdf, 0x45, 0x48, 0x0b, 0x9f, 0x98, 0xd2, 0x98, 0xaf, 0x64, 0xa6, 0x34, 0x13, 0xef,
|
|
0x4e, 0x38, 0x81, 0x3e, 0x00, 0x9b, 0x77, 0x36, 0xc8, 0x38, 0x54, 0x8c, 0xc7, 0x91, 0xca, 0xb1,
|
|
0x69, 0xb4, 0xb1, 0xed, 0x87, 0xd1, 0x1b, 0xcf, 0xf1, 0xe9, 0x5e, 0x56, 0x2f, 0x2f, 0x1f, 0x9c,
|
|
0x88, 0x76, 0xbe, 0x23, 0x1f, 0x3b, 0x74, 0x4f, 0x85, 0x4e, 0x4d, 0x6e, 0x35, 0xd5, 0x82, 0x55,
|
|
0xaa, 0x87, 0x4d, 0x47, 0x0c, 0xb7, 0xa0, 0x60, 0xf4, 0x33, 0xa6, 0x59, 0x0f, 0x36, 0x63, 0xa6,
|
|
0x59, 0x67, 0x34, 0x41, 0x38, 0x81, 0xae, 0x41, 0x8e, 0x1f, 0xc5, 0xbc, 0x22, 0xa1, 0x13, 0xd3,
|
|
0x27, 0xae, 0x51, 0x69, 0x2b, 0x27, 0x67, 0x4f, 0x46, 0x8c, 0xbe, 0x0b, 0xf9, 0x6b, 0x94, 0xa9,
|
|
0x70, 0x3d, 0x3e, 0x1d, 0xef, 0x33, 0x2c, 0x35, 0x99, 0x33, 0x38, 0xb1, 0xf6, 0x63, 0xfd, 0x7f,
|
|
0xca, 0x86, 0xc3, 0x1c, 0x74, 0x07, 0x16, 0x85, 0x60, 0xd1, 0x1f, 0x2e, 0x13, 0x01, 0x74, 0xe0,
|
|
0xdf, 0x9d, 0x89, 0x00, 0x3a, 0xf8, 0x2f, 0x0f, 0x4e, 0x34, 0x3f, 0x7a, 0xf6, 0xbc, 0x9a, 0xf8,
|
|
0xec, 0x79, 0x35, 0xf1, 0xf9, 0xf3, 0xaa, 0xf5, 0xd3, 0xbd, 0xaa, 0xf5, 0x9b, 0xbd, 0xaa, 0xf5,
|
|
0x74, 0xaf, 0x6a, 0x3d, 0xdb, 0xab, 0x5a, 0xff, 0xd8, 0xab, 0x5a, 0xff, 0xdc, 0xab, 0x26, 0x3e,
|
|
0xdf, 0xab, 0x5a, 0x9f, 0xbe, 0xa8, 0x26, 0x9e, 0xbd, 0xa8, 0x26, 0x3e, 0x7b, 0x51, 0x4d, 0x7c,
|
|
0xf4, 0xe6, 0x17, 0x3d, 0x37, 0xe9, 0x1d, 0x77, 0x32, 0xe2, 0xf3, 0xde, 0x7f, 0x03, 0x00, 0x00,
|
|
0xff, 0xff, 0xc7, 0xff, 0x87, 0xf1, 0x0e, 0x1b, 0x00, 0x00,
|
|
}
|
|
|
|
func (x Direction) String() string {
|
|
s, ok := Direction_name[int32(x)]
|
|
if ok {
|
|
return s
|
|
}
|
|
return strconv.Itoa(int(x))
|
|
}
|
|
func (this *StreamRatesRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*StreamRatesRequest)
|
|
if !ok {
|
|
that2, ok := that.(StreamRatesRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *StreamRatesResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*StreamRatesResponse)
|
|
if !ok {
|
|
that2, ok := that.(StreamRatesResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.StreamRates) != len(that1.StreamRates) {
|
|
return false
|
|
}
|
|
for i := range this.StreamRates {
|
|
if !this.StreamRates[i].Equal(that1.StreamRates[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *StreamRate) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*StreamRate)
|
|
if !ok {
|
|
that2, ok := that.(StreamRate)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.StreamHash != that1.StreamHash {
|
|
return false
|
|
}
|
|
if this.StreamHashNoShard != that1.StreamHashNoShard {
|
|
return false
|
|
}
|
|
if this.Rate != that1.Rate {
|
|
return false
|
|
}
|
|
if this.Tenant != that1.Tenant {
|
|
return false
|
|
}
|
|
if this.Pushes != that1.Pushes {
|
|
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.Selector != that1.Selector {
|
|
return false
|
|
}
|
|
if this.Limit != that1.Limit {
|
|
return false
|
|
}
|
|
if !this.Start.Equal(that1.Start) {
|
|
return false
|
|
}
|
|
if !this.End.Equal(that1.End) {
|
|
return false
|
|
}
|
|
if this.Direction != that1.Direction {
|
|
return false
|
|
}
|
|
if len(this.Shards) != len(that1.Shards) {
|
|
return false
|
|
}
|
|
for i := range this.Shards {
|
|
if this.Shards[i] != that1.Shards[i] {
|
|
return false
|
|
}
|
|
}
|
|
if len(this.Deletes) != len(that1.Deletes) {
|
|
return false
|
|
}
|
|
for i := range this.Deletes {
|
|
if !this.Deletes[i].Equal(that1.Deletes[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *SampleQueryRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*SampleQueryRequest)
|
|
if !ok {
|
|
that2, ok := that.(SampleQueryRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Selector != that1.Selector {
|
|
return false
|
|
}
|
|
if !this.Start.Equal(that1.Start) {
|
|
return false
|
|
}
|
|
if !this.End.Equal(that1.End) {
|
|
return false
|
|
}
|
|
if len(this.Shards) != len(that1.Shards) {
|
|
return false
|
|
}
|
|
for i := range this.Shards {
|
|
if this.Shards[i] != that1.Shards[i] {
|
|
return false
|
|
}
|
|
}
|
|
if len(this.Deletes) != len(that1.Deletes) {
|
|
return false
|
|
}
|
|
for i := range this.Deletes {
|
|
if !this.Deletes[i].Equal(that1.Deletes[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *Delete) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*Delete)
|
|
if !ok {
|
|
that2, ok := that.(Delete)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Selector != that1.Selector {
|
|
return false
|
|
}
|
|
if this.Start != that1.Start {
|
|
return false
|
|
}
|
|
if this.End != that1.End {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *QueryResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*QueryResponse)
|
|
if !ok {
|
|
that2, ok := that.(QueryResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.Streams) != len(that1.Streams) {
|
|
return false
|
|
}
|
|
for i := range this.Streams {
|
|
if !this.Streams[i].Equal(that1.Streams[i]) {
|
|
return false
|
|
}
|
|
}
|
|
if !this.Stats.Equal(&that1.Stats) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *SampleQueryResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*SampleQueryResponse)
|
|
if !ok {
|
|
that2, ok := that.(SampleQueryResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.Series) != len(that1.Series) {
|
|
return false
|
|
}
|
|
for i := range this.Series {
|
|
if !this.Series[i].Equal(that1.Series[i]) {
|
|
return false
|
|
}
|
|
}
|
|
if !this.Stats.Equal(&that1.Stats) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *LabelRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*LabelRequest)
|
|
if !ok {
|
|
that2, ok := that.(LabelRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Name != that1.Name {
|
|
return false
|
|
}
|
|
if this.Values != that1.Values {
|
|
return false
|
|
}
|
|
if that1.Start == nil {
|
|
if this.Start != nil {
|
|
return false
|
|
}
|
|
} else if !this.Start.Equal(*that1.Start) {
|
|
return false
|
|
}
|
|
if that1.End == nil {
|
|
if this.End != nil {
|
|
return false
|
|
}
|
|
} else if !this.End.Equal(*that1.End) {
|
|
return false
|
|
}
|
|
if this.Query != that1.Query {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *LabelResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*LabelResponse)
|
|
if !ok {
|
|
that2, ok := that.(LabelResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.Values) != len(that1.Values) {
|
|
return false
|
|
}
|
|
for i := range this.Values {
|
|
if this.Values[i] != that1.Values[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *Sample) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*Sample)
|
|
if !ok {
|
|
that2, ok := that.(Sample)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Timestamp != that1.Timestamp {
|
|
return false
|
|
}
|
|
if this.Value != that1.Value {
|
|
return false
|
|
}
|
|
if this.Hash != that1.Hash {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *LegacySample) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*LegacySample)
|
|
if !ok {
|
|
that2, ok := that.(LegacySample)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Value != that1.Value {
|
|
return false
|
|
}
|
|
if this.TimestampMs != that1.TimestampMs {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *Series) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*Series)
|
|
if !ok {
|
|
that2, ok := that.(Series)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Labels != that1.Labels {
|
|
return false
|
|
}
|
|
if len(this.Samples) != len(that1.Samples) {
|
|
return false
|
|
}
|
|
for i := range this.Samples {
|
|
if !this.Samples[i].Equal(&that1.Samples[i]) {
|
|
return false
|
|
}
|
|
}
|
|
if this.StreamHash != that1.StreamHash {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *TailRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*TailRequest)
|
|
if !ok {
|
|
that2, ok := that.(TailRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Query != that1.Query {
|
|
return false
|
|
}
|
|
if this.DelayFor != that1.DelayFor {
|
|
return false
|
|
}
|
|
if this.Limit != that1.Limit {
|
|
return false
|
|
}
|
|
if !this.Start.Equal(that1.Start) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *TailResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*TailResponse)
|
|
if !ok {
|
|
that2, ok := that.(TailResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if that1.Stream == nil {
|
|
if this.Stream != nil {
|
|
return false
|
|
}
|
|
} else if !this.Stream.Equal(*that1.Stream) {
|
|
return false
|
|
}
|
|
if len(this.DroppedStreams) != len(that1.DroppedStreams) {
|
|
return false
|
|
}
|
|
for i := range this.DroppedStreams {
|
|
if !this.DroppedStreams[i].Equal(that1.DroppedStreams[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *SeriesRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*SeriesRequest)
|
|
if !ok {
|
|
that2, ok := that.(SeriesRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if !this.Start.Equal(that1.Start) {
|
|
return false
|
|
}
|
|
if !this.End.Equal(that1.End) {
|
|
return false
|
|
}
|
|
if len(this.Groups) != len(that1.Groups) {
|
|
return false
|
|
}
|
|
for i := range this.Groups {
|
|
if this.Groups[i] != that1.Groups[i] {
|
|
return false
|
|
}
|
|
}
|
|
if len(this.Shards) != len(that1.Shards) {
|
|
return false
|
|
}
|
|
for i := range this.Shards {
|
|
if this.Shards[i] != that1.Shards[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *SeriesResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*SeriesResponse)
|
|
if !ok {
|
|
that2, ok := that.(SeriesResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.Series) != len(that1.Series) {
|
|
return false
|
|
}
|
|
for i := range this.Series {
|
|
if !this.Series[i].Equal(&that1.Series[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *SeriesIdentifier) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*SeriesIdentifier)
|
|
if !ok {
|
|
that2, ok := that.(SeriesIdentifier)
|
|
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] != that1.Labels[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *DroppedStream) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*DroppedStream)
|
|
if !ok {
|
|
that2, ok := that.(DroppedStream)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if !this.From.Equal(that1.From) {
|
|
return false
|
|
}
|
|
if !this.To.Equal(that1.To) {
|
|
return false
|
|
}
|
|
if this.Labels != that1.Labels {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *LabelPair) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*LabelPair)
|
|
if !ok {
|
|
that2, ok := that.(LabelPair)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Name != that1.Name {
|
|
return false
|
|
}
|
|
if this.Value != that1.Value {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *LegacyLabelPair) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*LegacyLabelPair)
|
|
if !ok {
|
|
that2, ok := that.(LegacyLabelPair)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if !bytes.Equal(this.Name, that1.Name) {
|
|
return false
|
|
}
|
|
if !bytes.Equal(this.Value, that1.Value) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *Chunk) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*Chunk)
|
|
if !ok {
|
|
that2, ok := that.(Chunk)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if !bytes.Equal(this.Data, that1.Data) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *TailersCountRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*TailersCountRequest)
|
|
if !ok {
|
|
that2, ok := that.(TailersCountRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *TailersCountResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*TailersCountResponse)
|
|
if !ok {
|
|
that2, ok := that.(TailersCountResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Count != that1.Count {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *GetChunkIDsRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*GetChunkIDsRequest)
|
|
if !ok {
|
|
that2, ok := that.(GetChunkIDsRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Matchers != that1.Matchers {
|
|
return false
|
|
}
|
|
if !this.Start.Equal(that1.Start) {
|
|
return false
|
|
}
|
|
if !this.End.Equal(that1.End) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *GetChunkIDsResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*GetChunkIDsResponse)
|
|
if !ok {
|
|
that2, ok := that.(GetChunkIDsResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.ChunkIDs) != len(that1.ChunkIDs) {
|
|
return false
|
|
}
|
|
for i := range this.ChunkIDs {
|
|
if this.ChunkIDs[i] != that1.ChunkIDs[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *ChunkRef) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*ChunkRef)
|
|
if !ok {
|
|
that2, ok := that.(ChunkRef)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Fingerprint != that1.Fingerprint {
|
|
return false
|
|
}
|
|
if this.UserID != that1.UserID {
|
|
return false
|
|
}
|
|
if !this.From.Equal(that1.From) {
|
|
return false
|
|
}
|
|
if !this.Through.Equal(that1.Through) {
|
|
return false
|
|
}
|
|
if this.Checksum != that1.Checksum {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *LabelValuesForMetricNameRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*LabelValuesForMetricNameRequest)
|
|
if !ok {
|
|
that2, ok := that.(LabelValuesForMetricNameRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.MetricName != that1.MetricName {
|
|
return false
|
|
}
|
|
if this.LabelName != that1.LabelName {
|
|
return false
|
|
}
|
|
if !this.From.Equal(that1.From) {
|
|
return false
|
|
}
|
|
if !this.Through.Equal(that1.Through) {
|
|
return false
|
|
}
|
|
if this.Matchers != that1.Matchers {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *LabelNamesForMetricNameRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*LabelNamesForMetricNameRequest)
|
|
if !ok {
|
|
that2, ok := that.(LabelNamesForMetricNameRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.MetricName != that1.MetricName {
|
|
return false
|
|
}
|
|
if !this.From.Equal(that1.From) {
|
|
return false
|
|
}
|
|
if !this.Through.Equal(that1.Through) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *LineFilterExpression) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*LineFilterExpression)
|
|
if !ok {
|
|
that2, ok := that.(LineFilterExpression)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Operator != that1.Operator {
|
|
return false
|
|
}
|
|
if this.Match != that1.Match {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *GetChunkRefRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*GetChunkRefRequest)
|
|
if !ok {
|
|
that2, ok := that.(GetChunkRefRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if !this.From.Equal(that1.From) {
|
|
return false
|
|
}
|
|
if !this.Through.Equal(that1.Through) {
|
|
return false
|
|
}
|
|
if this.Matchers != that1.Matchers {
|
|
return false
|
|
}
|
|
if len(this.Filters) != len(that1.Filters) {
|
|
return false
|
|
}
|
|
for i := range this.Filters {
|
|
if !this.Filters[i].Equal(that1.Filters[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *GetChunkRefResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*GetChunkRefResponse)
|
|
if !ok {
|
|
that2, ok := that.(GetChunkRefResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.Refs) != len(that1.Refs) {
|
|
return false
|
|
}
|
|
for i := range this.Refs {
|
|
if !this.Refs[i].Equal(that1.Refs[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *GetSeriesRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*GetSeriesRequest)
|
|
if !ok {
|
|
that2, ok := that.(GetSeriesRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if !this.From.Equal(that1.From) {
|
|
return false
|
|
}
|
|
if !this.Through.Equal(that1.Through) {
|
|
return false
|
|
}
|
|
if this.Matchers != that1.Matchers {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *GetSeriesResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*GetSeriesResponse)
|
|
if !ok {
|
|
that2, ok := that.(GetSeriesResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.Series) != len(that1.Series) {
|
|
return false
|
|
}
|
|
for i := range this.Series {
|
|
if !this.Series[i].Equal(&that1.Series[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *IndexSeries) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*IndexSeries)
|
|
if !ok {
|
|
that2, ok := that.(IndexSeries)
|
|
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
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *QueryIndexResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*QueryIndexResponse)
|
|
if !ok {
|
|
that2, ok := that.(QueryIndexResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.QueryKey != that1.QueryKey {
|
|
return false
|
|
}
|
|
if len(this.Rows) != len(that1.Rows) {
|
|
return false
|
|
}
|
|
for i := range this.Rows {
|
|
if !this.Rows[i].Equal(that1.Rows[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *Row) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*Row)
|
|
if !ok {
|
|
that2, ok := that.(Row)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if !bytes.Equal(this.RangeValue, that1.RangeValue) {
|
|
return false
|
|
}
|
|
if !bytes.Equal(this.Value, that1.Value) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *QueryIndexRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*QueryIndexRequest)
|
|
if !ok {
|
|
that2, ok := that.(QueryIndexRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.Queries) != len(that1.Queries) {
|
|
return false
|
|
}
|
|
for i := range this.Queries {
|
|
if !this.Queries[i].Equal(that1.Queries[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (this *IndexQuery) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*IndexQuery)
|
|
if !ok {
|
|
that2, ok := that.(IndexQuery)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.TableName != that1.TableName {
|
|
return false
|
|
}
|
|
if this.HashValue != that1.HashValue {
|
|
return false
|
|
}
|
|
if !bytes.Equal(this.RangeValuePrefix, that1.RangeValuePrefix) {
|
|
return false
|
|
}
|
|
if !bytes.Equal(this.RangeValueStart, that1.RangeValueStart) {
|
|
return false
|
|
}
|
|
if !bytes.Equal(this.ValueEqual, that1.ValueEqual) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *IndexStatsRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*IndexStatsRequest)
|
|
if !ok {
|
|
that2, ok := that.(IndexStatsRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if !this.From.Equal(that1.From) {
|
|
return false
|
|
}
|
|
if !this.Through.Equal(that1.Through) {
|
|
return false
|
|
}
|
|
if this.Matchers != that1.Matchers {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *IndexStatsResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*IndexStatsResponse)
|
|
if !ok {
|
|
that2, ok := that.(IndexStatsResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Streams != that1.Streams {
|
|
return false
|
|
}
|
|
if this.Chunks != that1.Chunks {
|
|
return false
|
|
}
|
|
if this.Bytes != that1.Bytes {
|
|
return false
|
|
}
|
|
if this.Entries != that1.Entries {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *VolumeRequest) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*VolumeRequest)
|
|
if !ok {
|
|
that2, ok := that.(VolumeRequest)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if !this.From.Equal(that1.From) {
|
|
return false
|
|
}
|
|
if !this.Through.Equal(that1.Through) {
|
|
return false
|
|
}
|
|
if this.Matchers != that1.Matchers {
|
|
return false
|
|
}
|
|
if this.Limit != that1.Limit {
|
|
return false
|
|
}
|
|
if this.Step != that1.Step {
|
|
return false
|
|
}
|
|
if len(this.TargetLabels) != len(that1.TargetLabels) {
|
|
return false
|
|
}
|
|
for i := range this.TargetLabels {
|
|
if this.TargetLabels[i] != that1.TargetLabels[i] {
|
|
return false
|
|
}
|
|
}
|
|
if this.AggregateBy != that1.AggregateBy {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *VolumeResponse) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*VolumeResponse)
|
|
if !ok {
|
|
that2, ok := that.(VolumeResponse)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if len(this.Volumes) != len(that1.Volumes) {
|
|
return false
|
|
}
|
|
for i := range this.Volumes {
|
|
if !this.Volumes[i].Equal(&that1.Volumes[i]) {
|
|
return false
|
|
}
|
|
}
|
|
if this.Limit != that1.Limit {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *Volume) Equal(that interface{}) bool {
|
|
if that == nil {
|
|
return this == nil
|
|
}
|
|
|
|
that1, ok := that.(*Volume)
|
|
if !ok {
|
|
that2, ok := that.(Volume)
|
|
if ok {
|
|
that1 = &that2
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if that1 == nil {
|
|
return this == nil
|
|
} else if this == nil {
|
|
return false
|
|
}
|
|
if this.Name != that1.Name {
|
|
return false
|
|
}
|
|
if this.Volume != that1.Volume {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
func (this *StreamRatesRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 4)
|
|
s = append(s, "&logproto.StreamRatesRequest{")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *StreamRatesResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.StreamRatesResponse{")
|
|
if this.StreamRates != nil {
|
|
s = append(s, "StreamRates: "+fmt.Sprintf("%#v", this.StreamRates)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *StreamRate) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 9)
|
|
s = append(s, "&logproto.StreamRate{")
|
|
s = append(s, "StreamHash: "+fmt.Sprintf("%#v", this.StreamHash)+",\n")
|
|
s = append(s, "StreamHashNoShard: "+fmt.Sprintf("%#v", this.StreamHashNoShard)+",\n")
|
|
s = append(s, "Rate: "+fmt.Sprintf("%#v", this.Rate)+",\n")
|
|
s = append(s, "Tenant: "+fmt.Sprintf("%#v", this.Tenant)+",\n")
|
|
s = append(s, "Pushes: "+fmt.Sprintf("%#v", this.Pushes)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *QueryRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 11)
|
|
s = append(s, "&logproto.QueryRequest{")
|
|
s = append(s, "Selector: "+fmt.Sprintf("%#v", this.Selector)+",\n")
|
|
s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
|
|
s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
|
|
s = append(s, "End: "+fmt.Sprintf("%#v", this.End)+",\n")
|
|
s = append(s, "Direction: "+fmt.Sprintf("%#v", this.Direction)+",\n")
|
|
s = append(s, "Shards: "+fmt.Sprintf("%#v", this.Shards)+",\n")
|
|
if this.Deletes != nil {
|
|
s = append(s, "Deletes: "+fmt.Sprintf("%#v", this.Deletes)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *SampleQueryRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 9)
|
|
s = append(s, "&logproto.SampleQueryRequest{")
|
|
s = append(s, "Selector: "+fmt.Sprintf("%#v", this.Selector)+",\n")
|
|
s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
|
|
s = append(s, "End: "+fmt.Sprintf("%#v", this.End)+",\n")
|
|
s = append(s, "Shards: "+fmt.Sprintf("%#v", this.Shards)+",\n")
|
|
if this.Deletes != nil {
|
|
s = append(s, "Deletes: "+fmt.Sprintf("%#v", this.Deletes)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *Delete) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&logproto.Delete{")
|
|
s = append(s, "Selector: "+fmt.Sprintf("%#v", this.Selector)+",\n")
|
|
s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
|
|
s = append(s, "End: "+fmt.Sprintf("%#v", this.End)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *QueryResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.QueryResponse{")
|
|
s = append(s, "Streams: "+fmt.Sprintf("%#v", this.Streams)+",\n")
|
|
s = append(s, "Stats: "+strings.Replace(this.Stats.GoString(), `&`, ``, 1)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *SampleQueryResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.SampleQueryResponse{")
|
|
s = append(s, "Series: "+fmt.Sprintf("%#v", this.Series)+",\n")
|
|
s = append(s, "Stats: "+strings.Replace(this.Stats.GoString(), `&`, ``, 1)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *LabelRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 9)
|
|
s = append(s, "&logproto.LabelRequest{")
|
|
s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
|
|
s = append(s, "Values: "+fmt.Sprintf("%#v", this.Values)+",\n")
|
|
s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
|
|
s = append(s, "End: "+fmt.Sprintf("%#v", this.End)+",\n")
|
|
s = append(s, "Query: "+fmt.Sprintf("%#v", this.Query)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *LabelResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.LabelResponse{")
|
|
s = append(s, "Values: "+fmt.Sprintf("%#v", this.Values)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *Sample) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&logproto.Sample{")
|
|
s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
|
|
s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
|
|
s = append(s, "Hash: "+fmt.Sprintf("%#v", this.Hash)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *LegacySample) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.LegacySample{")
|
|
s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
|
|
s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *Series) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&logproto.Series{")
|
|
s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
|
|
if this.Samples != nil {
|
|
vs := make([]*Sample, len(this.Samples))
|
|
for i := range vs {
|
|
vs[i] = &this.Samples[i]
|
|
}
|
|
s = append(s, "Samples: "+fmt.Sprintf("%#v", vs)+",\n")
|
|
}
|
|
s = append(s, "StreamHash: "+fmt.Sprintf("%#v", this.StreamHash)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *TailRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 8)
|
|
s = append(s, "&logproto.TailRequest{")
|
|
s = append(s, "Query: "+fmt.Sprintf("%#v", this.Query)+",\n")
|
|
s = append(s, "DelayFor: "+fmt.Sprintf("%#v", this.DelayFor)+",\n")
|
|
s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
|
|
s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *TailResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.TailResponse{")
|
|
s = append(s, "Stream: "+fmt.Sprintf("%#v", this.Stream)+",\n")
|
|
if this.DroppedStreams != nil {
|
|
s = append(s, "DroppedStreams: "+fmt.Sprintf("%#v", this.DroppedStreams)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *SeriesRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 8)
|
|
s = append(s, "&logproto.SeriesRequest{")
|
|
s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
|
|
s = append(s, "End: "+fmt.Sprintf("%#v", this.End)+",\n")
|
|
s = append(s, "Groups: "+fmt.Sprintf("%#v", this.Groups)+",\n")
|
|
s = append(s, "Shards: "+fmt.Sprintf("%#v", this.Shards)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *SeriesResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.SeriesResponse{")
|
|
if this.Series != nil {
|
|
vs := make([]*SeriesIdentifier, len(this.Series))
|
|
for i := range vs {
|
|
vs[i] = &this.Series[i]
|
|
}
|
|
s = append(s, "Series: "+fmt.Sprintf("%#v", vs)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *SeriesIdentifier) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.SeriesIdentifier{")
|
|
keysForLabels := make([]string, 0, len(this.Labels))
|
|
for k, _ := range this.Labels {
|
|
keysForLabels = append(keysForLabels, k)
|
|
}
|
|
github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
|
|
mapStringForLabels := "map[string]string{"
|
|
for _, k := range keysForLabels {
|
|
mapStringForLabels += fmt.Sprintf("%#v: %#v,", k, this.Labels[k])
|
|
}
|
|
mapStringForLabels += "}"
|
|
if this.Labels != nil {
|
|
s = append(s, "Labels: "+mapStringForLabels+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *DroppedStream) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&logproto.DroppedStream{")
|
|
s = append(s, "From: "+fmt.Sprintf("%#v", this.From)+",\n")
|
|
s = append(s, "To: "+fmt.Sprintf("%#v", this.To)+",\n")
|
|
s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *LabelPair) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.LabelPair{")
|
|
s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
|
|
s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *LegacyLabelPair) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.LegacyLabelPair{")
|
|
s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
|
|
s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *Chunk) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.Chunk{")
|
|
s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *TailersCountRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 4)
|
|
s = append(s, "&logproto.TailersCountRequest{")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *TailersCountResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.TailersCountResponse{")
|
|
s = append(s, "Count: "+fmt.Sprintf("%#v", this.Count)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *GetChunkIDsRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&logproto.GetChunkIDsRequest{")
|
|
s = append(s, "Matchers: "+fmt.Sprintf("%#v", this.Matchers)+",\n")
|
|
s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
|
|
s = append(s, "End: "+fmt.Sprintf("%#v", this.End)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *GetChunkIDsResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.GetChunkIDsResponse{")
|
|
s = append(s, "ChunkIDs: "+fmt.Sprintf("%#v", this.ChunkIDs)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *ChunkRef) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 9)
|
|
s = append(s, "&logproto.ChunkRef{")
|
|
s = append(s, "Fingerprint: "+fmt.Sprintf("%#v", this.Fingerprint)+",\n")
|
|
s = append(s, "UserID: "+fmt.Sprintf("%#v", this.UserID)+",\n")
|
|
s = append(s, "From: "+fmt.Sprintf("%#v", this.From)+",\n")
|
|
s = append(s, "Through: "+fmt.Sprintf("%#v", this.Through)+",\n")
|
|
s = append(s, "Checksum: "+fmt.Sprintf("%#v", this.Checksum)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *LabelValuesForMetricNameRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 9)
|
|
s = append(s, "&logproto.LabelValuesForMetricNameRequest{")
|
|
s = append(s, "MetricName: "+fmt.Sprintf("%#v", this.MetricName)+",\n")
|
|
s = append(s, "LabelName: "+fmt.Sprintf("%#v", this.LabelName)+",\n")
|
|
s = append(s, "From: "+fmt.Sprintf("%#v", this.From)+",\n")
|
|
s = append(s, "Through: "+fmt.Sprintf("%#v", this.Through)+",\n")
|
|
s = append(s, "Matchers: "+fmt.Sprintf("%#v", this.Matchers)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *LabelNamesForMetricNameRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&logproto.LabelNamesForMetricNameRequest{")
|
|
s = append(s, "MetricName: "+fmt.Sprintf("%#v", this.MetricName)+",\n")
|
|
s = append(s, "From: "+fmt.Sprintf("%#v", this.From)+",\n")
|
|
s = append(s, "Through: "+fmt.Sprintf("%#v", this.Through)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *LineFilterExpression) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.LineFilterExpression{")
|
|
s = append(s, "Operator: "+fmt.Sprintf("%#v", this.Operator)+",\n")
|
|
s = append(s, "Match: "+fmt.Sprintf("%#v", this.Match)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *GetChunkRefRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 8)
|
|
s = append(s, "&logproto.GetChunkRefRequest{")
|
|
s = append(s, "From: "+fmt.Sprintf("%#v", this.From)+",\n")
|
|
s = append(s, "Through: "+fmt.Sprintf("%#v", this.Through)+",\n")
|
|
s = append(s, "Matchers: "+fmt.Sprintf("%#v", this.Matchers)+",\n")
|
|
if this.Filters != nil {
|
|
s = append(s, "Filters: "+fmt.Sprintf("%#v", this.Filters)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *GetChunkRefResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.GetChunkRefResponse{")
|
|
if this.Refs != nil {
|
|
s = append(s, "Refs: "+fmt.Sprintf("%#v", this.Refs)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *GetSeriesRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&logproto.GetSeriesRequest{")
|
|
s = append(s, "From: "+fmt.Sprintf("%#v", this.From)+",\n")
|
|
s = append(s, "Through: "+fmt.Sprintf("%#v", this.Through)+",\n")
|
|
s = append(s, "Matchers: "+fmt.Sprintf("%#v", this.Matchers)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *GetSeriesResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.GetSeriesResponse{")
|
|
if this.Series != nil {
|
|
vs := make([]*IndexSeries, len(this.Series))
|
|
for i := range vs {
|
|
vs[i] = &this.Series[i]
|
|
}
|
|
s = append(s, "Series: "+fmt.Sprintf("%#v", vs)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *IndexSeries) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.IndexSeries{")
|
|
s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *QueryIndexResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.QueryIndexResponse{")
|
|
s = append(s, "QueryKey: "+fmt.Sprintf("%#v", this.QueryKey)+",\n")
|
|
if this.Rows != nil {
|
|
s = append(s, "Rows: "+fmt.Sprintf("%#v", this.Rows)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *Row) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.Row{")
|
|
s = append(s, "RangeValue: "+fmt.Sprintf("%#v", this.RangeValue)+",\n")
|
|
s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *QueryIndexRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&logproto.QueryIndexRequest{")
|
|
if this.Queries != nil {
|
|
s = append(s, "Queries: "+fmt.Sprintf("%#v", this.Queries)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *IndexQuery) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 9)
|
|
s = append(s, "&logproto.IndexQuery{")
|
|
s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n")
|
|
s = append(s, "HashValue: "+fmt.Sprintf("%#v", this.HashValue)+",\n")
|
|
s = append(s, "RangeValuePrefix: "+fmt.Sprintf("%#v", this.RangeValuePrefix)+",\n")
|
|
s = append(s, "RangeValueStart: "+fmt.Sprintf("%#v", this.RangeValueStart)+",\n")
|
|
s = append(s, "ValueEqual: "+fmt.Sprintf("%#v", this.ValueEqual)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *IndexStatsRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&logproto.IndexStatsRequest{")
|
|
s = append(s, "From: "+fmt.Sprintf("%#v", this.From)+",\n")
|
|
s = append(s, "Through: "+fmt.Sprintf("%#v", this.Through)+",\n")
|
|
s = append(s, "Matchers: "+fmt.Sprintf("%#v", this.Matchers)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *IndexStatsResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 8)
|
|
s = append(s, "&logproto.IndexStatsResponse{")
|
|
s = append(s, "Streams: "+fmt.Sprintf("%#v", this.Streams)+",\n")
|
|
s = append(s, "Chunks: "+fmt.Sprintf("%#v", this.Chunks)+",\n")
|
|
s = append(s, "Bytes: "+fmt.Sprintf("%#v", this.Bytes)+",\n")
|
|
s = append(s, "Entries: "+fmt.Sprintf("%#v", this.Entries)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *VolumeRequest) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 11)
|
|
s = append(s, "&logproto.VolumeRequest{")
|
|
s = append(s, "From: "+fmt.Sprintf("%#v", this.From)+",\n")
|
|
s = append(s, "Through: "+fmt.Sprintf("%#v", this.Through)+",\n")
|
|
s = append(s, "Matchers: "+fmt.Sprintf("%#v", this.Matchers)+",\n")
|
|
s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
|
|
s = append(s, "Step: "+fmt.Sprintf("%#v", this.Step)+",\n")
|
|
s = append(s, "TargetLabels: "+fmt.Sprintf("%#v", this.TargetLabels)+",\n")
|
|
s = append(s, "AggregateBy: "+fmt.Sprintf("%#v", this.AggregateBy)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *VolumeResponse) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.VolumeResponse{")
|
|
if this.Volumes != nil {
|
|
vs := make([]*Volume, len(this.Volumes))
|
|
for i := range vs {
|
|
vs[i] = &this.Volumes[i]
|
|
}
|
|
s = append(s, "Volumes: "+fmt.Sprintf("%#v", vs)+",\n")
|
|
}
|
|
s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *Volume) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&logproto.Volume{")
|
|
s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
|
|
s = append(s, "Volume: "+fmt.Sprintf("%#v", this.Volume)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func valueToGoStringLogproto(v interface{}, typ string) string {
|
|
rv := reflect.ValueOf(v)
|
|
if rv.IsNil() {
|
|
return "nil"
|
|
}
|
|
pv := reflect.Indirect(rv).Interface()
|
|
return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
|
|
}
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ context.Context
|
|
var _ grpc.ClientConn
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the grpc package it is being compiled against.
|
|
const _ = grpc.SupportPackageIsVersion4
|
|
|
|
// QuerierClient is the client API for Querier service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
|
type QuerierClient interface {
|
|
Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (Querier_QueryClient, error)
|
|
QuerySample(ctx context.Context, in *SampleQueryRequest, opts ...grpc.CallOption) (Querier_QuerySampleClient, error)
|
|
Label(ctx context.Context, in *LabelRequest, opts ...grpc.CallOption) (*LabelResponse, error)
|
|
Tail(ctx context.Context, in *TailRequest, opts ...grpc.CallOption) (Querier_TailClient, error)
|
|
Series(ctx context.Context, in *SeriesRequest, opts ...grpc.CallOption) (*SeriesResponse, error)
|
|
TailersCount(ctx context.Context, in *TailersCountRequest, opts ...grpc.CallOption) (*TailersCountResponse, error)
|
|
GetChunkIDs(ctx context.Context, in *GetChunkIDsRequest, opts ...grpc.CallOption) (*GetChunkIDsResponse, error)
|
|
// Note: this MUST be the same as the variant defined in
|
|
// indexgateway.proto on the IndexGateway service.
|
|
GetStats(ctx context.Context, in *IndexStatsRequest, opts ...grpc.CallOption) (*IndexStatsResponse, error)
|
|
// Note: this MUST be the same as the variant defined in
|
|
// indexgateway.proto on the IndexGateway service.
|
|
GetVolume(ctx context.Context, in *VolumeRequest, opts ...grpc.CallOption) (*VolumeResponse, error)
|
|
}
|
|
|
|
type querierClient struct {
|
|
cc *grpc.ClientConn
|
|
}
|
|
|
|
func NewQuerierClient(cc *grpc.ClientConn) QuerierClient {
|
|
return &querierClient{cc}
|
|
}
|
|
|
|
func (c *querierClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (Querier_QueryClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &_Querier_serviceDesc.Streams[0], "/logproto.Querier/Query", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &querierQueryClient{stream}
|
|
if err := x.ClientStream.SendMsg(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := x.ClientStream.CloseSend(); err != nil {
|
|
return nil, err
|
|
}
|
|
return x, nil
|
|
}
|
|
|
|
type Querier_QueryClient interface {
|
|
Recv() (*QueryResponse, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type querierQueryClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *querierQueryClient) Recv() (*QueryResponse, error) {
|
|
m := new(QueryResponse)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (c *querierClient) QuerySample(ctx context.Context, in *SampleQueryRequest, opts ...grpc.CallOption) (Querier_QuerySampleClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &_Querier_serviceDesc.Streams[1], "/logproto.Querier/QuerySample", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &querierQuerySampleClient{stream}
|
|
if err := x.ClientStream.SendMsg(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := x.ClientStream.CloseSend(); err != nil {
|
|
return nil, err
|
|
}
|
|
return x, nil
|
|
}
|
|
|
|
type Querier_QuerySampleClient interface {
|
|
Recv() (*SampleQueryResponse, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type querierQuerySampleClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *querierQuerySampleClient) Recv() (*SampleQueryResponse, error) {
|
|
m := new(SampleQueryResponse)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (c *querierClient) Label(ctx context.Context, in *LabelRequest, opts ...grpc.CallOption) (*LabelResponse, error) {
|
|
out := new(LabelResponse)
|
|
err := c.cc.Invoke(ctx, "/logproto.Querier/Label", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *querierClient) Tail(ctx context.Context, in *TailRequest, opts ...grpc.CallOption) (Querier_TailClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &_Querier_serviceDesc.Streams[2], "/logproto.Querier/Tail", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &querierTailClient{stream}
|
|
if err := x.ClientStream.SendMsg(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := x.ClientStream.CloseSend(); err != nil {
|
|
return nil, err
|
|
}
|
|
return x, nil
|
|
}
|
|
|
|
type Querier_TailClient interface {
|
|
Recv() (*TailResponse, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type querierTailClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *querierTailClient) Recv() (*TailResponse, error) {
|
|
m := new(TailResponse)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (c *querierClient) Series(ctx context.Context, in *SeriesRequest, opts ...grpc.CallOption) (*SeriesResponse, error) {
|
|
out := new(SeriesResponse)
|
|
err := c.cc.Invoke(ctx, "/logproto.Querier/Series", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *querierClient) TailersCount(ctx context.Context, in *TailersCountRequest, opts ...grpc.CallOption) (*TailersCountResponse, error) {
|
|
out := new(TailersCountResponse)
|
|
err := c.cc.Invoke(ctx, "/logproto.Querier/TailersCount", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *querierClient) GetChunkIDs(ctx context.Context, in *GetChunkIDsRequest, opts ...grpc.CallOption) (*GetChunkIDsResponse, error) {
|
|
out := new(GetChunkIDsResponse)
|
|
err := c.cc.Invoke(ctx, "/logproto.Querier/GetChunkIDs", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *querierClient) GetStats(ctx context.Context, in *IndexStatsRequest, opts ...grpc.CallOption) (*IndexStatsResponse, error) {
|
|
out := new(IndexStatsResponse)
|
|
err := c.cc.Invoke(ctx, "/logproto.Querier/GetStats", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *querierClient) GetVolume(ctx context.Context, in *VolumeRequest, opts ...grpc.CallOption) (*VolumeResponse, error) {
|
|
out := new(VolumeResponse)
|
|
err := c.cc.Invoke(ctx, "/logproto.Querier/GetVolume", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// QuerierServer is the server API for Querier service.
|
|
type QuerierServer interface {
|
|
Query(*QueryRequest, Querier_QueryServer) error
|
|
QuerySample(*SampleQueryRequest, Querier_QuerySampleServer) error
|
|
Label(context.Context, *LabelRequest) (*LabelResponse, error)
|
|
Tail(*TailRequest, Querier_TailServer) error
|
|
Series(context.Context, *SeriesRequest) (*SeriesResponse, error)
|
|
TailersCount(context.Context, *TailersCountRequest) (*TailersCountResponse, error)
|
|
GetChunkIDs(context.Context, *GetChunkIDsRequest) (*GetChunkIDsResponse, error)
|
|
// Note: this MUST be the same as the variant defined in
|
|
// indexgateway.proto on the IndexGateway service.
|
|
GetStats(context.Context, *IndexStatsRequest) (*IndexStatsResponse, error)
|
|
// Note: this MUST be the same as the variant defined in
|
|
// indexgateway.proto on the IndexGateway service.
|
|
GetVolume(context.Context, *VolumeRequest) (*VolumeResponse, error)
|
|
}
|
|
|
|
// UnimplementedQuerierServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedQuerierServer struct {
|
|
}
|
|
|
|
func (*UnimplementedQuerierServer) Query(req *QueryRequest, srv Querier_QueryServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method Query not implemented")
|
|
}
|
|
func (*UnimplementedQuerierServer) QuerySample(req *SampleQueryRequest, srv Querier_QuerySampleServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method QuerySample not implemented")
|
|
}
|
|
func (*UnimplementedQuerierServer) Label(ctx context.Context, req *LabelRequest) (*LabelResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Label not implemented")
|
|
}
|
|
func (*UnimplementedQuerierServer) Tail(req *TailRequest, srv Querier_TailServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method Tail not implemented")
|
|
}
|
|
func (*UnimplementedQuerierServer) Series(ctx context.Context, req *SeriesRequest) (*SeriesResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Series not implemented")
|
|
}
|
|
func (*UnimplementedQuerierServer) TailersCount(ctx context.Context, req *TailersCountRequest) (*TailersCountResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method TailersCount not implemented")
|
|
}
|
|
func (*UnimplementedQuerierServer) GetChunkIDs(ctx context.Context, req *GetChunkIDsRequest) (*GetChunkIDsResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method GetChunkIDs not implemented")
|
|
}
|
|
func (*UnimplementedQuerierServer) GetStats(ctx context.Context, req *IndexStatsRequest) (*IndexStatsResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method GetStats not implemented")
|
|
}
|
|
func (*UnimplementedQuerierServer) GetVolume(ctx context.Context, req *VolumeRequest) (*VolumeResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method GetVolume not implemented")
|
|
}
|
|
|
|
func RegisterQuerierServer(s *grpc.Server, srv QuerierServer) {
|
|
s.RegisterService(&_Querier_serviceDesc, srv)
|
|
}
|
|
|
|
func _Querier_Query_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
m := new(QueryRequest)
|
|
if err := stream.RecvMsg(m); err != nil {
|
|
return err
|
|
}
|
|
return srv.(QuerierServer).Query(m, &querierQueryServer{stream})
|
|
}
|
|
|
|
type Querier_QueryServer interface {
|
|
Send(*QueryResponse) error
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type querierQueryServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *querierQueryServer) Send(m *QueryResponse) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func _Querier_QuerySample_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
m := new(SampleQueryRequest)
|
|
if err := stream.RecvMsg(m); err != nil {
|
|
return err
|
|
}
|
|
return srv.(QuerierServer).QuerySample(m, &querierQuerySampleServer{stream})
|
|
}
|
|
|
|
type Querier_QuerySampleServer interface {
|
|
Send(*SampleQueryResponse) error
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type querierQuerySampleServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *querierQuerySampleServer) Send(m *SampleQueryResponse) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func _Querier_Label_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(LabelRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(QuerierServer).Label(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/logproto.Querier/Label",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(QuerierServer).Label(ctx, req.(*LabelRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Querier_Tail_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
m := new(TailRequest)
|
|
if err := stream.RecvMsg(m); err != nil {
|
|
return err
|
|
}
|
|
return srv.(QuerierServer).Tail(m, &querierTailServer{stream})
|
|
}
|
|
|
|
type Querier_TailServer interface {
|
|
Send(*TailResponse) error
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type querierTailServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *querierTailServer) Send(m *TailResponse) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func _Querier_Series_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SeriesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(QuerierServer).Series(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/logproto.Querier/Series",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(QuerierServer).Series(ctx, req.(*SeriesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Querier_TailersCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(TailersCountRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(QuerierServer).TailersCount(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/logproto.Querier/TailersCount",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(QuerierServer).TailersCount(ctx, req.(*TailersCountRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Querier_GetChunkIDs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetChunkIDsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(QuerierServer).GetChunkIDs(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/logproto.Querier/GetChunkIDs",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(QuerierServer).GetChunkIDs(ctx, req.(*GetChunkIDsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Querier_GetStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(IndexStatsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(QuerierServer).GetStats(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/logproto.Querier/GetStats",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(QuerierServer).GetStats(ctx, req.(*IndexStatsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Querier_GetVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(VolumeRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(QuerierServer).GetVolume(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/logproto.Querier/GetVolume",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(QuerierServer).GetVolume(ctx, req.(*VolumeRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
var _Querier_serviceDesc = grpc.ServiceDesc{
|
|
ServiceName: "logproto.Querier",
|
|
HandlerType: (*QuerierServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "Label",
|
|
Handler: _Querier_Label_Handler,
|
|
},
|
|
{
|
|
MethodName: "Series",
|
|
Handler: _Querier_Series_Handler,
|
|
},
|
|
{
|
|
MethodName: "TailersCount",
|
|
Handler: _Querier_TailersCount_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetChunkIDs",
|
|
Handler: _Querier_GetChunkIDs_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetStats",
|
|
Handler: _Querier_GetStats_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetVolume",
|
|
Handler: _Querier_GetVolume_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{
|
|
{
|
|
StreamName: "Query",
|
|
Handler: _Querier_Query_Handler,
|
|
ServerStreams: true,
|
|
},
|
|
{
|
|
StreamName: "QuerySample",
|
|
Handler: _Querier_QuerySample_Handler,
|
|
ServerStreams: true,
|
|
},
|
|
{
|
|
StreamName: "Tail",
|
|
Handler: _Querier_Tail_Handler,
|
|
ServerStreams: true,
|
|
},
|
|
},
|
|
Metadata: "pkg/logproto/logproto.proto",
|
|
}
|
|
|
|
// StreamDataClient is the client API for StreamData service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
|
type StreamDataClient interface {
|
|
GetStreamRates(ctx context.Context, in *StreamRatesRequest, opts ...grpc.CallOption) (*StreamRatesResponse, error)
|
|
}
|
|
|
|
type streamDataClient struct {
|
|
cc *grpc.ClientConn
|
|
}
|
|
|
|
func NewStreamDataClient(cc *grpc.ClientConn) StreamDataClient {
|
|
return &streamDataClient{cc}
|
|
}
|
|
|
|
func (c *streamDataClient) GetStreamRates(ctx context.Context, in *StreamRatesRequest, opts ...grpc.CallOption) (*StreamRatesResponse, error) {
|
|
out := new(StreamRatesResponse)
|
|
err := c.cc.Invoke(ctx, "/logproto.StreamData/GetStreamRates", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// StreamDataServer is the server API for StreamData service.
|
|
type StreamDataServer interface {
|
|
GetStreamRates(context.Context, *StreamRatesRequest) (*StreamRatesResponse, error)
|
|
}
|
|
|
|
// UnimplementedStreamDataServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedStreamDataServer struct {
|
|
}
|
|
|
|
func (*UnimplementedStreamDataServer) GetStreamRates(ctx context.Context, req *StreamRatesRequest) (*StreamRatesResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method GetStreamRates not implemented")
|
|
}
|
|
|
|
func RegisterStreamDataServer(s *grpc.Server, srv StreamDataServer) {
|
|
s.RegisterService(&_StreamData_serviceDesc, srv)
|
|
}
|
|
|
|
func _StreamData_GetStreamRates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(StreamRatesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(StreamDataServer).GetStreamRates(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/logproto.StreamData/GetStreamRates",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(StreamDataServer).GetStreamRates(ctx, req.(*StreamRatesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
var _StreamData_serviceDesc = grpc.ServiceDesc{
|
|
ServiceName: "logproto.StreamData",
|
|
HandlerType: (*StreamDataServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "GetStreamRates",
|
|
Handler: _StreamData_GetStreamRates_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "pkg/logproto/logproto.proto",
|
|
}
|
|
|
|
func (m *StreamRatesRequest) 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 *StreamRatesRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *StreamRatesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *StreamRatesResponse) 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 *StreamRatesResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *StreamRatesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.StreamRates) > 0 {
|
|
for iNdEx := len(m.StreamRates) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.StreamRates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *StreamRate) 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 *StreamRate) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *StreamRate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Pushes != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Pushes))
|
|
i--
|
|
dAtA[i] = 0x28
|
|
}
|
|
if len(m.Tenant) > 0 {
|
|
i -= len(m.Tenant)
|
|
copy(dAtA[i:], m.Tenant)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Tenant)))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
if m.Rate != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Rate))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if m.StreamHashNoShard != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.StreamHashNoShard))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.StreamHash != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.StreamHash))
|
|
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 len(m.Deletes) > 0 {
|
|
for iNdEx := len(m.Deletes) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Deletes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x42
|
|
}
|
|
}
|
|
if len(m.Shards) > 0 {
|
|
for iNdEx := len(m.Shards) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.Shards[iNdEx])
|
|
copy(dAtA[i:], m.Shards[iNdEx])
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Shards[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x3a
|
|
}
|
|
}
|
|
if m.Direction != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Direction))
|
|
i--
|
|
dAtA[i] = 0x28
|
|
}
|
|
n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.End):])
|
|
if err1 != nil {
|
|
return 0, err1
|
|
}
|
|
i -= n1
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n1))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Start):])
|
|
if err2 != nil {
|
|
return 0, err2
|
|
}
|
|
i -= n2
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n2))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
if m.Limit != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Limit))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.Selector) > 0 {
|
|
i -= len(m.Selector)
|
|
copy(dAtA[i:], m.Selector)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Selector)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *SampleQueryRequest) 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 *SampleQueryRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *SampleQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Deletes) > 0 {
|
|
for iNdEx := len(m.Deletes) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Deletes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
}
|
|
if len(m.Shards) > 0 {
|
|
for iNdEx := len(m.Shards) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.Shards[iNdEx])
|
|
copy(dAtA[i:], m.Shards[iNdEx])
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Shards[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
}
|
|
n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.End):])
|
|
if err3 != nil {
|
|
return 0, err3
|
|
}
|
|
i -= n3
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n3))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Start):])
|
|
if err4 != nil {
|
|
return 0, err4
|
|
}
|
|
i -= n4
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n4))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
if len(m.Selector) > 0 {
|
|
i -= len(m.Selector)
|
|
copy(dAtA[i:], m.Selector)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Selector)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Delete) 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 *Delete) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Delete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.End != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.End))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if m.Start != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Start))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.Selector) > 0 {
|
|
i -= len(m.Selector)
|
|
copy(dAtA[i:], m.Selector)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Selector)))
|
|
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) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
{
|
|
size, err := m.Stats.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
if len(m.Streams) > 0 {
|
|
for iNdEx := len(m.Streams) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size := m.Streams[iNdEx].Size()
|
|
i -= size
|
|
if _, err := m.Streams[iNdEx].MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *SampleQueryResponse) 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 *SampleQueryResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *SampleQueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
{
|
|
size, err := m.Stats.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
if len(m.Series) > 0 {
|
|
for iNdEx := len(m.Series) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size := m.Series[iNdEx].Size()
|
|
i -= size
|
|
if _, err := m.Series[iNdEx].MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *LabelRequest) 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 *LabelRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *LabelRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Query) > 0 {
|
|
i -= len(m.Query)
|
|
copy(dAtA[i:], m.Query)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Query)))
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
if m.End != nil {
|
|
n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.End):])
|
|
if err7 != nil {
|
|
return 0, err7
|
|
}
|
|
i -= n7
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n7))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
if m.Start != nil {
|
|
n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Start):])
|
|
if err8 != nil {
|
|
return 0, err8
|
|
}
|
|
i -= n8
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n8))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Values {
|
|
i--
|
|
if m.Values {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.Name) > 0 {
|
|
i -= len(m.Name)
|
|
copy(dAtA[i:], m.Name)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Name)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *LabelResponse) 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 *LabelResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *LabelResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Values) > 0 {
|
|
for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.Values[iNdEx])
|
|
copy(dAtA[i:], m.Values[iNdEx])
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Values[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Sample) 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 *Sample) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Sample) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Hash != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Hash))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if m.Value != 0 {
|
|
i -= 8
|
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
|
|
i--
|
|
dAtA[i] = 0x11
|
|
}
|
|
if m.Timestamp != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Timestamp))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *LegacySample) 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 *LegacySample) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *LegacySample) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.TimestampMs != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.TimestampMs))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.Value != 0 {
|
|
i -= 8
|
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
|
|
i--
|
|
dAtA[i] = 0x9
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Series) 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 *Series) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Series) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.StreamHash != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.StreamHash))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if len(m.Samples) > 0 {
|
|
for iNdEx := len(m.Samples) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Samples[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
}
|
|
if len(m.Labels) > 0 {
|
|
i -= len(m.Labels)
|
|
copy(dAtA[i:], m.Labels)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Labels)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *TailRequest) 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 *TailRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *TailRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Start):])
|
|
if err9 != nil {
|
|
return 0, err9
|
|
}
|
|
i -= n9
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n9))
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
if m.Limit != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Limit))
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if m.DelayFor != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.DelayFor))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if len(m.Query) > 0 {
|
|
i -= len(m.Query)
|
|
copy(dAtA[i:], m.Query)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Query)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *TailResponse) 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 *TailResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *TailResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.DroppedStreams) > 0 {
|
|
for iNdEx := len(m.DroppedStreams) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.DroppedStreams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
}
|
|
if m.Stream != nil {
|
|
{
|
|
size := m.Stream.Size()
|
|
i -= size
|
|
if _, err := m.Stream.MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *SeriesRequest) 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 *SeriesRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *SeriesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Shards) > 0 {
|
|
for iNdEx := len(m.Shards) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.Shards[iNdEx])
|
|
copy(dAtA[i:], m.Shards[iNdEx])
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Shards[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
}
|
|
if len(m.Groups) > 0 {
|
|
for iNdEx := len(m.Groups) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.Groups[iNdEx])
|
|
copy(dAtA[i:], m.Groups[iNdEx])
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Groups[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
}
|
|
n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.End):])
|
|
if err11 != nil {
|
|
return 0, err11
|
|
}
|
|
i -= n11
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n11))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Start):])
|
|
if err12 != nil {
|
|
return 0, err12
|
|
}
|
|
i -= n12
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n12))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *SeriesResponse) 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 *SeriesResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *SeriesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Series) > 0 {
|
|
for iNdEx := len(m.Series) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Series[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *SeriesIdentifier) 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 *SeriesIdentifier) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *SeriesIdentifier) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Labels) > 0 {
|
|
for k := range m.Labels {
|
|
v := m.Labels[k]
|
|
baseI := i
|
|
i -= len(v)
|
|
copy(dAtA[i:], v)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(v)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
i -= len(k)
|
|
copy(dAtA[i:], k)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(k)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
i = encodeVarintLogproto(dAtA, i, uint64(baseI-i))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *DroppedStream) 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 *DroppedStream) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *DroppedStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Labels) > 0 {
|
|
i -= len(m.Labels)
|
|
copy(dAtA[i:], m.Labels)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Labels)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
n13, err13 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.To, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.To):])
|
|
if err13 != nil {
|
|
return 0, err13
|
|
}
|
|
i -= n13
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n13))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
n14, err14 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.From, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.From):])
|
|
if err14 != nil {
|
|
return 0, err14
|
|
}
|
|
i -= n14
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n14))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *LabelPair) 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 *LabelPair) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *LabelPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Value) > 0 {
|
|
i -= len(m.Value)
|
|
copy(dAtA[i:], m.Value)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Value)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Name) > 0 {
|
|
i -= len(m.Name)
|
|
copy(dAtA[i:], m.Name)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Name)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *LegacyLabelPair) 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 *LegacyLabelPair) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *LegacyLabelPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Value) > 0 {
|
|
i -= len(m.Value)
|
|
copy(dAtA[i:], m.Value)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Value)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Name) > 0 {
|
|
i -= len(m.Name)
|
|
copy(dAtA[i:], m.Name)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Name)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Chunk) 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 *Chunk) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Chunk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Data) > 0 {
|
|
i -= len(m.Data)
|
|
copy(dAtA[i:], m.Data)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Data)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *TailersCountRequest) 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 *TailersCountRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *TailersCountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *TailersCountResponse) 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 *TailersCountResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *TailersCountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Count != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Count))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetChunkIDsRequest) 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 *GetChunkIDsRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetChunkIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
n15, err15 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.End):])
|
|
if err15 != nil {
|
|
return 0, err15
|
|
}
|
|
i -= n15
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n15))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
n16, err16 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Start):])
|
|
if err16 != nil {
|
|
return 0, err16
|
|
}
|
|
i -= n16
|
|
i = encodeVarintLogproto(dAtA, i, uint64(n16))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
if len(m.Matchers) > 0 {
|
|
i -= len(m.Matchers)
|
|
copy(dAtA[i:], m.Matchers)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Matchers)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetChunkIDsResponse) 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 *GetChunkIDsResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetChunkIDsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.ChunkIDs) > 0 {
|
|
for iNdEx := len(m.ChunkIDs) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.ChunkIDs[iNdEx])
|
|
copy(dAtA[i:], m.ChunkIDs[iNdEx])
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.ChunkIDs[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ChunkRef) 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 *ChunkRef) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ChunkRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Checksum != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Checksum))
|
|
i--
|
|
dAtA[i] = 0x28
|
|
}
|
|
if m.Through != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Through))
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if m.From != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.From))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if len(m.UserID) > 0 {
|
|
i -= len(m.UserID)
|
|
copy(dAtA[i:], m.UserID)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.UserID)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Fingerprint != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Fingerprint))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *LabelValuesForMetricNameRequest) 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 *LabelValuesForMetricNameRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *LabelValuesForMetricNameRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Matchers) > 0 {
|
|
i -= len(m.Matchers)
|
|
copy(dAtA[i:], m.Matchers)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Matchers)))
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
if m.Through != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Through))
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if m.From != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.From))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if len(m.LabelName) > 0 {
|
|
i -= len(m.LabelName)
|
|
copy(dAtA[i:], m.LabelName)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.LabelName)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.MetricName) > 0 {
|
|
i -= len(m.MetricName)
|
|
copy(dAtA[i:], m.MetricName)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.MetricName)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *LabelNamesForMetricNameRequest) 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 *LabelNamesForMetricNameRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *LabelNamesForMetricNameRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Through != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Through))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if m.From != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.From))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.MetricName) > 0 {
|
|
i -= len(m.MetricName)
|
|
copy(dAtA[i:], m.MetricName)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.MetricName)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *LineFilterExpression) 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 *LineFilterExpression) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *LineFilterExpression) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Match) > 0 {
|
|
i -= len(m.Match)
|
|
copy(dAtA[i:], m.Match)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Match)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Operator != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Operator))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetChunkRefRequest) 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 *GetChunkRefRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetChunkRefRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Filters) > 0 {
|
|
for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Filters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
}
|
|
if len(m.Matchers) > 0 {
|
|
i -= len(m.Matchers)
|
|
copy(dAtA[i:], m.Matchers)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Matchers)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Through != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Through))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.From != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.From))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetChunkRefResponse) 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 *GetChunkRefResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetChunkRefResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Refs) > 0 {
|
|
for iNdEx := len(m.Refs) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Refs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetSeriesRequest) 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 *GetSeriesRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetSeriesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Matchers) > 0 {
|
|
i -= len(m.Matchers)
|
|
copy(dAtA[i:], m.Matchers)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Matchers)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Through != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Through))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.From != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.From))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetSeriesResponse) 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 *GetSeriesResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetSeriesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Series) > 0 {
|
|
for iNdEx := len(m.Series) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Series[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *IndexSeries) 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 *IndexSeries) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *IndexSeries) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
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 = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *QueryIndexResponse) 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 *QueryIndexResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *QueryIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Rows) > 0 {
|
|
for iNdEx := len(m.Rows) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Rows[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
}
|
|
if len(m.QueryKey) > 0 {
|
|
i -= len(m.QueryKey)
|
|
copy(dAtA[i:], m.QueryKey)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.QueryKey)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Row) 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 *Row) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Row) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Value) > 0 {
|
|
i -= len(m.Value)
|
|
copy(dAtA[i:], m.Value)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Value)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.RangeValue) > 0 {
|
|
i -= len(m.RangeValue)
|
|
copy(dAtA[i:], m.RangeValue)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.RangeValue)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *QueryIndexRequest) 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 *QueryIndexRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *QueryIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Queries) > 0 {
|
|
for iNdEx := len(m.Queries) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Queries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *IndexQuery) 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 *IndexQuery) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *IndexQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.ValueEqual) > 0 {
|
|
i -= len(m.ValueEqual)
|
|
copy(dAtA[i:], m.ValueEqual)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.ValueEqual)))
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
if len(m.RangeValueStart) > 0 {
|
|
i -= len(m.RangeValueStart)
|
|
copy(dAtA[i:], m.RangeValueStart)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.RangeValueStart)))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
if len(m.RangeValuePrefix) > 0 {
|
|
i -= len(m.RangeValuePrefix)
|
|
copy(dAtA[i:], m.RangeValuePrefix)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.RangeValuePrefix)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if len(m.HashValue) > 0 {
|
|
i -= len(m.HashValue)
|
|
copy(dAtA[i:], m.HashValue)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.HashValue)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.TableName) > 0 {
|
|
i -= len(m.TableName)
|
|
copy(dAtA[i:], m.TableName)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.TableName)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *IndexStatsRequest) 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 *IndexStatsRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *IndexStatsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Matchers) > 0 {
|
|
i -= len(m.Matchers)
|
|
copy(dAtA[i:], m.Matchers)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Matchers)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Through != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Through))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.From != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.From))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *IndexStatsResponse) 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 *IndexStatsResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *IndexStatsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Entries != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Entries))
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if m.Bytes != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Bytes))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if m.Chunks != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Chunks))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.Streams != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Streams))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *VolumeRequest) 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 *VolumeRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *VolumeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.AggregateBy) > 0 {
|
|
i -= len(m.AggregateBy)
|
|
copy(dAtA[i:], m.AggregateBy)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.AggregateBy)))
|
|
i--
|
|
dAtA[i] = 0x3a
|
|
}
|
|
if len(m.TargetLabels) > 0 {
|
|
for iNdEx := len(m.TargetLabels) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.TargetLabels[iNdEx])
|
|
copy(dAtA[i:], m.TargetLabels[iNdEx])
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.TargetLabels[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x32
|
|
}
|
|
}
|
|
if m.Step != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Step))
|
|
i--
|
|
dAtA[i] = 0x28
|
|
}
|
|
if m.Limit != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Limit))
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if len(m.Matchers) > 0 {
|
|
i -= len(m.Matchers)
|
|
copy(dAtA[i:], m.Matchers)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Matchers)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Through != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Through))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.From != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.From))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *VolumeResponse) 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 *VolumeResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *VolumeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Limit != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Limit))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.Volumes) > 0 {
|
|
for iNdEx := len(m.Volumes) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Volumes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintLogproto(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Volume) 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 *Volume) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Volume) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Volume != 0 {
|
|
i = encodeVarintLogproto(dAtA, i, uint64(m.Volume))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if len(m.Name) > 0 {
|
|
i -= len(m.Name)
|
|
copy(dAtA[i:], m.Name)
|
|
i = encodeVarintLogproto(dAtA, i, uint64(len(m.Name)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func encodeVarintLogproto(dAtA []byte, offset int, v uint64) int {
|
|
offset -= sovLogproto(v)
|
|
base := offset
|
|
for v >= 1<<7 {
|
|
dAtA[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
dAtA[offset] = uint8(v)
|
|
return base
|
|
}
|
|
func (m *StreamRatesRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
return n
|
|
}
|
|
|
|
func (m *StreamRatesResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.StreamRates) > 0 {
|
|
for _, e := range m.StreamRates {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *StreamRate) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.StreamHash != 0 {
|
|
n += 1 + sovLogproto(uint64(m.StreamHash))
|
|
}
|
|
if m.StreamHashNoShard != 0 {
|
|
n += 1 + sovLogproto(uint64(m.StreamHashNoShard))
|
|
}
|
|
if m.Rate != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Rate))
|
|
}
|
|
l = len(m.Tenant)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.Pushes != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Pushes))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *QueryRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Selector)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.Limit != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Limit))
|
|
}
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Start)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.End)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
if m.Direction != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Direction))
|
|
}
|
|
if len(m.Shards) > 0 {
|
|
for _, s := range m.Shards {
|
|
l = len(s)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
if len(m.Deletes) > 0 {
|
|
for _, e := range m.Deletes {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *SampleQueryRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Selector)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Start)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.End)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
if len(m.Shards) > 0 {
|
|
for _, s := range m.Shards {
|
|
l = len(s)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
if len(m.Deletes) > 0 {
|
|
for _, e := range m.Deletes {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Delete) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Selector)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.Start != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Start))
|
|
}
|
|
if m.End != 0 {
|
|
n += 1 + sovLogproto(uint64(m.End))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *QueryResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Streams) > 0 {
|
|
for _, e := range m.Streams {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
l = m.Stats.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
return n
|
|
}
|
|
|
|
func (m *SampleQueryResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Series) > 0 {
|
|
for _, e := range m.Series {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
l = m.Stats.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
return n
|
|
}
|
|
|
|
func (m *LabelRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Name)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.Values {
|
|
n += 2
|
|
}
|
|
if m.Start != nil {
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Start)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.End != nil {
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.End)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = len(m.Query)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *LabelResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Values) > 0 {
|
|
for _, s := range m.Values {
|
|
l = len(s)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Sample) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Timestamp != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Timestamp))
|
|
}
|
|
if m.Value != 0 {
|
|
n += 9
|
|
}
|
|
if m.Hash != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Hash))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *LegacySample) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Value != 0 {
|
|
n += 9
|
|
}
|
|
if m.TimestampMs != 0 {
|
|
n += 1 + sovLogproto(uint64(m.TimestampMs))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Series) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Labels)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if len(m.Samples) > 0 {
|
|
for _, e := range m.Samples {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
if m.StreamHash != 0 {
|
|
n += 1 + sovLogproto(uint64(m.StreamHash))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *TailRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Query)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.DelayFor != 0 {
|
|
n += 1 + sovLogproto(uint64(m.DelayFor))
|
|
}
|
|
if m.Limit != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Limit))
|
|
}
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Start)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
return n
|
|
}
|
|
|
|
func (m *TailResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Stream != nil {
|
|
l = m.Stream.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if len(m.DroppedStreams) > 0 {
|
|
for _, e := range m.DroppedStreams {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *SeriesRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Start)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.End)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
if len(m.Groups) > 0 {
|
|
for _, s := range m.Groups {
|
|
l = len(s)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
if len(m.Shards) > 0 {
|
|
for _, s := range m.Shards {
|
|
l = len(s)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *SeriesResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Series) > 0 {
|
|
for _, e := range m.Series {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *SeriesIdentifier) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Labels) > 0 {
|
|
for k, v := range m.Labels {
|
|
_ = k
|
|
_ = v
|
|
mapEntrySize := 1 + len(k) + sovLogproto(uint64(len(k))) + 1 + len(v) + sovLogproto(uint64(len(v)))
|
|
n += mapEntrySize + 1 + sovLogproto(uint64(mapEntrySize))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *DroppedStream) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.From)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.To)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
l = len(m.Labels)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *LabelPair) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Name)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = len(m.Value)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *LegacyLabelPair) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Name)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = len(m.Value)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Chunk) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Data)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *TailersCountRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
return n
|
|
}
|
|
|
|
func (m *TailersCountResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Count != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Count))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetChunkIDsRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Matchers)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Start)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.End)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
return n
|
|
}
|
|
|
|
func (m *GetChunkIDsResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.ChunkIDs) > 0 {
|
|
for _, s := range m.ChunkIDs {
|
|
l = len(s)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ChunkRef) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Fingerprint != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Fingerprint))
|
|
}
|
|
l = len(m.UserID)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.From != 0 {
|
|
n += 1 + sovLogproto(uint64(m.From))
|
|
}
|
|
if m.Through != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Through))
|
|
}
|
|
if m.Checksum != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Checksum))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *LabelValuesForMetricNameRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.MetricName)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = len(m.LabelName)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.From != 0 {
|
|
n += 1 + sovLogproto(uint64(m.From))
|
|
}
|
|
if m.Through != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Through))
|
|
}
|
|
l = len(m.Matchers)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *LabelNamesForMetricNameRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.MetricName)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.From != 0 {
|
|
n += 1 + sovLogproto(uint64(m.From))
|
|
}
|
|
if m.Through != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Through))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *LineFilterExpression) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Operator != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Operator))
|
|
}
|
|
l = len(m.Match)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetChunkRefRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.From != 0 {
|
|
n += 1 + sovLogproto(uint64(m.From))
|
|
}
|
|
if m.Through != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Through))
|
|
}
|
|
l = len(m.Matchers)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if len(m.Filters) > 0 {
|
|
for _, e := range m.Filters {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetChunkRefResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Refs) > 0 {
|
|
for _, e := range m.Refs {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetSeriesRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.From != 0 {
|
|
n += 1 + sovLogproto(uint64(m.From))
|
|
}
|
|
if m.Through != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Through))
|
|
}
|
|
l = len(m.Matchers)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetSeriesResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Series) > 0 {
|
|
for _, e := range m.Series {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *IndexSeries) 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 + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *QueryIndexResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.QueryKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if len(m.Rows) > 0 {
|
|
for _, e := range m.Rows {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Row) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.RangeValue)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = len(m.Value)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *QueryIndexRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Queries) > 0 {
|
|
for _, e := range m.Queries {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *IndexQuery) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.TableName)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = len(m.HashValue)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = len(m.RangeValuePrefix)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = len(m.RangeValueStart)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
l = len(m.ValueEqual)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *IndexStatsRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.From != 0 {
|
|
n += 1 + sovLogproto(uint64(m.From))
|
|
}
|
|
if m.Through != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Through))
|
|
}
|
|
l = len(m.Matchers)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *IndexStatsResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Streams != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Streams))
|
|
}
|
|
if m.Chunks != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Chunks))
|
|
}
|
|
if m.Bytes != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Bytes))
|
|
}
|
|
if m.Entries != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Entries))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *VolumeRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.From != 0 {
|
|
n += 1 + sovLogproto(uint64(m.From))
|
|
}
|
|
if m.Through != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Through))
|
|
}
|
|
l = len(m.Matchers)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.Limit != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Limit))
|
|
}
|
|
if m.Step != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Step))
|
|
}
|
|
if len(m.TargetLabels) > 0 {
|
|
for _, s := range m.TargetLabels {
|
|
l = len(s)
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
l = len(m.AggregateBy)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *VolumeResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Volumes) > 0 {
|
|
for _, e := range m.Volumes {
|
|
l = e.Size()
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
}
|
|
if m.Limit != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Limit))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Volume) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Name)
|
|
if l > 0 {
|
|
n += 1 + l + sovLogproto(uint64(l))
|
|
}
|
|
if m.Volume != 0 {
|
|
n += 1 + sovLogproto(uint64(m.Volume))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovLogproto(x uint64) (n int) {
|
|
return (math_bits.Len64(x|1) + 6) / 7
|
|
}
|
|
func sozLogproto(x uint64) (n int) {
|
|
return sovLogproto(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (this *StreamRatesRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&StreamRatesRequest{`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *StreamRatesResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForStreamRates := "[]*StreamRate{"
|
|
for _, f := range this.StreamRates {
|
|
repeatedStringForStreamRates += strings.Replace(f.String(), "StreamRate", "StreamRate", 1) + ","
|
|
}
|
|
repeatedStringForStreamRates += "}"
|
|
s := strings.Join([]string{`&StreamRatesResponse{`,
|
|
`StreamRates:` + repeatedStringForStreamRates + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *StreamRate) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&StreamRate{`,
|
|
`StreamHash:` + fmt.Sprintf("%v", this.StreamHash) + `,`,
|
|
`StreamHashNoShard:` + fmt.Sprintf("%v", this.StreamHashNoShard) + `,`,
|
|
`Rate:` + fmt.Sprintf("%v", this.Rate) + `,`,
|
|
`Tenant:` + fmt.Sprintf("%v", this.Tenant) + `,`,
|
|
`Pushes:` + fmt.Sprintf("%v", this.Pushes) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *QueryRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForDeletes := "[]*Delete{"
|
|
for _, f := range this.Deletes {
|
|
repeatedStringForDeletes += strings.Replace(f.String(), "Delete", "Delete", 1) + ","
|
|
}
|
|
repeatedStringForDeletes += "}"
|
|
s := strings.Join([]string{`&QueryRequest{`,
|
|
`Selector:` + fmt.Sprintf("%v", this.Selector) + `,`,
|
|
`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
|
|
`Start:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Start), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`End:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.End), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`Direction:` + fmt.Sprintf("%v", this.Direction) + `,`,
|
|
`Shards:` + fmt.Sprintf("%v", this.Shards) + `,`,
|
|
`Deletes:` + repeatedStringForDeletes + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *SampleQueryRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForDeletes := "[]*Delete{"
|
|
for _, f := range this.Deletes {
|
|
repeatedStringForDeletes += strings.Replace(f.String(), "Delete", "Delete", 1) + ","
|
|
}
|
|
repeatedStringForDeletes += "}"
|
|
s := strings.Join([]string{`&SampleQueryRequest{`,
|
|
`Selector:` + fmt.Sprintf("%v", this.Selector) + `,`,
|
|
`Start:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Start), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`End:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.End), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`Shards:` + fmt.Sprintf("%v", this.Shards) + `,`,
|
|
`Deletes:` + repeatedStringForDeletes + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *Delete) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&Delete{`,
|
|
`Selector:` + fmt.Sprintf("%v", this.Selector) + `,`,
|
|
`Start:` + fmt.Sprintf("%v", this.Start) + `,`,
|
|
`End:` + fmt.Sprintf("%v", this.End) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *QueryResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&QueryResponse{`,
|
|
`Streams:` + fmt.Sprintf("%v", this.Streams) + `,`,
|
|
`Stats:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Stats), "Ingester", "stats.Ingester", 1), `&`, ``, 1) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *SampleQueryResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&SampleQueryResponse{`,
|
|
`Series:` + fmt.Sprintf("%v", this.Series) + `,`,
|
|
`Stats:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Stats), "Ingester", "stats.Ingester", 1), `&`, ``, 1) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *LabelRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&LabelRequest{`,
|
|
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
|
|
`Values:` + fmt.Sprintf("%v", this.Values) + `,`,
|
|
`Start:` + strings.Replace(fmt.Sprintf("%v", this.Start), "Timestamp", "types.Timestamp", 1) + `,`,
|
|
`End:` + strings.Replace(fmt.Sprintf("%v", this.End), "Timestamp", "types.Timestamp", 1) + `,`,
|
|
`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *LabelResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&LabelResponse{`,
|
|
`Values:` + fmt.Sprintf("%v", this.Values) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *Sample) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&Sample{`,
|
|
`Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`,
|
|
`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
|
|
`Hash:` + fmt.Sprintf("%v", this.Hash) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *LegacySample) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&LegacySample{`,
|
|
`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
|
|
`TimestampMs:` + fmt.Sprintf("%v", this.TimestampMs) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *Series) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForSamples := "[]Sample{"
|
|
for _, f := range this.Samples {
|
|
repeatedStringForSamples += strings.Replace(strings.Replace(f.String(), "Sample", "Sample", 1), `&`, ``, 1) + ","
|
|
}
|
|
repeatedStringForSamples += "}"
|
|
s := strings.Join([]string{`&Series{`,
|
|
`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
|
|
`Samples:` + repeatedStringForSamples + `,`,
|
|
`StreamHash:` + fmt.Sprintf("%v", this.StreamHash) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *TailRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&TailRequest{`,
|
|
`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
|
|
`DelayFor:` + fmt.Sprintf("%v", this.DelayFor) + `,`,
|
|
`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
|
|
`Start:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Start), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *TailResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForDroppedStreams := "[]*DroppedStream{"
|
|
for _, f := range this.DroppedStreams {
|
|
repeatedStringForDroppedStreams += strings.Replace(f.String(), "DroppedStream", "DroppedStream", 1) + ","
|
|
}
|
|
repeatedStringForDroppedStreams += "}"
|
|
s := strings.Join([]string{`&TailResponse{`,
|
|
`Stream:` + fmt.Sprintf("%v", this.Stream) + `,`,
|
|
`DroppedStreams:` + repeatedStringForDroppedStreams + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *SeriesRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&SeriesRequest{`,
|
|
`Start:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Start), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`End:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.End), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`Groups:` + fmt.Sprintf("%v", this.Groups) + `,`,
|
|
`Shards:` + fmt.Sprintf("%v", this.Shards) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *SeriesResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForSeries := "[]SeriesIdentifier{"
|
|
for _, f := range this.Series {
|
|
repeatedStringForSeries += strings.Replace(strings.Replace(f.String(), "SeriesIdentifier", "SeriesIdentifier", 1), `&`, ``, 1) + ","
|
|
}
|
|
repeatedStringForSeries += "}"
|
|
s := strings.Join([]string{`&SeriesResponse{`,
|
|
`Series:` + repeatedStringForSeries + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *SeriesIdentifier) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
keysForLabels := make([]string, 0, len(this.Labels))
|
|
for k, _ := range this.Labels {
|
|
keysForLabels = append(keysForLabels, k)
|
|
}
|
|
github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
|
|
mapStringForLabels := "map[string]string{"
|
|
for _, k := range keysForLabels {
|
|
mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
|
|
}
|
|
mapStringForLabels += "}"
|
|
s := strings.Join([]string{`&SeriesIdentifier{`,
|
|
`Labels:` + mapStringForLabels + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *DroppedStream) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&DroppedStream{`,
|
|
`From:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.From), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`To:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.To), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *LabelPair) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&LabelPair{`,
|
|
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
|
|
`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *LegacyLabelPair) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&LegacyLabelPair{`,
|
|
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
|
|
`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *Chunk) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&Chunk{`,
|
|
`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *TailersCountRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&TailersCountRequest{`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *TailersCountResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&TailersCountResponse{`,
|
|
`Count:` + fmt.Sprintf("%v", this.Count) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *GetChunkIDsRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&GetChunkIDsRequest{`,
|
|
`Matchers:` + fmt.Sprintf("%v", this.Matchers) + `,`,
|
|
`Start:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Start), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`End:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.End), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *GetChunkIDsResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&GetChunkIDsResponse{`,
|
|
`ChunkIDs:` + fmt.Sprintf("%v", this.ChunkIDs) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *ChunkRef) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&ChunkRef{`,
|
|
`Fingerprint:` + fmt.Sprintf("%v", this.Fingerprint) + `,`,
|
|
`UserID:` + fmt.Sprintf("%v", this.UserID) + `,`,
|
|
`From:` + fmt.Sprintf("%v", this.From) + `,`,
|
|
`Through:` + fmt.Sprintf("%v", this.Through) + `,`,
|
|
`Checksum:` + fmt.Sprintf("%v", this.Checksum) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *LabelValuesForMetricNameRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&LabelValuesForMetricNameRequest{`,
|
|
`MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
|
|
`LabelName:` + fmt.Sprintf("%v", this.LabelName) + `,`,
|
|
`From:` + fmt.Sprintf("%v", this.From) + `,`,
|
|
`Through:` + fmt.Sprintf("%v", this.Through) + `,`,
|
|
`Matchers:` + fmt.Sprintf("%v", this.Matchers) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *LabelNamesForMetricNameRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&LabelNamesForMetricNameRequest{`,
|
|
`MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
|
|
`From:` + fmt.Sprintf("%v", this.From) + `,`,
|
|
`Through:` + fmt.Sprintf("%v", this.Through) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *LineFilterExpression) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&LineFilterExpression{`,
|
|
`Operator:` + fmt.Sprintf("%v", this.Operator) + `,`,
|
|
`Match:` + fmt.Sprintf("%v", this.Match) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *GetChunkRefRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForFilters := "[]*LineFilterExpression{"
|
|
for _, f := range this.Filters {
|
|
repeatedStringForFilters += strings.Replace(f.String(), "LineFilterExpression", "LineFilterExpression", 1) + ","
|
|
}
|
|
repeatedStringForFilters += "}"
|
|
s := strings.Join([]string{`&GetChunkRefRequest{`,
|
|
`From:` + fmt.Sprintf("%v", this.From) + `,`,
|
|
`Through:` + fmt.Sprintf("%v", this.Through) + `,`,
|
|
`Matchers:` + fmt.Sprintf("%v", this.Matchers) + `,`,
|
|
`Filters:` + repeatedStringForFilters + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *GetChunkRefResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForRefs := "[]*ChunkRef{"
|
|
for _, f := range this.Refs {
|
|
repeatedStringForRefs += strings.Replace(f.String(), "ChunkRef", "ChunkRef", 1) + ","
|
|
}
|
|
repeatedStringForRefs += "}"
|
|
s := strings.Join([]string{`&GetChunkRefResponse{`,
|
|
`Refs:` + repeatedStringForRefs + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *GetSeriesRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&GetSeriesRequest{`,
|
|
`From:` + fmt.Sprintf("%v", this.From) + `,`,
|
|
`Through:` + fmt.Sprintf("%v", this.Through) + `,`,
|
|
`Matchers:` + fmt.Sprintf("%v", this.Matchers) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *GetSeriesResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForSeries := "[]IndexSeries{"
|
|
for _, f := range this.Series {
|
|
repeatedStringForSeries += strings.Replace(strings.Replace(f.String(), "IndexSeries", "IndexSeries", 1), `&`, ``, 1) + ","
|
|
}
|
|
repeatedStringForSeries += "}"
|
|
s := strings.Join([]string{`&GetSeriesResponse{`,
|
|
`Series:` + repeatedStringForSeries + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *IndexSeries) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&IndexSeries{`,
|
|
`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *QueryIndexResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForRows := "[]*Row{"
|
|
for _, f := range this.Rows {
|
|
repeatedStringForRows += strings.Replace(f.String(), "Row", "Row", 1) + ","
|
|
}
|
|
repeatedStringForRows += "}"
|
|
s := strings.Join([]string{`&QueryIndexResponse{`,
|
|
`QueryKey:` + fmt.Sprintf("%v", this.QueryKey) + `,`,
|
|
`Rows:` + repeatedStringForRows + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *Row) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&Row{`,
|
|
`RangeValue:` + fmt.Sprintf("%v", this.RangeValue) + `,`,
|
|
`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *QueryIndexRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForQueries := "[]*IndexQuery{"
|
|
for _, f := range this.Queries {
|
|
repeatedStringForQueries += strings.Replace(f.String(), "IndexQuery", "IndexQuery", 1) + ","
|
|
}
|
|
repeatedStringForQueries += "}"
|
|
s := strings.Join([]string{`&QueryIndexRequest{`,
|
|
`Queries:` + repeatedStringForQueries + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *IndexQuery) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&IndexQuery{`,
|
|
`TableName:` + fmt.Sprintf("%v", this.TableName) + `,`,
|
|
`HashValue:` + fmt.Sprintf("%v", this.HashValue) + `,`,
|
|
`RangeValuePrefix:` + fmt.Sprintf("%v", this.RangeValuePrefix) + `,`,
|
|
`RangeValueStart:` + fmt.Sprintf("%v", this.RangeValueStart) + `,`,
|
|
`ValueEqual:` + fmt.Sprintf("%v", this.ValueEqual) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *IndexStatsRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&IndexStatsRequest{`,
|
|
`From:` + fmt.Sprintf("%v", this.From) + `,`,
|
|
`Through:` + fmt.Sprintf("%v", this.Through) + `,`,
|
|
`Matchers:` + fmt.Sprintf("%v", this.Matchers) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *IndexStatsResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&IndexStatsResponse{`,
|
|
`Streams:` + fmt.Sprintf("%v", this.Streams) + `,`,
|
|
`Chunks:` + fmt.Sprintf("%v", this.Chunks) + `,`,
|
|
`Bytes:` + fmt.Sprintf("%v", this.Bytes) + `,`,
|
|
`Entries:` + fmt.Sprintf("%v", this.Entries) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *VolumeRequest) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&VolumeRequest{`,
|
|
`From:` + fmt.Sprintf("%v", this.From) + `,`,
|
|
`Through:` + fmt.Sprintf("%v", this.Through) + `,`,
|
|
`Matchers:` + fmt.Sprintf("%v", this.Matchers) + `,`,
|
|
`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
|
|
`Step:` + fmt.Sprintf("%v", this.Step) + `,`,
|
|
`TargetLabels:` + fmt.Sprintf("%v", this.TargetLabels) + `,`,
|
|
`AggregateBy:` + fmt.Sprintf("%v", this.AggregateBy) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *VolumeResponse) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
repeatedStringForVolumes := "[]Volume{"
|
|
for _, f := range this.Volumes {
|
|
repeatedStringForVolumes += strings.Replace(strings.Replace(f.String(), "Volume", "Volume", 1), `&`, ``, 1) + ","
|
|
}
|
|
repeatedStringForVolumes += "}"
|
|
s := strings.Join([]string{`&VolumeResponse{`,
|
|
`Volumes:` + repeatedStringForVolumes + `,`,
|
|
`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *Volume) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&Volume{`,
|
|
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
|
|
`Volume:` + fmt.Sprintf("%v", this.Volume) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func valueToStringLogproto(v interface{}) string {
|
|
rv := reflect.ValueOf(v)
|
|
if rv.IsNil() {
|
|
return "nil"
|
|
}
|
|
pv := reflect.Indirect(rv).Interface()
|
|
return fmt.Sprintf("*%v", pv)
|
|
}
|
|
func (m *StreamRatesRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: StreamRatesRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: StreamRatesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *StreamRatesResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: StreamRatesResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: StreamRatesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field StreamRates", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.StreamRates = append(m.StreamRates, &StreamRate{})
|
|
if err := m.StreamRates[len(m.StreamRates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *StreamRate) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: StreamRate: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: StreamRate: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field StreamHash", wireType)
|
|
}
|
|
m.StreamHash = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.StreamHash |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field StreamHashNoShard", wireType)
|
|
}
|
|
m.StreamHashNoShard = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.StreamHashNoShard |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Rate", wireType)
|
|
}
|
|
m.Rate = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Rate |= int64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Tenant", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Tenant = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Pushes", wireType)
|
|
}
|
|
m.Pushes = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Pushes |= uint32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
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
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
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: QueryRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: QueryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Selector = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
|
|
}
|
|
m.Limit = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Limit |= uint32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Start, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.End, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType)
|
|
}
|
|
m.Direction = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Direction |= Direction(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 7:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Shards", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Shards = append(m.Shards, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 8:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Deletes", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Deletes = append(m.Deletes, &Delete{})
|
|
if err := m.Deletes[len(m.Deletes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *SampleQueryRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: SampleQueryRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SampleQueryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Selector = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Start, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.End, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Shards", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Shards = append(m.Shards, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Deletes", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Deletes = append(m.Deletes, &Delete{})
|
|
if err := m.Deletes[len(m.Deletes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Delete) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: Delete: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Delete: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Selector = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
|
|
}
|
|
m.Start = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Start |= int64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
|
|
}
|
|
m.End = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.End |= int64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *QueryResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: QueryResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: QueryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Streams", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Streams = append(m.Streams, github_com_grafana_loki_pkg_push.Stream{})
|
|
if err := m.Streams[len(m.Streams)-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 Stats", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *SampleQueryResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: SampleQueryResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SampleQueryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Series", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Series = append(m.Series, Series{})
|
|
if err := m.Series[len(m.Series)-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 Stats", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *LabelRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: LabelRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: LabelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Name = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Values = bool(v != 0)
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Start == nil {
|
|
m.Start = new(time.Time)
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Start, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.End == nil {
|
|
m.End = new(time.Time)
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.End, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Query = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *LabelResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: LabelResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: LabelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Sample) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: Sample: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Sample: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
|
|
}
|
|
m.Timestamp = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Timestamp |= int64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 1 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
|
|
}
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
|
|
iNdEx += 8
|
|
m.Value = float64(math.Float64frombits(v))
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
|
|
}
|
|
m.Hash = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Hash |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *LegacySample) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: LegacySample: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: LegacySample: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 1 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
|
|
}
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
|
|
iNdEx += 8
|
|
m.Value = float64(math.Float64frombits(v))
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field TimestampMs", wireType)
|
|
}
|
|
m.TimestampMs = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.TimestampMs |= int64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Series) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: Series: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Series: 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 stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Labels = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Samples", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Samples = append(m.Samples, Sample{})
|
|
if err := m.Samples[len(m.Samples)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field StreamHash", wireType)
|
|
}
|
|
m.StreamHash = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.StreamHash |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *TailRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: TailRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: TailRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Query = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field DelayFor", wireType)
|
|
}
|
|
m.DelayFor = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.DelayFor |= uint32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
|
|
}
|
|
m.Limit = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Limit |= uint32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Start, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *TailResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: TailResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: TailResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Stream", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Stream == nil {
|
|
m.Stream = &github_com_grafana_loki_pkg_push.Stream{}
|
|
}
|
|
if err := m.Stream.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field DroppedStreams", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.DroppedStreams = append(m.DroppedStreams, &DroppedStream{})
|
|
if err := m.DroppedStreams[len(m.DroppedStreams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *SeriesRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: SeriesRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SeriesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Start, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.End, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Shards", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Shards = append(m.Shards, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *SeriesResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: SeriesResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SeriesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Series", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Series = append(m.Series, SeriesIdentifier{})
|
|
if err := m.Series[len(m.Series)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *SeriesIdentifier) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: SeriesIdentifier: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SeriesIdentifier: 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 ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Labels == nil {
|
|
m.Labels = make(map[string]string)
|
|
}
|
|
var mapkey string
|
|
var mapvalue string
|
|
for iNdEx < postIndex {
|
|
entryPreIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
if fieldNum == 1 {
|
|
var stringLenmapkey uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLenmapkey |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLenmapkey := int(stringLenmapkey)
|
|
if intStringLenmapkey < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postStringIndexmapkey := iNdEx + intStringLenmapkey
|
|
if postStringIndexmapkey < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postStringIndexmapkey > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
|
|
iNdEx = postStringIndexmapkey
|
|
} else if fieldNum == 2 {
|
|
var stringLenmapvalue uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLenmapvalue |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLenmapvalue := int(stringLenmapvalue)
|
|
if intStringLenmapvalue < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
|
|
if postStringIndexmapvalue < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postStringIndexmapvalue > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
|
|
iNdEx = postStringIndexmapvalue
|
|
} else {
|
|
iNdEx = entryPreIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > postIndex {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
m.Labels[mapkey] = mapvalue
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *DroppedStream) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: DroppedStream: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: DroppedStream: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.From, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.To, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Labels = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *LabelPair) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: LabelPair: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: LabelPair: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Name = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Value = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *LegacyLabelPair) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: LegacyLabelPair: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: LegacyLabelPair: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Name = append(m.Name[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Name == nil {
|
|
m.Name = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Value == nil {
|
|
m.Value = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Chunk) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: Chunk: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Chunk: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
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 ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Data == nil {
|
|
m.Data = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *TailersCountRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: TailersCountRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: TailersCountRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *TailersCountResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: TailersCountResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: TailersCountResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
|
|
}
|
|
m.Count = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Count |= uint32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *GetChunkIDsRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: GetChunkIDsRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetChunkIDsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Matchers = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Start, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.End, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *GetChunkIDsResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: GetChunkIDsResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetChunkIDsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ChunkIDs", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.ChunkIDs = append(m.ChunkIDs, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ChunkRef) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: ChunkRef: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ChunkRef: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Fingerprint", wireType)
|
|
}
|
|
m.Fingerprint = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Fingerprint |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserID", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.UserID = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
|
|
}
|
|
m.From = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.From |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Through", wireType)
|
|
}
|
|
m.Through = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Through |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Checksum", wireType)
|
|
}
|
|
m.Checksum = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Checksum |= uint32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *LabelValuesForMetricNameRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: LabelValuesForMetricNameRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: LabelValuesForMetricNameRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.MetricName = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field LabelName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.LabelName = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
|
|
}
|
|
m.From = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.From |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Through", wireType)
|
|
}
|
|
m.Through = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Through |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Matchers = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *LabelNamesForMetricNameRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: LabelNamesForMetricNameRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: LabelNamesForMetricNameRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.MetricName = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
|
|
}
|
|
m.From = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.From |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Through", wireType)
|
|
}
|
|
m.Through = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Through |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *LineFilterExpression) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: LineFilterExpression: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: LineFilterExpression: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
|
|
}
|
|
m.Operator = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Operator |= int64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Match", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Match = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *GetChunkRefRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: GetChunkRefRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetChunkRefRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
|
|
}
|
|
m.From = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.From |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Through", wireType)
|
|
}
|
|
m.Through = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Through |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Matchers = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Filters = append(m.Filters, &LineFilterExpression{})
|
|
if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *GetChunkRefResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: GetChunkRefResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetChunkRefResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Refs", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Refs = append(m.Refs, &ChunkRef{})
|
|
if err := m.Refs[len(m.Refs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *GetSeriesRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: GetSeriesRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetSeriesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
|
|
}
|
|
m.From = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.From |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Through", wireType)
|
|
}
|
|
m.Through = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Through |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Matchers = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *GetSeriesResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: GetSeriesResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetSeriesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Series", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Series = append(m.Series, IndexSeries{})
|
|
if err := m.Series[len(m.Series)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *IndexSeries) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: IndexSeries: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: IndexSeries: 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 ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Labels = append(m.Labels, LabelAdapter{})
|
|
if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *QueryIndexResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: QueryIndexResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: QueryIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field QueryKey", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.QueryKey = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Rows = append(m.Rows, &Row{})
|
|
if err := m.Rows[len(m.Rows)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Row) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: Row: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Row: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RangeValue", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.RangeValue = append(m.RangeValue[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.RangeValue == nil {
|
|
m.RangeValue = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Value == nil {
|
|
m.Value = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *QueryIndexRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: QueryIndexRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: QueryIndexRequest: 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 ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Queries = append(m.Queries, &IndexQuery{})
|
|
if err := m.Queries[len(m.Queries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *IndexQuery) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: IndexQuery: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: IndexQuery: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.TableName = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field HashValue", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.HashValue = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RangeValuePrefix", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.RangeValuePrefix = append(m.RangeValuePrefix[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.RangeValuePrefix == nil {
|
|
m.RangeValuePrefix = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RangeValueStart", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.RangeValueStart = append(m.RangeValueStart[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.RangeValueStart == nil {
|
|
m.RangeValueStart = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ValueEqual", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.ValueEqual = append(m.ValueEqual[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.ValueEqual == nil {
|
|
m.ValueEqual = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *IndexStatsRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: IndexStatsRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: IndexStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
|
|
}
|
|
m.From = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.From |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Through", wireType)
|
|
}
|
|
m.Through = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Through |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Matchers = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *IndexStatsResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: IndexStatsResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: IndexStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Streams", wireType)
|
|
}
|
|
m.Streams = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Streams |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType)
|
|
}
|
|
m.Chunks = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Chunks |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Bytes", wireType)
|
|
}
|
|
m.Bytes = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Bytes |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
|
|
}
|
|
m.Entries = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Entries |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *VolumeRequest) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: VolumeRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: VolumeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
|
|
}
|
|
m.From = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.From |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Through", wireType)
|
|
}
|
|
m.Through = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Through |= github_com_prometheus_common_model.Time(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Matchers = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
|
|
}
|
|
m.Limit = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Limit |= int32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType)
|
|
}
|
|
m.Step = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Step |= int64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 6:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field TargetLabels", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.TargetLabels = append(m.TargetLabels, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 7:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AggregateBy", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.AggregateBy = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *VolumeResponse) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: VolumeResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: VolumeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Volumes = append(m.Volumes, Volume{})
|
|
if err := m.Volumes[len(m.Volumes)-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 Limit", wireType)
|
|
}
|
|
m.Limit = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Limit |= int32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Volume) 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 ErrIntOverflowLogproto
|
|
}
|
|
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: Volume: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Volume: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Name = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Volume", wireType)
|
|
}
|
|
m.Volume = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Volume |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipLogproto(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthLogproto
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func skipLogproto(dAtA []byte) (n int, err error) {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
wireType := int(wire & 0x7)
|
|
switch wireType {
|
|
case 0:
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx++
|
|
if dAtA[iNdEx-1] < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
return iNdEx, nil
|
|
case 1:
|
|
iNdEx += 8
|
|
return iNdEx, nil
|
|
case 2:
|
|
var length int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
length |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if length < 0 {
|
|
return 0, ErrInvalidLengthLogproto
|
|
}
|
|
iNdEx += length
|
|
if iNdEx < 0 {
|
|
return 0, ErrInvalidLengthLogproto
|
|
}
|
|
return iNdEx, nil
|
|
case 3:
|
|
for {
|
|
var innerWire uint64
|
|
var start int = iNdEx
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowLogproto
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
innerWire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
innerWireType := int(innerWire & 0x7)
|
|
if innerWireType == 4 {
|
|
break
|
|
}
|
|
next, err := skipLogproto(dAtA[start:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
iNdEx = start + next
|
|
if iNdEx < 0 {
|
|
return 0, ErrInvalidLengthLogproto
|
|
}
|
|
}
|
|
return iNdEx, nil
|
|
case 4:
|
|
return iNdEx, nil
|
|
case 5:
|
|
iNdEx += 4
|
|
return iNdEx, nil
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthLogproto = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowLogproto = fmt.Errorf("proto: integer overflow")
|
|
)
|
|
|