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

chore: bump gogo/protobuf and regenerate 

It had been bumped previously from v1.1.1 to v1.2.0 and nothing was
regenerated. This bumps it to v1.2.1 and regenerates.
pull/13094/head
Jeff Wendling 2019-04-02 13:35:46 -06:00
parent dd55308b77
commit 5dc3e52fd9
7 changed files with 855 additions and 496 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
go.mod
View File

@ -39,7 +39,7 @@ require (
github.com/go-ldap/ldap v2.5.1+incompatible // indirect
github.com/go-test/deep v1.0.1 // indirect
github.com/gocql/gocql v0.0.0-20181124151448-70385f88b28b // indirect
github.com/gogo/protobuf v1.2.0
github.com/gogo/protobuf v1.2.1
github.com/golang/gddo v0.0.0-20181116215533-9bd4a3295021
github.com/golang/protobuf v1.2.0
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db

4
go.sum
View File

@ -134,6 +134,8 @@ github.com/gocql/gocql v0.0.0-20181124151448-70385f88b28b h1:dnUw9Ih14dCKzbtZxm+
github.com/gocql/gocql v0.0.0-20181124151448-70385f88b28b/go.mod h1:4Fw1eo5iaEhDUs8XyuhSVCVy52Jq3L+/3GJgYkwc+/0=
github.com/gogo/protobuf v1.2.0 h1:xU6/SpYbvkNYiptHJYEDRseDLvYE7wSqhYYNy0QSUzI=
github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE=
github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
github.com/golang/gddo v0.0.0-20181116215533-9bd4a3295021 h1:HYV500jCgk+IC68L5sWrLFIWMpaUFfXXpJSAb7XOoBk=
github.com/golang/gddo v0.0.0-20181116215533-9bd4a3295021/go.mod h1:xEhNfoBDX1hzLm2Nf80qUvZ2sVwoMZ8d6IE2SrsQfh4=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
@ -260,6 +262,7 @@ github.com/kevinburke/go-bindata v3.11.0+incompatible/go.mod h1:/pEEZ72flUW2p0yi
github.com/kevinburke/ssh_config v0.0.0-20180830205328-81db2a75821e/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
github.com/keybase/go-crypto v0.0.0-20181127160227-255a5089e85a h1:X/UFlwD2/UV0RCy+8ITi4DmxJwk83YUH7bXwkJIHHMo=
github.com/keybase/go-crypto v0.0.0-20181127160227-255a5089e85a/go.mod h1:ghbZscTyKdM07+Fw3KSi0hcJm+AlEUWj8QLlPtijN/M=
github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
github.com/kisielk/gotool v1.0.0 h1:AV2c/EiW3KqPNT9ZKl07ehoAGi4C5/01Cfbblndcapg=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
@ -466,6 +469,7 @@ golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c h1:fqgJT0MGcGpPgpWU7VRdRjuArfcOvC4AoJmILihzhDg=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181221154417-3ad2d988d5e2 h1:M7NLB69gFpUH4s6SJLwXiVs45aZfVjqGKynfNFKSGcI=

2
scripts/protoc-gen-gogo
View File

@ -1,2 +1,2 @@
#!/bin/bash
#!/usr/bin/env bash
env GO111MODULE=on go run github.com/gogo/protobuf/protoc-gen-gogo "$@"

2
scripts/protoc-gen-gogofaster
View File

@ -1,2 +1,2 @@
#!/bin/bash
#!/usr/bin/env bash
env GO111MODULE=on go run github.com/gogo/protobuf/protoc-gen-gogofaster "$@"

274
storage/reads/datatypes/predicate.pb.go
View File

@ -3,14 +3,14 @@
package datatypes
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import encoding_binary "encoding/binary"
import io "io"
import (
encoding_binary "encoding/binary"
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
@ -42,6 +42,7 @@ var Node_Type_name = map[int32]string{
4: "LITERAL",
5: "FIELD_REF",
}
var Node_Type_value = map[string]int32{
"LOGICAL_EXPRESSION": 0,
"COMPARISON_EXPRESSION": 1,
@ -54,8 +55,9 @@ var Node_Type_value = map[string]int32{
func (x Node_Type) String() string {
return proto.EnumName(Node_Type_name, int32(x))
}
func (Node_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_predicate_dbcd4976a789e072, []int{0, 0}
return fileDescriptor_87cba9804b436f42, []int{0, 0}
}
type Node_Comparison int32
@ -83,6 +85,7 @@ var Node_Comparison_name = map[int32]string{
7: "GT",
8: "GTE",
}
var Node_Comparison_value = map[string]int32{
"EQUAL": 0,
"NOT_EQUAL": 1,
@ -98,8 +101,9 @@ var Node_Comparison_value = map[string]int32{
func (x Node_Comparison) String() string {
return proto.EnumName(Node_Comparison_name, int32(x))
}
func (Node_Comparison) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_predicate_dbcd4976a789e072, []int{0, 1}
return fileDescriptor_87cba9804b436f42, []int{0, 1}
}
// Logical operators apply to boolean values and combine to produce a single boolean result.
@ -114,6 +118,7 @@ var Node_Logical_name = map[int32]string{
0: "AND",
1: "OR",
}
var Node_Logical_value = map[string]int32{
"AND": 0,
"OR": 1,
@ -122,13 +127,14 @@ var Node_Logical_value = map[string]int32{
func (x Node_Logical) String() string {
return proto.EnumName(Node_Logical_name, int32(x))
}
func (Node_Logical) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_predicate_dbcd4976a789e072, []int{0, 2}
return fileDescriptor_87cba9804b436f42, []int{0, 2}
}
type Node struct {
NodeType Node_Type `protobuf:"varint,1,opt,name=node_type,json=nodeType,proto3,enum=influxdata.platform.storage.Node_Type" json:"nodeType"`
Children []*Node `protobuf:"bytes,2,rep,name=children" json:"children,omitempty"`
Children []*Node `protobuf:"bytes,2,rep,name=children,proto3" json:"children,omitempty"`
// Types that are valid to be assigned to Value:
// *Node_StringValue
// *Node_BooleanValue
@ -140,16 +146,14 @@ type Node struct {
// *Node_FieldRefValue
// *Node_Logical_
// *Node_Comparison_
Value isNode_Value `protobuf_oneof:"value"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_sizecache int32 `json:"-"`
Value isNode_Value `protobuf_oneof:"value"`
}
func (m *Node) Reset() { *m = Node{} }
func (m *Node) String() string { return proto.CompactTextString(m) }
func (*Node) ProtoMessage() {}
func (*Node) Descriptor() ([]byte, []int) {
return fileDescriptor_predicate_dbcd4976a789e072, []int{0}
return fileDescriptor_87cba9804b436f42, []int{0}
}
func (m *Node) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -166,8 +170,8 @@ func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return b[:n], nil
}
}
func (dst *Node) XXX_Merge(src proto.Message) {
xxx_messageInfo_Node.Merge(dst, src)
func (m *Node) XXX_Merge(src proto.Message) {
xxx_messageInfo_Node.Merge(m, src)
}
func (m *Node) XXX_Size() int {
return m.Size()
@ -373,7 +377,7 @@ func _Node_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
_ = b.EncodeVarint(uint64(x.Comparison))
case nil:
default:
return fmt.Errorf("node.Value has unexpected type %T", x)
return fmt.Errorf("Node.Value has unexpected type %T", x)
}
return nil
}
@ -502,16 +506,14 @@ func _Node_OneofSizer(msg proto.Message) (n int) {
}
type Predicate struct {
Root *Node `protobuf:"bytes,1,opt,name=root" json:"root,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_sizecache int32 `json:"-"`
Root *Node `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"`
}
func (m *Predicate) Reset() { *m = Predicate{} }
func (m *Predicate) String() string { return proto.CompactTextString(m) }
func (*Predicate) ProtoMessage() {}
func (*Predicate) Descriptor() ([]byte, []int) {
return fileDescriptor_predicate_dbcd4976a789e072, []int{1}
return fileDescriptor_87cba9804b436f42, []int{1}
}
func (m *Predicate) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -528,8 +530,8 @@ func (m *Predicate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return b[:n], nil
}
}
func (dst *Predicate) XXX_Merge(src proto.Message) {
xxx_messageInfo_Predicate.Merge(dst, src)
func (m *Predicate) XXX_Merge(src proto.Message) {
xxx_messageInfo_Predicate.Merge(m, src)
}
func (m *Predicate) XXX_Size() int {
return m.Size()
@ -548,12 +550,74 @@ func (m *Predicate) GetRoot() *Node {
}
func init() {
proto.RegisterType((*Node)(nil), "influxdata.platform.storage.Node")
proto.RegisterType((*Predicate)(nil), "influxdata.platform.storage.Predicate")
proto.RegisterEnum("influxdata.platform.storage.Node_Type", Node_Type_name, Node_Type_value)
proto.RegisterEnum("influxdata.platform.storage.Node_Comparison", Node_Comparison_name, Node_Comparison_value)
proto.RegisterEnum("influxdata.platform.storage.Node_Logical", Node_Logical_name, Node_Logical_value)
proto.RegisterType((*Node)(nil), "influxdata.platform.storage.Node")
proto.RegisterType((*Predicate)(nil), "influxdata.platform.storage.Predicate")
}
func init() { proto.RegisterFile("predicate.proto", fileDescriptor_87cba9804b436f42) }
var fileDescriptor_87cba9804b436f42 = []byte{
// 869 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x95, 0xcd, 0x6e, 0xdb, 0x46,
0x10, 0xc7, 0x45, 0x7d, 0x58, 0xe2, 0xc8, 0x1f, 0xcc, 0xc6, 0x8e, 0x55, 0xa6, 0x91, 0xb6, 0x36,
0x5a, 0x28, 0x40, 0xa1, 0xc0, 0x6e, 0x7d, 0x0a, 0x8a, 0x82, 0x74, 0x68, 0x59, 0x00, 0x2b, 0xa9,
0x14, 0xd3, 0x04, 0x05, 0x0a, 0x81, 0xb1, 0x56, 0x0c, 0x01, 0x86, 0xab, 0x2e, 0x57, 0x85, 0xf3,
0x06, 0x05, 0x4f, 0xbd, 0x07, 0x3c, 0xf5, 0x65, 0x7a, 0x29, 0x90, 0x63, 0x4f, 0x42, 0x21, 0xdf,
0xfa, 0x14, 0x05, 0xbf, 0xe5, 0xb6, 0xa8, 0x73, 0xdb, 0x99, 0xfd, 0xff, 0xfe, 0x3b, 0x3b, 0x1c,
0xad, 0x60, 0x6f, 0xc1, 0xc8, 0xcc, 0xb9, 0xb2, 0x38, 0xe9, 0x2d, 0x18, 0xe5, 0x14, 0x3d, 0x74,
0xbc, 0xb9, 0xbb, 0xbc, 0x9e, 0x59, 0xdc, 0xea, 0x2d, 0x5c, 0x8b, 0xcf, 0x29, 0x7b, 0xd3, 0xf3,
0x39, 0x65, 0x96, 0x4d, 0xe4, 0x7d, 0x9b, 0xda, 0x34, 0xd6, 0x3d, 0x89, 0x56, 0x09, 0x72, 0xf4,
0xae, 0x09, 0xd5, 0x21, 0x9d, 0x11, 0xf4, 0x03, 0x88, 0x1e, 0x9d, 0x91, 0x29, 0x7f, 0xbb, 0x20,
0x2d, 0x01, 0x0b, 0xdd, 0xdd, 0xd3, 0xcf, 0x7a, 0xff, 0xe3, 0xd7, 0x8b, 0xa8, 0x9e, 0xf9, 0x76,
0x41, 0xd4, 0xd6, 0x7a, 0xd5, 0x69, 0x44, 0x61, 0x14, 0xfd, 0xb5, 0xea, 0x34, 0xbc, 0x74, 0x6d,
0xe4, 0x2b, 0xf4, 0x15, 0x34, 0xae, 0x5e, 0x3b, 0xee, 0x8c, 0x11, 0xaf, 0x55, 0xc6, 0x95, 0x6e,
0xf3, 0xf4, 0x93, 0x3b, 0xdd, 0x8d, 0x1c, 0x41, 0x5f, 0xc2, 0xb6, 0xcf, 0x99, 0xe3, 0xd9, 0xd3,
0x9f, 0x2c, 0x77, 0x49, 0x5a, 0x15, 0x2c, 0x74, 0x45, 0x75, 0x6f, 0xbd, 0xea, 0x34, 0x27, 0x71,
0xfe, 0xbb, 0x28, 0x7d, 0x59, 0x32, 0x9a, 0x7e, 0x11, 0xa2, 0x13, 0x80, 0x57, 0x94, 0xba, 0x29,
0x53, 0xc5, 0x42, 0xb7, 0xa1, 0x4a, 0xeb, 0x55, 0x67, 0x5b, 0xa5, 0xd4, 0x25, 0x96, 0x97, 0x41,
0x62, 0xa4, 0x4a, 0x90, 0x27, 0x20, 0x3a, 0x1e, 0x4f, 0x89, 0x1a, 0x16, 0xba, 0x95, 0x84, 0x18,
0x78, 0x9c, 0xd8, 0x84, 0x65, 0x44, 0xc3, 0xf1, 0x78, 0x02, 0x9c, 0x02, 0x2c, 0x0b, 0x62, 0x0b,
0x0b, 0xdd, 0xaa, 0x7a, 0x6f, 0xbd, 0xea, 0xec, 0x3c, 0xf7, 0x7c, 0xc7, 0xf6, 0xc8, 0x2c, 0x3f,
0x64, 0x99, 0x33, 0x27, 0xd0, 0x9c, 0xbb, 0xd4, 0xca, 0xa0, 0x3a, 0x16, 0xba, 0x82, 0xba, 0xbb,
0x5e, 0x75, 0xe0, 0x22, 0x4a, 0x67, 0x04, 0xcc, 0xf3, 0x28, 0x42, 0x18, 0xb1, 0xc9, 0x75, 0x8a,
0x34, 0xe2, 0xfb, 0xc7, 0x88, 0x11, 0xa5, 0x73, 0x84, 0xe5, 0x11, 0x3a, 0x83, 0x1d, 0x6e, 0xd9,
0x53, 0x46, 0xe6, 0x29, 0x24, 0x16, 0x4d, 0x33, 0x2d, 0xdb, 0x20, 0xf3, 0xbc, 0x69, 0xbc, 0x08,
0xd1, 0x53, 0xd8, 0x9b, 0x3b, 0xc4, 0x9d, 0x6d, 0x80, 0x10, 0x83, 0xf1, 0xad, 0x2e, 0xa2, 0xad,
0x0d, 0x74, 0x67, 0xbe, 0x99, 0x40, 0x1a, 0xd4, 0x5d, 0x6a, 0x3b, 0x57, 0x96, 0xdb, 0x6a, 0xc6,
0x33, 0xf4, 0xf8, 0xee, 0x19, 0xd2, 0x13, 0xe0, 0xb2, 0x64, 0x64, 0x2c, 0x1a, 0x02, 0x5c, 0xd1,
0x37, 0x0b, 0x8b, 0x39, 0x3e, 0xf5, 0x5a, 0xdb, 0xb1, 0xd3, 0xe7, 0x77, 0x3b, 0x9d, 0xe7, 0x4c,
0xd4, 0x8a, 0xc2, 0xe1, 0xe8, 0x5d, 0x19, 0xaa, 0xf1, 0x18, 0x9e, 0x01, 0xd2, 0x47, 0xfd, 0xc1,
0xb9, 0xa2, 0x4f, 0xb5, 0x97, 0x63, 0x43, 0x9b, 0x4c, 0x06, 0xa3, 0xa1, 0x54, 0x92, 0x1f, 0x05,
0x21, 0xfe, 0x28, 0x1b, 0xe1, 0xb4, 0x20, 0xed, 0x7a, 0xc1, 0x88, 0xef, 0x3b, 0xd4, 0x43, 0x4f,
0xe1, 0xe0, 0x7c, 0xf4, 0xcd, 0x58, 0x31, 0x06, 0x93, 0xd1, 0x70, 0x93, 0x14, 0x64, 0x1c, 0x84,
0xf8, 0xe3, 0x8c, 0x2c, 0x0a, 0xd8, 0x80, 0x4f, 0x40, 0x1a, 0x2b, 0x86, 0x76, 0x8b, 0x2b, 0xcb,
0x0f, 0x83, 0x10, 0x1f, 0x66, 0xdc, 0xd8, 0x62, 0x64, 0x13, 0xe9, 0x40, 0xdd, 0x54, 0xfa, 0x53,
0x43, 0xbb, 0x90, 0x2a, 0x32, 0x0a, 0x42, 0xbc, 0x9b, 0x29, 0x93, 0x0f, 0x87, 0x30, 0xd4, 0xf5,
0x81, 0xa9, 0x19, 0x8a, 0x2e, 0x55, 0xe5, 0xfb, 0x41, 0x88, 0xf7, 0xf2, 0xe2, 0x1d, 0x4e, 0x98,
0xe5, 0xa2, 0x63, 0x10, 0x2f, 0x06, 0x9a, 0xfe, 0x2c, 0x36, 0xa9, 0xc9, 0xfb, 0x41, 0x88, 0xa5,
0x4c, 0x93, 0x7d, 0x44, 0xb9, 0xfa, 0xf3, 0xaf, 0xed, 0xd2, 0xd1, 0xef, 0x65, 0x80, 0xa2, 0x72,
0xd4, 0x86, 0x9a, 0xf6, 0xed, 0x73, 0x45, 0x97, 0x4a, 0x89, 0xf3, 0xc6, 0xa5, 0x7e, 0x5c, 0x5a,
0x2e, 0xfa, 0x14, 0xc4, 0xe1, 0xc8, 0x9c, 0x26, 0x1a, 0x41, 0x7e, 0x10, 0x84, 0x18, 0x15, 0x9a,
0x21, 0xe5, 0x89, 0xec, 0x31, 0x34, 0x27, 0xa6, 0x62, 0x98, 0x93, 0xe9, 0x8b, 0x81, 0x79, 0x29,
0x95, 0xe5, 0x56, 0x10, 0xe2, 0xfd, 0x42, 0x38, 0xe1, 0x16, 0xe3, 0xfe, 0x0b, 0x87, 0xbf, 0x8e,
0x4e, 0x34, 0xb4, 0xbe, 0xf6, 0x52, 0xaa, 0xfc, 0xf3, 0xc4, 0x78, 0xb8, 0xb3, 0x13, 0x13, 0x4d,
0xf5, 0x3f, 0x4e, 0x4c, 0x64, 0x32, 0x94, 0x75, 0x53, 0xaa, 0x25, 0x0d, 0x2b, 0xf6, 0x75, 0xe2,
0xfb, 0x08, 0x43, 0x45, 0x37, 0x35, 0x69, 0x4b, 0x3e, 0x0c, 0x42, 0x7c, 0xff, 0xf6, 0x66, 0x52,
0xef, 0x23, 0x28, 0xf7, 0x4d, 0xa9, 0x2e, 0x1f, 0x04, 0x21, 0xbe, 0x57, 0x08, 0xfa, 0x8c, 0x58,
0x9c, 0x30, 0x74, 0x0c, 0x95, 0xbe, 0xa9, 0x49, 0x0d, 0x59, 0x0e, 0x42, 0xfc, 0xe0, 0x5f, 0xfb,
0xb1, 0x47, 0xda, 0xcf, 0xaf, 0xa1, 0x9e, 0x8e, 0x10, 0x3a, 0x84, 0x8a, 0x32, 0x7c, 0x26, 0x95,
0xe4, 0xdd, 0x20, 0xc4, 0x90, 0x66, 0x15, 0x6f, 0x86, 0x0e, 0xa0, 0x3c, 0x32, 0x24, 0x41, 0xde,
0x09, 0x42, 0x2c, 0xa6, 0xf9, 0x11, 0x4b, 0x0c, 0xd4, 0x3a, 0xd4, 0xe2, 0x1f, 0xde, 0x91, 0x0a,
0xe2, 0x38, 0x7b, 0xe3, 0xd1, 0x19, 0x54, 0x19, 0xa5, 0x3c, 0x7e, 0x9c, 0x3f, 0xe8, 0xf9, 0x8c,
0xe5, 0xea, 0xf1, 0x6f, 0xeb, 0xb6, 0xf0, 0x7e, 0xdd, 0x16, 0xfe, 0x5c, 0xb7, 0x85, 0x5f, 0x6e,
0xda, 0xa5, 0xf7, 0x37, 0xed, 0xd2, 0x1f, 0x37, 0xed, 0xd2, 0xf7, 0x62, 0xc4, 0x46, 0xef, 0xbd,
0xff, 0x6a, 0x2b, 0xfe, 0x37, 0xf8, 0xe2, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x27, 0x63, 0xc0,
0x0c, 0x53, 0x06, 0x00, 0x00,
}
func (m *Node) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -714,6 +778,9 @@ func encodeVarintPredicate(dAtA []byte, offset int, v uint64) int {
return offset + 1
}
func (m *Node) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.NodeType != 0 {
@ -732,6 +799,9 @@ func (m *Node) Size() (n int) {
}
func (m *Node_StringValue) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.StringValue)
@ -739,30 +809,45 @@ func (m *Node_StringValue) Size() (n int) {
return n
}
func (m *Node_BooleanValue) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 2
return n
}
func (m *Node_IntegerValue) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 1 + sovPredicate(uint64(m.IntegerValue))
return n
}
func (m *Node_UnsignedValue) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 1 + sovPredicate(uint64(m.UnsignedValue))
return n
}
func (m *Node_FloatValue) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 9
return n
}
func (m *Node_RegexValue) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.RegexValue)
@ -770,6 +855,9 @@ func (m *Node_RegexValue) Size() (n int) {
return n
}
func (m *Node_TagRefValue) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.TagRefValue)
@ -777,6 +865,9 @@ func (m *Node_TagRefValue) Size() (n int) {
return n
}
func (m *Node_FieldRefValue) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.FieldRefValue)
@ -784,18 +875,27 @@ func (m *Node_FieldRefValue) Size() (n int) {
return n
}
func (m *Node_Logical_) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 1 + sovPredicate(uint64(m.Logical))
return n
}
func (m *Node_Comparison_) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 1 + sovPredicate(uint64(m.Comparison))
return n
}
func (m *Predicate) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Root != nil {
@ -833,7 +933,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -861,7 +961,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.NodeType |= (Node_Type(b) & 0x7F) << shift
m.NodeType |= Node_Type(b&0x7F) << shift
if b < 0x80 {
break
}
@ -880,7 +980,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
@ -889,6 +989,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthPredicate
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthPredicate
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -911,7 +1014,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -921,6 +1024,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthPredicate
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthPredicate
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -940,7 +1046,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
@ -961,7 +1067,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
v |= (int64(b) & 0x7F) << shift
v |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -981,7 +1087,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint64(b) & 0x7F) << shift
v |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1012,7 +1118,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1022,6 +1128,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthPredicate
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthPredicate
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -1041,7 +1150,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1051,6 +1160,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthPredicate
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthPredicate
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -1070,7 +1182,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1080,6 +1192,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthPredicate
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthPredicate
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -1099,7 +1214,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
v |= (Node_Logical(b) & 0x7F) << shift
v |= Node_Logical(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1119,7 +1234,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
v |= (Node_Comparison(b) & 0x7F) << shift
v |= Node_Comparison(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1134,6 +1249,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
if skippy < 0 {
return ErrInvalidLengthPredicate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPredicate
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
@ -1161,7 +1279,7 @@ func (m *Predicate) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1189,7 +1307,7 @@ func (m *Predicate) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1198,6 +1316,9 @@ func (m *Predicate) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthPredicate
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthPredicate
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -1217,6 +1338,9 @@ func (m *Predicate) Unmarshal(dAtA []byte) error {
if skippy < 0 {
return ErrInvalidLengthPredicate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPredicate
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
@ -1283,10 +1407,13 @@ func skipPredicate(dAtA []byte) (n int, err error) {
break
}
}
iNdEx += length
if length < 0 {
return 0, ErrInvalidLengthPredicate
}
iNdEx += length
if iNdEx < 0 {
return 0, ErrInvalidLengthPredicate
}
return iNdEx, nil
case 3:
for {
@ -1315,6 +1442,9 @@ func skipPredicate(dAtA []byte) (n int, err error) {
return 0, err
}
iNdEx = start + next
if iNdEx < 0 {
return 0, ErrInvalidLengthPredicate
}
}
return iNdEx, nil
case 4:
@ -1333,63 +1463,3 @@ var (
ErrInvalidLengthPredicate = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowPredicate = fmt.Errorf("proto: integer overflow")
)
func init() { proto.RegisterFile("predicate.proto", fileDescriptor_predicate_dbcd4976a789e072) }
var fileDescriptor_predicate_dbcd4976a789e072 = []byte{
// 860 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x95, 0xdd, 0x8e, 0xdb, 0x44,
0x14, 0xc7, 0xe3, 0x7c, 0x6c, 0xe2, 0x93, 0xfd, 0x70, 0xa7, 0xbb, 0xdd, 0xe0, 0xa5, 0xc9, 0xb0,
0x15, 0x28, 0x95, 0x50, 0xaa, 0x5d, 0xd8, 0xab, 0x0a, 0xa1, 0x78, 0xeb, 0xcd, 0x46, 0x32, 0x49,
0x70, 0x5c, 0x5a, 0x21, 0xa1, 0x68, 0xba, 0x99, 0xb8, 0x96, 0x5c, 0x4f, 0x18, 0x4f, 0xd0, 0xf6,
0x0d, 0x90, 0xaf, 0xb8, 0xaf, 0x7c, 0xc5, 0xcb, 0x70, 0x83, 0xc4, 0x13, 0x44, 0x28, 0xdc, 0xf1,
0x14, 0xc8, 0xdf, 0x29, 0x20, 0x96, 0xbb, 0x39, 0x67, 0xfe, 0xbf, 0xff, 0x9c, 0x39, 0x3e, 0x99,
0xc0, 0xc1, 0x92, 0xd3, 0xb9, 0x73, 0x43, 0x04, 0xed, 0x2d, 0x39, 0x13, 0x0c, 0x9d, 0x38, 0xde,
0xc2, 0x5d, 0xdd, 0xce, 0x89, 0x20, 0xbd, 0xa5, 0x4b, 0xc4, 0x82, 0xf1, 0x37, 0x3d, 0x5f, 0x30,
0x4e, 0x6c, 0xaa, 0x1e, 0xda, 0xcc, 0x66, 0xb1, 0xee, 0x49, 0xb4, 0x4a, 0x90, 0xd3, 0x77, 0x4d,
0xa8, 0x8e, 0xd8, 0x9c, 0xa2, 0xef, 0x40, 0xf6, 0xd8, 0x9c, 0xce, 0xc4, 0xdb, 0x25, 0x6d, 0x49,
0x58, 0xea, 0xee, 0x9f, 0x7f, 0xd2, 0xfb, 0x0f, 0xbf, 0x5e, 0x44, 0xf5, 0xac, 0xb7, 0x4b, 0xaa,
0xb5, 0x36, 0xeb, 0x4e, 0x23, 0x0a, 0xa3, 0xe8, 0xcf, 0x75, 0xa7, 0xe1, 0xa5, 0x6b, 0x33, 0x5f,
0xa1, 0x2f, 0xa0, 0x71, 0xf3, 0xda, 0x71, 0xe7, 0x9c, 0x7a, 0xad, 0x32, 0xae, 0x74, 0x9b, 0xe7,
0x1f, 0xdd, 0xe9, 0x6e, 0xe6, 0x08, 0xfa, 0x1c, 0x76, 0x7d, 0xc1, 0x1d, 0xcf, 0x9e, 0xfd, 0x40,
0xdc, 0x15, 0x6d, 0x55, 0xb0, 0xd4, 0x95, 0xb5, 0x83, 0xcd, 0xba, 0xd3, 0x9c, 0xc6, 0xf9, 0x6f,
0xa2, 0xf4, 0x75, 0xc9, 0x6c, 0xfa, 0x45, 0x88, 0xce, 0x00, 0x5e, 0x31, 0xe6, 0xa6, 0x4c, 0x15,
0x4b, 0xdd, 0x86, 0xa6, 0x6c, 0xd6, 0x9d, 0x5d, 0x8d, 0x31, 0x97, 0x12, 0x2f, 0x83, 0xe4, 0x48,
0x95, 0x20, 0x4f, 0x40, 0x76, 0x3c, 0x91, 0x12, 0x35, 0x2c, 0x75, 0x2b, 0x09, 0x31, 0xf4, 0x04,
0xb5, 0x29, 0xcf, 0x88, 0x86, 0xe3, 0x89, 0x04, 0x38, 0x07, 0x58, 0x15, 0xc4, 0x0e, 0x96, 0xba,
0x55, 0xed, 0xde, 0x66, 0xdd, 0xd9, 0x7b, 0xee, 0xf9, 0x8e, 0xed, 0xd1, 0x79, 0x7e, 0xc8, 0x2a,
0x67, 0xce, 0xa0, 0xb9, 0x70, 0x19, 0xc9, 0xa0, 0x3a, 0x96, 0xba, 0x92, 0xb6, 0xbf, 0x59, 0x77,
0xe0, 0x2a, 0x4a, 0x67, 0x04, 0x2c, 0xf2, 0x28, 0x42, 0x38, 0xb5, 0xe9, 0x6d, 0x8a, 0x34, 0xe2,
0xfb, 0xc7, 0x88, 0x19, 0xa5, 0x73, 0x84, 0xe7, 0x11, 0xba, 0x80, 0x3d, 0x41, 0xec, 0x19, 0xa7,
0x8b, 0x14, 0x92, 0x8b, 0xa6, 0x59, 0xc4, 0x36, 0xe9, 0x22, 0x6f, 0x9a, 0x28, 0x42, 0xf4, 0x14,
0x0e, 0x16, 0x0e, 0x75, 0xe7, 0x5b, 0x20, 0xc4, 0x60, 0x7c, 0xab, 0xab, 0x68, 0x6b, 0x0b, 0xdd,
0x5b, 0x6c, 0x27, 0x90, 0x0e, 0x75, 0x97, 0xd9, 0xce, 0x0d, 0x71, 0x5b, 0xcd, 0x78, 0x86, 0x1e,
0xdf, 0x3d, 0x43, 0x46, 0x02, 0x5c, 0x97, 0xcc, 0x8c, 0x45, 0x23, 0x80, 0x1b, 0xf6, 0x66, 0x49,
0xb8, 0xe3, 0x33, 0xaf, 0xb5, 0x1b, 0x3b, 0x7d, 0x7a, 0xb7, 0xd3, 0x65, 0xce, 0x44, 0xad, 0x28,
0x1c, 0x4e, 0xdf, 0x95, 0xa1, 0x1a, 0x8f, 0xe1, 0x05, 0x20, 0x63, 0x3c, 0x18, 0x5e, 0xf6, 0x8d,
0x99, 0xfe, 0x72, 0x62, 0xea, 0xd3, 0xe9, 0x70, 0x3c, 0x52, 0x4a, 0xea, 0xc3, 0x20, 0xc4, 0x1f,
0x64, 0x23, 0x9c, 0x16, 0xa4, 0xdf, 0x2e, 0x39, 0xf5, 0x7d, 0x87, 0x79, 0xe8, 0x29, 0x1c, 0x5d,
0x8e, 0xbf, 0x9a, 0xf4, 0xcd, 0xe1, 0x74, 0x3c, 0xda, 0x26, 0x25, 0x15, 0x07, 0x21, 0xfe, 0x30,
0x23, 0x8b, 0x02, 0xb6, 0xe0, 0x33, 0x50, 0x26, 0x7d, 0x53, 0x7f, 0x8f, 0x2b, 0xab, 0x27, 0x41,
0x88, 0x8f, 0x33, 0x6e, 0x42, 0x38, 0xdd, 0x46, 0x3a, 0x50, 0xb7, 0xfa, 0x83, 0x99, 0xa9, 0x5f,
0x29, 0x15, 0x15, 0x05, 0x21, 0xde, 0xcf, 0x94, 0xc9, 0x87, 0x43, 0x18, 0xea, 0xc6, 0xd0, 0xd2,
0xcd, 0xbe, 0xa1, 0x54, 0xd5, 0xfb, 0x41, 0x88, 0x0f, 0xf2, 0xe2, 0x1d, 0x41, 0x39, 0x71, 0xd1,
0x23, 0x90, 0xaf, 0x86, 0xba, 0xf1, 0x2c, 0x36, 0xa9, 0xa9, 0x87, 0x41, 0x88, 0x95, 0x4c, 0x93,
0x7d, 0x44, 0xb5, 0xfa, 0xe3, 0xcf, 0xed, 0xd2, 0xe9, 0xaf, 0x65, 0x80, 0xa2, 0x72, 0xd4, 0x86,
0x9a, 0xfe, 0xf5, 0xf3, 0xbe, 0xa1, 0x94, 0x12, 0xe7, 0xad, 0x4b, 0x7d, 0xbf, 0x22, 0x2e, 0xfa,
0x18, 0xe4, 0xd1, 0xd8, 0x9a, 0x25, 0x1a, 0x49, 0x7d, 0x10, 0x84, 0x18, 0x15, 0x9a, 0x11, 0x13,
0x89, 0xec, 0x31, 0x34, 0xa7, 0x56, 0xdf, 0xb4, 0xa6, 0xb3, 0x17, 0x43, 0xeb, 0x5a, 0x29, 0xab,
0xad, 0x20, 0xc4, 0x87, 0x85, 0x70, 0x2a, 0x08, 0x17, 0xfe, 0x0b, 0x47, 0xbc, 0x8e, 0x4e, 0x34,
0xf5, 0x81, 0xfe, 0x52, 0xa9, 0xfc, 0xfd, 0xc4, 0x78, 0xb8, 0xb3, 0x13, 0x13, 0x4d, 0xf5, 0x5f,
0x4e, 0x4c, 0x64, 0x2a, 0x94, 0x0d, 0x4b, 0xa9, 0x25, 0x0d, 0x2b, 0xf6, 0x0d, 0xea, 0xfb, 0x08,
0x43, 0xc5, 0xb0, 0x74, 0x65, 0x47, 0x3d, 0x0e, 0x42, 0x7c, 0xff, 0xfd, 0xcd, 0xa4, 0xde, 0x87,
0x50, 0x1e, 0x58, 0x4a, 0x5d, 0x3d, 0x0a, 0x42, 0x7c, 0xaf, 0x10, 0x0c, 0x38, 0x25, 0x82, 0x72,
0xf4, 0x08, 0x2a, 0x03, 0x4b, 0x57, 0x1a, 0xaa, 0x1a, 0x84, 0xf8, 0xc1, 0x3f, 0xf6, 0x63, 0x8f,
0xb4, 0x9f, 0x5f, 0x42, 0x3d, 0x1d, 0x21, 0x74, 0x0c, 0x95, 0xfe, 0xe8, 0x99, 0x52, 0x52, 0xf7,
0x83, 0x10, 0x43, 0x9a, 0xed, 0x7b, 0x73, 0x74, 0x04, 0xe5, 0xb1, 0xa9, 0x48, 0xea, 0x5e, 0x10,
0x62, 0x39, 0xcd, 0x8f, 0x79, 0x62, 0xa0, 0xd5, 0xa1, 0x16, 0xff, 0xf0, 0x4e, 0x35, 0x90, 0x27,
0xd9, 0x1b, 0x8f, 0x2e, 0xa0, 0xca, 0x19, 0x13, 0xf1, 0xe3, 0xfc, 0xbf, 0x9e, 0xcf, 0x58, 0xae,
0x9d, 0xfc, 0xb2, 0x69, 0x4b, 0xbf, 0x6d, 0xda, 0xd2, 0xef, 0x9b, 0xb6, 0xf4, 0xd3, 0x1f, 0xed,
0xd2, 0xb7, 0x72, 0xc4, 0x44, 0xef, 0xbc, 0xff, 0x6a, 0x27, 0xfe, 0x17, 0xf8, 0xec, 0xaf, 0x00,
0x00, 0x00, 0xff, 0xff, 0xef, 0xb8, 0x31, 0xd8, 0x4b, 0x06, 0x00, 0x00,
}

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

File diff suppressed because it is too large Load Diff

192
task/backend/meta.pb.go
View File

@ -3,12 +3,13 @@
package backend
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import io "io"
import (
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
@ -47,7 +48,7 @@ func (m *StoreTaskMeta) Reset() { *m = StoreTaskMeta{} }
func (m *StoreTaskMeta) String() string { return proto.CompactTextString(m) }
func (*StoreTaskMeta) ProtoMessage() {}
func (*StoreTaskMeta) Descriptor() ([]byte, []int) {
return fileDescriptor_meta_b8385560be3db2c8, []int{0}
return fileDescriptor_3b5ea8fe65782bcc, []int{0}
}
func (m *StoreTaskMeta) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -64,8 +65,8 @@ func (m *StoreTaskMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return b[:n], nil
}
}
func (dst *StoreTaskMeta) XXX_Merge(src proto.Message) {
xxx_messageInfo_StoreTaskMeta.Merge(dst, src)
func (m *StoreTaskMeta) XXX_Merge(src proto.Message) {
xxx_messageInfo_StoreTaskMeta.Merge(m, src)
}
func (m *StoreTaskMeta) XXX_Size() int {
return m.Size()
@ -164,7 +165,7 @@ func (m *StoreTaskMetaRun) Reset() { *m = StoreTaskMetaRun{} }
func (m *StoreTaskMetaRun) String() string { return proto.CompactTextString(m) }
func (*StoreTaskMetaRun) ProtoMessage() {}
func (*StoreTaskMetaRun) Descriptor() ([]byte, []int) {
return fileDescriptor_meta_b8385560be3db2c8, []int{1}
return fileDescriptor_3b5ea8fe65782bcc, []int{1}
}
func (m *StoreTaskMetaRun) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -181,8 +182,8 @@ func (m *StoreTaskMetaRun) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
return b[:n], nil
}
}
func (dst *StoreTaskMetaRun) XXX_Merge(src proto.Message) {
xxx_messageInfo_StoreTaskMetaRun.Merge(dst, src)
func (m *StoreTaskMetaRun) XXX_Merge(src proto.Message) {
xxx_messageInfo_StoreTaskMetaRun.Merge(m, src)
}
func (m *StoreTaskMetaRun) XXX_Size() int {
return m.Size()
@ -254,7 +255,7 @@ func (m *StoreTaskMetaManualRun) Reset() { *m = StoreTaskMetaManualRun{}
func (m *StoreTaskMetaManualRun) String() string { return proto.CompactTextString(m) }
func (*StoreTaskMetaManualRun) ProtoMessage() {}
func (*StoreTaskMetaManualRun) Descriptor() ([]byte, []int) {
return fileDescriptor_meta_b8385560be3db2c8, []int{2}
return fileDescriptor_3b5ea8fe65782bcc, []int{2}
}
func (m *StoreTaskMetaManualRun) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -271,8 +272,8 @@ func (m *StoreTaskMetaManualRun) XXX_Marshal(b []byte, deterministic bool) ([]by
return b[:n], nil
}
}
func (dst *StoreTaskMetaManualRun) XXX_Merge(src proto.Message) {
xxx_messageInfo_StoreTaskMetaManualRun.Merge(dst, src)
func (m *StoreTaskMetaManualRun) XXX_Merge(src proto.Message) {
xxx_messageInfo_StoreTaskMetaManualRun.Merge(m, src)
}
func (m *StoreTaskMetaManualRun) XXX_Size() int {
return m.Size()
@ -323,6 +324,47 @@ func init() {
proto.RegisterType((*StoreTaskMetaRun)(nil), "com.influxdata.platform.task.backend.StoreTaskMetaRun")
proto.RegisterType((*StoreTaskMetaManualRun)(nil), "com.influxdata.platform.task.backend.StoreTaskMetaManualRun")
}
func init() { proto.RegisterFile("meta.proto", fileDescriptor_3b5ea8fe65782bcc) }
var fileDescriptor_3b5ea8fe65782bcc = []byte{
// 544 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0xc1, 0x6e, 0xd3, 0x4c,
0x10, 0xae, 0x7f, 0xc7, 0x69, 0xb3, 0xf9, 0xd3, 0x98, 0xa5, 0xaa, 0x2c, 0x10, 0x8e, 0x1b, 0x81,
0x08, 0x17, 0x23, 0x81, 0xc4, 0x09, 0x21, 0xa5, 0x81, 0x43, 0x0f, 0xbd, 0x6c, 0x39, 0x21, 0x21,
0x6b, 0x6b, 0xaf, 0x83, 0x15, 0x7b, 0x37, 0xac, 0x67, 0x21, 0xe1, 0x29, 0x78, 0x14, 0xae, 0xbc,
0x01, 0xc7, 0x1e, 0x39, 0x55, 0x28, 0x79, 0x0d, 0x0e, 0x68, 0x77, 0x93, 0xd0, 0x96, 0x1c, 0x10,
0xb7, 0x99, 0x6f, 0x76, 0x67, 0xbf, 0xef, 0x9b, 0x59, 0x84, 0x2a, 0x06, 0x34, 0x9e, 0x4a, 0x01,
0x02, 0xdf, 0x4f, 0x45, 0x15, 0x17, 0x3c, 0x2f, 0xd5, 0x2c, 0xa3, 0x1a, 0x2d, 0x29, 0xe4, 0x42,
0x56, 0x31, 0xd0, 0x7a, 0x12, 0x9f, 0xd3, 0x74, 0xc2, 0x78, 0x76, 0xe7, 0x60, 0x2c, 0xc6, 0xc2,
0x5c, 0x78, 0xac, 0x23, 0x7b, 0xb7, 0xff, 0xd3, 0x45, 0x9d, 0x33, 0x10, 0x92, 0xbd, 0xa6, 0xf5,
0xe4, 0x94, 0x01, 0xc5, 0x0f, 0x51, 0xb7, 0xa2, 0xb3, 0x24, 0x15, 0x3c, 0x55, 0x52, 0x32, 0x9e,
0xce, 0x03, 0x27, 0x72, 0x06, 0x1e, 0xd9, 0xaf, 0xe8, 0x6c, 0xf4, 0x1b, 0xc5, 0x8f, 0x90, 0x5f,
0x52, 0x60, 0x35, 0x24, 0xa9, 0xa8, 0xa6, 0x25, 0x03, 0x96, 0x05, 0xff, 0x45, 0xce, 0xc0, 0x25,
0x5d, 0x8b, 0x8f, 0xd6, 0x30, 0x3e, 0x44, 0xcd, 0x1a, 0x28, 0xa8, 0x3a, 0x70, 0x23, 0x67, 0xd0,
0x22, 0xab, 0x0c, 0xa7, 0xe8, 0x96, 0x6d, 0x07, 0xe5, 0x3c, 0x91, 0x8a, 0xf3, 0x82, 0x8f, 0x83,
0x46, 0xe4, 0x0e, 0xda, 0x4f, 0x9e, 0xc5, 0x7f, 0xa3, 0x2a, 0xbe, 0xc6, 0x9d, 0x28, 0x4e, 0xfc,
0x4d, 0x43, 0x62, 0xfb, 0xe1, 0x07, 0x68, 0x9f, 0xe5, 0x39, 0x4b, 0xa1, 0xf8, 0xc0, 0x92, 0x54,
0x0a, 0x1e, 0x78, 0x86, 0x44, 0x67, 0x83, 0x8e, 0xa4, 0xe0, 0x9a, 0xa3, 0xc8, 0xf3, 0x9a, 0x41,
0xd0, 0xb4, 0x1c, 0x6d, 0x86, 0xef, 0x21, 0x94, 0x4a, 0x46, 0x81, 0x65, 0x09, 0x85, 0x60, 0xd7,
0x08, 0x6c, 0xad, 0x90, 0xa1, 0x29, 0xab, 0x69, 0xb6, 0x2e, 0xef, 0xd9, 0xf2, 0x0a, 0x19, 0x02,
0x7e, 0x81, 0x7c, 0xaa, 0xe0, 0x9d, 0x90, 0xc5, 0x27, 0x0a, 0x85, 0xe0, 0x49, 0x91, 0x05, 0xad,
0xc8, 0x19, 0x34, 0x8e, 0x6f, 0x2f, 0x2e, 0x7b, 0xdd, 0xe1, 0xd5, 0xda, 0xc9, 0x4b, 0xd2, 0xbd,
0x76, 0xf8, 0x24, 0xc3, 0x6f, 0x51, 0xbb, 0xa2, 0x5c, 0xd1, 0x52, 0xdb, 0x53, 0x07, 0xbe, 0xf1,
0xe6, 0xf9, 0x3f, 0x78, 0x73, 0x6a, 0xba, 0x68, 0x87, 0x50, 0xb5, 0x0e, 0xeb, 0xfe, 0x57, 0x07,
0xf9, 0x37, 0x2d, 0xc4, 0x3e, 0x72, 0xb9, 0xf8, 0x68, 0xa6, 0xee, 0x12, 0x1d, 0x6a, 0x04, 0xe4,
0xdc, 0x4c, 0xb7, 0x43, 0x74, 0x88, 0x23, 0xd4, 0x94, 0xca, 0xa8, 0x71, 0x8d, 0x9a, 0xd6, 0xe2,
0xb2, 0xe7, 0x11, 0xa5, 0x35, 0x78, 0x52, 0x69, 0xe6, 0x3d, 0xd4, 0x96, 0x94, 0x8f, 0x59, 0x52,
0x03, 0x95, 0x10, 0x34, 0x4c, 0x37, 0x64, 0xa0, 0x33, 0x8d, 0xe0, 0xbb, 0xa8, 0x65, 0x0f, 0x30,
0x9e, 0x99, 0x91, 0xb8, 0x64, 0xcf, 0x00, 0xaf, 0x78, 0x86, 0x8f, 0xd0, 0xff, 0x92, 0xbd, 0x57,
0xac, 0x5e, 0x19, 0xdb, 0x34, 0xf5, 0xf6, 0x06, 0x1b, 0x42, 0xff, 0x8b, 0x83, 0x0e, 0xb7, 0x4b,
0xc4, 0x07, 0xc8, 0xb3, 0xaf, 0x5a, 0x0d, 0x36, 0xd1, 0x2a, 0xf4, 0x53, 0x76, 0x47, 0x75, 0xb8,
0x75, 0x85, 0xdd, 0xed, 0x2b, 0x7c, 0x93, 0x50, 0xe3, 0x0f, 0x42, 0x57, 0x3c, 0xf1, 0xb6, 0x7b,
0x72, 0x7c, 0xf4, 0x6d, 0x11, 0x3a, 0x17, 0x8b, 0xd0, 0xf9, 0xb1, 0x08, 0x9d, 0xcf, 0xcb, 0x70,
0xe7, 0x62, 0x19, 0xee, 0x7c, 0x5f, 0x86, 0x3b, 0x6f, 0x76, 0x57, 0x43, 0x3b, 0x6f, 0x9a, 0x7f,
0xf9, 0xf4, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0xca, 0x64, 0xf6, 0x93, 0xe1, 0x03, 0x00, 0x00,
}
func (m *StoreTaskMeta) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -637,7 +679,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -665,7 +707,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.MaxConcurrency |= (int32(b) & 0x7F) << shift
m.MaxConcurrency |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
@ -684,7 +726,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.LatestCompleted |= (int64(b) & 0x7F) << shift
m.LatestCompleted |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -703,7 +745,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -713,6 +755,9 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthMeta
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthMeta
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -732,7 +777,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
@ -741,6 +786,9 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthMeta
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthMeta
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -763,7 +811,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -773,6 +821,9 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthMeta
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthMeta
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -792,7 +843,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -802,6 +853,9 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthMeta
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthMeta
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -821,7 +875,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.CreatedAt |= (int64(b) & 0x7F) << shift
m.CreatedAt |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -840,7 +894,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.UpdatedAt |= (int64(b) & 0x7F) << shift
m.UpdatedAt |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -859,7 +913,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.AuthorizationID |= (uint64(b) & 0x7F) << shift
m.AuthorizationID |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -878,7 +932,7 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
@ -887,6 +941,9 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthMeta
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthMeta
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
@ -904,6 +961,9 @@ func (m *StoreTaskMeta) Unmarshal(dAtA []byte) error {
if skippy < 0 {
return ErrInvalidLengthMeta
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthMeta
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
@ -931,7 +991,7 @@ func (m *StoreTaskMetaRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -959,7 +1019,7 @@ func (m *StoreTaskMetaRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.Now |= (int64(b) & 0x7F) << shift
m.Now |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -978,7 +1038,7 @@ func (m *StoreTaskMetaRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.Try |= (uint32(b) & 0x7F) << shift
m.Try |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
@ -997,7 +1057,7 @@ func (m *StoreTaskMetaRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.RunID |= (uint64(b) & 0x7F) << shift
m.RunID |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1016,7 +1076,7 @@ func (m *StoreTaskMetaRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.RangeStart |= (int64(b) & 0x7F) << shift
m.RangeStart |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1035,7 +1095,7 @@ func (m *StoreTaskMetaRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.RangeEnd |= (int64(b) & 0x7F) << shift
m.RangeEnd |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1054,7 +1114,7 @@ func (m *StoreTaskMetaRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.RequestedAt |= (int64(b) & 0x7F) << shift
m.RequestedAt |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1068,6 +1128,9 @@ func (m *StoreTaskMetaRun) Unmarshal(dAtA []byte) error {
if skippy < 0 {
return ErrInvalidLengthMeta
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthMeta
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
@ -1095,7 +1158,7 @@ func (m *StoreTaskMetaManualRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1123,7 +1186,7 @@ func (m *StoreTaskMetaManualRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.Start |= (int64(b) & 0x7F) << shift
m.Start |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1142,7 +1205,7 @@ func (m *StoreTaskMetaManualRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.End |= (int64(b) & 0x7F) << shift
m.End |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1161,7 +1224,7 @@ func (m *StoreTaskMetaManualRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.LatestCompleted |= (int64(b) & 0x7F) << shift
m.LatestCompleted |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1180,7 +1243,7 @@ func (m *StoreTaskMetaManualRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.RequestedAt |= (int64(b) & 0x7F) << shift
m.RequestedAt |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1199,7 +1262,7 @@ func (m *StoreTaskMetaManualRun) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.RunID |= (uint64(b) & 0x7F) << shift
m.RunID |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1213,6 +1276,9 @@ func (m *StoreTaskMetaManualRun) Unmarshal(dAtA []byte) error {
if skippy < 0 {
return ErrInvalidLengthMeta
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthMeta
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
@ -1279,10 +1345,13 @@ func skipMeta(dAtA []byte) (n int, err error) {
break
}
}
iNdEx += length
if length < 0 {
return 0, ErrInvalidLengthMeta
}
iNdEx += length
if iNdEx < 0 {
return 0, ErrInvalidLengthMeta
}
return iNdEx, nil
case 3:
for {
@ -1311,6 +1380,9 @@ func skipMeta(dAtA []byte) (n int, err error) {
return 0, err
}
iNdEx = start + next
if iNdEx < 0 {
return 0, ErrInvalidLengthMeta
}
}
return iNdEx, nil
case 4:
@ -1329,43 +1401,3 @@ var (
ErrInvalidLengthMeta = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowMeta = fmt.Errorf("proto: integer overflow")
)
func init() { proto.RegisterFile("meta.proto", fileDescriptor_meta_b8385560be3db2c8) }
var fileDescriptor_meta_b8385560be3db2c8 = []byte{
// 544 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0xc1, 0x6e, 0xd3, 0x4c,
0x10, 0xae, 0x7f, 0xc7, 0x69, 0xb3, 0xf9, 0xd3, 0x98, 0xa5, 0xaa, 0x2c, 0x10, 0x8e, 0x1b, 0x81,
0x08, 0x17, 0x23, 0x81, 0xc4, 0x09, 0x21, 0xa5, 0x81, 0x43, 0x0f, 0xbd, 0x6c, 0x39, 0x21, 0x21,
0x6b, 0x6b, 0xaf, 0x83, 0x15, 0x7b, 0x37, 0xac, 0x67, 0x21, 0xe1, 0x29, 0x78, 0x14, 0xae, 0xbc,
0x01, 0xc7, 0x1e, 0x39, 0x55, 0x28, 0x79, 0x0d, 0x0e, 0x68, 0x77, 0x93, 0xd0, 0x96, 0x1c, 0x10,
0xb7, 0x99, 0x6f, 0x76, 0x67, 0xbf, 0xef, 0x9b, 0x59, 0x84, 0x2a, 0x06, 0x34, 0x9e, 0x4a, 0x01,
0x02, 0xdf, 0x4f, 0x45, 0x15, 0x17, 0x3c, 0x2f, 0xd5, 0x2c, 0xa3, 0x1a, 0x2d, 0x29, 0xe4, 0x42,
0x56, 0x31, 0xd0, 0x7a, 0x12, 0x9f, 0xd3, 0x74, 0xc2, 0x78, 0x76, 0xe7, 0x60, 0x2c, 0xc6, 0xc2,
0x5c, 0x78, 0xac, 0x23, 0x7b, 0xb7, 0xff, 0xd3, 0x45, 0x9d, 0x33, 0x10, 0x92, 0xbd, 0xa6, 0xf5,
0xe4, 0x94, 0x01, 0xc5, 0x0f, 0x51, 0xb7, 0xa2, 0xb3, 0x24, 0x15, 0x3c, 0x55, 0x52, 0x32, 0x9e,
0xce, 0x03, 0x27, 0x72, 0x06, 0x1e, 0xd9, 0xaf, 0xe8, 0x6c, 0xf4, 0x1b, 0xc5, 0x8f, 0x90, 0x5f,
0x52, 0x60, 0x35, 0x24, 0xa9, 0xa8, 0xa6, 0x25, 0x03, 0x96, 0x05, 0xff, 0x45, 0xce, 0xc0, 0x25,
0x5d, 0x8b, 0x8f, 0xd6, 0x30, 0x3e, 0x44, 0xcd, 0x1a, 0x28, 0xa8, 0x3a, 0x70, 0x23, 0x67, 0xd0,
0x22, 0xab, 0x0c, 0xa7, 0xe8, 0x96, 0x6d, 0x07, 0xe5, 0x3c, 0x91, 0x8a, 0xf3, 0x82, 0x8f, 0x83,
0x46, 0xe4, 0x0e, 0xda, 0x4f, 0x9e, 0xc5, 0x7f, 0xa3, 0x2a, 0xbe, 0xc6, 0x9d, 0x28, 0x4e, 0xfc,
0x4d, 0x43, 0x62, 0xfb, 0xe1, 0x07, 0x68, 0x9f, 0xe5, 0x39, 0x4b, 0xa1, 0xf8, 0xc0, 0x92, 0x54,
0x0a, 0x1e, 0x78, 0x86, 0x44, 0x67, 0x83, 0x8e, 0xa4, 0xe0, 0x9a, 0xa3, 0xc8, 0xf3, 0x9a, 0x41,
0xd0, 0xb4, 0x1c, 0x6d, 0x86, 0xef, 0x21, 0x94, 0x4a, 0x46, 0x81, 0x65, 0x09, 0x85, 0x60, 0xd7,
0x08, 0x6c, 0xad, 0x90, 0xa1, 0x29, 0xab, 0x69, 0xb6, 0x2e, 0xef, 0xd9, 0xf2, 0x0a, 0x19, 0x02,
0x7e, 0x81, 0x7c, 0xaa, 0xe0, 0x9d, 0x90, 0xc5, 0x27, 0x0a, 0x85, 0xe0, 0x49, 0x91, 0x05, 0xad,
0xc8, 0x19, 0x34, 0x8e, 0x6f, 0x2f, 0x2e, 0x7b, 0xdd, 0xe1, 0xd5, 0xda, 0xc9, 0x4b, 0xd2, 0xbd,
0x76, 0xf8, 0x24, 0xc3, 0x6f, 0x51, 0xbb, 0xa2, 0x5c, 0xd1, 0x52, 0xdb, 0x53, 0x07, 0xbe, 0xf1,
0xe6, 0xf9, 0x3f, 0x78, 0x73, 0x6a, 0xba, 0x68, 0x87, 0x50, 0xb5, 0x0e, 0xeb, 0xfe, 0x57, 0x07,
0xf9, 0x37, 0x2d, 0xc4, 0x3e, 0x72, 0xb9, 0xf8, 0x68, 0xa6, 0xee, 0x12, 0x1d, 0x6a, 0x04, 0xe4,
0xdc, 0x4c, 0xb7, 0x43, 0x74, 0x88, 0x23, 0xd4, 0x94, 0xca, 0xa8, 0x71, 0x8d, 0x9a, 0xd6, 0xe2,
0xb2, 0xe7, 0x11, 0xa5, 0x35, 0x78, 0x52, 0x69, 0xe6, 0x3d, 0xd4, 0x96, 0x94, 0x8f, 0x59, 0x52,
0x03, 0x95, 0x10, 0x34, 0x4c, 0x37, 0x64, 0xa0, 0x33, 0x8d, 0xe0, 0xbb, 0xa8, 0x65, 0x0f, 0x30,
0x9e, 0x99, 0x91, 0xb8, 0x64, 0xcf, 0x00, 0xaf, 0x78, 0x86, 0x8f, 0xd0, 0xff, 0x92, 0xbd, 0x57,
0xac, 0x5e, 0x19, 0xdb, 0x34, 0xf5, 0xf6, 0x06, 0x1b, 0x42, 0xff, 0x8b, 0x83, 0x0e, 0xb7, 0x4b,
0xc4, 0x07, 0xc8, 0xb3, 0xaf, 0x5a, 0x0d, 0x36, 0xd1, 0x2a, 0xf4, 0x53, 0x76, 0x47, 0x75, 0xb8,
0x75, 0x85, 0xdd, 0xed, 0x2b, 0x7c, 0x93, 0x50, 0xe3, 0x0f, 0x42, 0x57, 0x3c, 0xf1, 0xb6, 0x7b,
0x72, 0x7c, 0xf4, 0x6d, 0x11, 0x3a, 0x17, 0x8b, 0xd0, 0xf9, 0xb1, 0x08, 0x9d, 0xcf, 0xcb, 0x70,
0xe7, 0x62, 0x19, 0xee, 0x7c, 0x5f, 0x86, 0x3b, 0x6f, 0x76, 0x57, 0x43, 0x3b, 0x6f, 0x9a, 0x7f,
0xf9, 0xf4, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0xca, 0x64, 0xf6, 0x93, 0xe1, 0x03, 0x00, 0x00,
}