2315 lines
57 KiB
Go
Generated
2315 lines
57 KiB
Go
Generated
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
|
// source: v2/netmap/grpc/types.proto
|
|
|
|
package netmap
|
|
|
|
import (
|
|
fmt "fmt"
|
|
proto "github.com/golang/protobuf/proto"
|
|
io "io"
|
|
math "math"
|
|
math_bits "math/bits"
|
|
)
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
|
|
// 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.ProtoPackageIsVersion3 // please upgrade the proto package
|
|
|
|
// Operations on filters
|
|
type Operation int32
|
|
|
|
const (
|
|
// No Operation defined
|
|
Operation_OPERATION_UNSPECIFIED Operation = 0
|
|
// Equal
|
|
Operation_EQ Operation = 1
|
|
// Not Equal
|
|
Operation_NE Operation = 2
|
|
// Greater then
|
|
Operation_GT Operation = 3
|
|
// Greater or equal
|
|
Operation_GE Operation = 4
|
|
// Less then
|
|
Operation_LT Operation = 5
|
|
// Less or equal
|
|
Operation_LE Operation = 6
|
|
// Logical OR
|
|
Operation_OR Operation = 7
|
|
// Logical AND
|
|
Operation_AND Operation = 8
|
|
)
|
|
|
|
var Operation_name = map[int32]string{
|
|
0: "OPERATION_UNSPECIFIED",
|
|
1: "EQ",
|
|
2: "NE",
|
|
3: "GT",
|
|
4: "GE",
|
|
5: "LT",
|
|
6: "LE",
|
|
7: "OR",
|
|
8: "AND",
|
|
}
|
|
|
|
var Operation_value = map[string]int32{
|
|
"OPERATION_UNSPECIFIED": 0,
|
|
"EQ": 1,
|
|
"NE": 2,
|
|
"GT": 3,
|
|
"GE": 4,
|
|
"LT": 5,
|
|
"LE": 6,
|
|
"OR": 7,
|
|
"AND": 8,
|
|
}
|
|
|
|
func (x Operation) String() string {
|
|
return proto.EnumName(Operation_name, int32(x))
|
|
}
|
|
|
|
func (Operation) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_91a1332b2376641a, []int{0}
|
|
}
|
|
|
|
// Selector modifier shows how the node set will be formed. By default selector
|
|
// just groups nodes into a bucket by attribute, selecting nodes only by their
|
|
// hash distance.
|
|
type Clause int32
|
|
|
|
const (
|
|
// No modifier defined. Will select nodes from bucket randomly.
|
|
Clause_CLAUSE_UNSPECIFIED Clause = 0
|
|
// SAME will select only nodes having the same value of bucket attribute
|
|
Clause_SAME Clause = 1
|
|
// DISTINCT will select nodes having different values of bucket attribute
|
|
Clause_DISTINCT Clause = 2
|
|
)
|
|
|
|
var Clause_name = map[int32]string{
|
|
0: "CLAUSE_UNSPECIFIED",
|
|
1: "SAME",
|
|
2: "DISTINCT",
|
|
}
|
|
|
|
var Clause_value = map[string]int32{
|
|
"CLAUSE_UNSPECIFIED": 0,
|
|
"SAME": 1,
|
|
"DISTINCT": 2,
|
|
}
|
|
|
|
func (x Clause) String() string {
|
|
return proto.EnumName(Clause_name, int32(x))
|
|
}
|
|
|
|
func (Clause) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_91a1332b2376641a, []int{1}
|
|
}
|
|
|
|
// Represents the enumeration of various states of the NeoFS node.
|
|
type NodeInfo_State int32
|
|
|
|
const (
|
|
// Unknown state.
|
|
NodeInfo_UNSPECIFIED NodeInfo_State = 0
|
|
// Active state in the network.
|
|
NodeInfo_ONLINE NodeInfo_State = 1
|
|
// Network unavailable state.
|
|
NodeInfo_OFFLINE NodeInfo_State = 2
|
|
)
|
|
|
|
var NodeInfo_State_name = map[int32]string{
|
|
0: "UNSPECIFIED",
|
|
1: "ONLINE",
|
|
2: "OFFLINE",
|
|
}
|
|
|
|
var NodeInfo_State_value = map[string]int32{
|
|
"UNSPECIFIED": 0,
|
|
"ONLINE": 1,
|
|
"OFFLINE": 2,
|
|
}
|
|
|
|
func (x NodeInfo_State) String() string {
|
|
return proto.EnumName(NodeInfo_State_name, int32(x))
|
|
}
|
|
|
|
func (NodeInfo_State) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_91a1332b2376641a, []int{4, 0}
|
|
}
|
|
|
|
// Filter will return the subset of nodes from `NetworkMap` or another filter's
|
|
// results, that will satisfy filter's conditions.
|
|
type Filter struct {
|
|
// Name of the filter or a reference to the named filter. '*' means
|
|
// application to the whole unfiltered NetworkMap. At top level it's used as a
|
|
// filter name. At lower levels it's considered to be a reference to another
|
|
// named filter
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
// Key to filter
|
|
Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
|
|
// Filtering operation
|
|
Op Operation `protobuf:"varint,3,opt,name=op,proto3,enum=neo.fs.v2.netmap.Operation" json:"op,omitempty"`
|
|
// Value to match
|
|
Value string `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
|
|
// List of inner filters. Top level operation will be applied to the whole
|
|
// list.
|
|
Filters []*Filter `protobuf:"bytes,5,rep,name=filters,proto3" json:"filters,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Filter) Reset() { *m = Filter{} }
|
|
func (m *Filter) String() string { return proto.CompactTextString(m) }
|
|
func (*Filter) ProtoMessage() {}
|
|
func (*Filter) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_91a1332b2376641a, []int{0}
|
|
}
|
|
func (m *Filter) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Filter.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 *Filter) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Filter.Merge(m, src)
|
|
}
|
|
func (m *Filter) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Filter) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Filter.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Filter proto.InternalMessageInfo
|
|
|
|
func (m *Filter) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Filter) GetKey() string {
|
|
if m != nil {
|
|
return m.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Filter) GetOp() Operation {
|
|
if m != nil {
|
|
return m.Op
|
|
}
|
|
return Operation_OPERATION_UNSPECIFIED
|
|
}
|
|
|
|
func (m *Filter) GetValue() string {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Filter) GetFilters() []*Filter {
|
|
if m != nil {
|
|
return m.Filters
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Selector chooses a number of nodes from the bucket taking the nearest nodes
|
|
// to the provided `ContainerID` by hash distance.
|
|
type Selector struct {
|
|
// Selector name to reference in object placement section
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
// How many nodes to select from the bucket
|
|
Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
|
|
// Selector modifier showing how to form a bucket
|
|
Clause Clause `protobuf:"varint,3,opt,name=clause,proto3,enum=neo.fs.v2.netmap.Clause" json:"clause,omitempty"`
|
|
// Attribute bucket to select from
|
|
Attribute string `protobuf:"bytes,4,opt,name=attribute,proto3" json:"attribute,omitempty"`
|
|
// Filter reference to select from
|
|
Filter string `protobuf:"bytes,5,opt,name=filter,proto3" json:"filter,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Selector) Reset() { *m = Selector{} }
|
|
func (m *Selector) String() string { return proto.CompactTextString(m) }
|
|
func (*Selector) ProtoMessage() {}
|
|
func (*Selector) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_91a1332b2376641a, []int{1}
|
|
}
|
|
func (m *Selector) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Selector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Selector.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 *Selector) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Selector.Merge(m, src)
|
|
}
|
|
func (m *Selector) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Selector) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Selector.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Selector proto.InternalMessageInfo
|
|
|
|
func (m *Selector) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Selector) GetCount() uint32 {
|
|
if m != nil {
|
|
return m.Count
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Selector) GetClause() Clause {
|
|
if m != nil {
|
|
return m.Clause
|
|
}
|
|
return Clause_CLAUSE_UNSPECIFIED
|
|
}
|
|
|
|
func (m *Selector) GetAttribute() string {
|
|
if m != nil {
|
|
return m.Attribute
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Selector) GetFilter() string {
|
|
if m != nil {
|
|
return m.Filter
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Number of object replicas in a set of nodes from the defined selector. If no
|
|
// selector set the root bucket containing all possible nodes will be used by
|
|
// default.
|
|
type Replica struct {
|
|
// How many object replicas to put
|
|
Count uint32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
|
|
// Named selector bucket to put replicas
|
|
Selector string `protobuf:"bytes,2,opt,name=selector,proto3" json:"selector,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Replica) Reset() { *m = Replica{} }
|
|
func (m *Replica) String() string { return proto.CompactTextString(m) }
|
|
func (*Replica) ProtoMessage() {}
|
|
func (*Replica) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_91a1332b2376641a, []int{2}
|
|
}
|
|
func (m *Replica) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Replica) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Replica.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 *Replica) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Replica.Merge(m, src)
|
|
}
|
|
func (m *Replica) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Replica) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Replica.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Replica proto.InternalMessageInfo
|
|
|
|
func (m *Replica) GetCount() uint32 {
|
|
if m != nil {
|
|
return m.Count
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Replica) GetSelector() string {
|
|
if m != nil {
|
|
return m.Selector
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Set of rules to select a subset of nodes from `NetworkMap` able to store
|
|
// container's objects. The format is simple enough to transpile from different
|
|
// storage policy definition languages.
|
|
type PlacementPolicy struct {
|
|
// Rules to set number of object replicas and place each one into a named
|
|
// bucket
|
|
Replicas []*Replica `protobuf:"bytes,1,rep,name=replicas,proto3" json:"replicas,omitempty"`
|
|
// Container backup factor controls how deep NeoFS will search for nodes
|
|
// alternatives to include into container's nodes subset
|
|
ContainerBackupFactor uint32 `protobuf:"varint,2,opt,name=container_backup_factor,json=containerBackupFactor,proto3" json:"container_backup_factor,omitempty"`
|
|
// Set of Selectors to form the container's nodes subset
|
|
Selectors []*Selector `protobuf:"bytes,3,rep,name=selectors,proto3" json:"selectors,omitempty"`
|
|
// List of named filters to reference in selectors
|
|
Filters []*Filter `protobuf:"bytes,4,rep,name=filters,proto3" json:"filters,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PlacementPolicy) Reset() { *m = PlacementPolicy{} }
|
|
func (m *PlacementPolicy) String() string { return proto.CompactTextString(m) }
|
|
func (*PlacementPolicy) ProtoMessage() {}
|
|
func (*PlacementPolicy) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_91a1332b2376641a, []int{3}
|
|
}
|
|
func (m *PlacementPolicy) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *PlacementPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_PlacementPolicy.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 *PlacementPolicy) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PlacementPolicy.Merge(m, src)
|
|
}
|
|
func (m *PlacementPolicy) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *PlacementPolicy) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PlacementPolicy.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PlacementPolicy proto.InternalMessageInfo
|
|
|
|
func (m *PlacementPolicy) GetReplicas() []*Replica {
|
|
if m != nil {
|
|
return m.Replicas
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PlacementPolicy) GetContainerBackupFactor() uint32 {
|
|
if m != nil {
|
|
return m.ContainerBackupFactor
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *PlacementPolicy) GetSelectors() []*Selector {
|
|
if m != nil {
|
|
return m.Selectors
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PlacementPolicy) GetFilters() []*Filter {
|
|
if m != nil {
|
|
return m.Filters
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// NeoFS node description
|
|
type NodeInfo struct {
|
|
// Public key of the NeoFS node in a binary format.
|
|
PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
|
|
// Ways to connect to a node
|
|
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
|
|
// Carries list of the NeoFS node attributes in a string key-value format.
|
|
Attributes []*NodeInfo_Attribute `protobuf:"bytes,3,rep,name=attributes,proto3" json:"attributes,omitempty"`
|
|
// Carries state of the NeoFS node.
|
|
State NodeInfo_State `protobuf:"varint,4,opt,name=state,proto3,enum=neo.fs.v2.netmap.NodeInfo_State" json:"state,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *NodeInfo) Reset() { *m = NodeInfo{} }
|
|
func (m *NodeInfo) String() string { return proto.CompactTextString(m) }
|
|
func (*NodeInfo) ProtoMessage() {}
|
|
func (*NodeInfo) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_91a1332b2376641a, []int{4}
|
|
}
|
|
func (m *NodeInfo) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *NodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_NodeInfo.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 *NodeInfo) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_NodeInfo.Merge(m, src)
|
|
}
|
|
func (m *NodeInfo) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *NodeInfo) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_NodeInfo.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_NodeInfo proto.InternalMessageInfo
|
|
|
|
func (m *NodeInfo) GetPublicKey() []byte {
|
|
if m != nil {
|
|
return m.PublicKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NodeInfo) GetAddress() string {
|
|
if m != nil {
|
|
return m.Address
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *NodeInfo) GetAttributes() []*NodeInfo_Attribute {
|
|
if m != nil {
|
|
return m.Attributes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NodeInfo) GetState() NodeInfo_State {
|
|
if m != nil {
|
|
return m.State
|
|
}
|
|
return NodeInfo_UNSPECIFIED
|
|
}
|
|
|
|
// Administrator-defined Attributes of the NeoFS Storage Node.
|
|
//
|
|
// Node's attributes are mostly used during Storage Policy evaluation to
|
|
// calculate object's placement and find a set of nodes satisfying policy
|
|
// requirements. There are some "well-known" node attributes common to all the
|
|
// Storage Nodes in the network and used implicitly with default values if not
|
|
// explicitly set:
|
|
//
|
|
// * Capacity \
|
|
// Total available disk space in Gigabytes.
|
|
// * Price \
|
|
// Price in GAS tokens for storing one GB of data during one Epoch. In node
|
|
// attributes it's a string presenting floating point number with comma or
|
|
// point delimiter for decimal part. In the Network Map it will be saved as
|
|
// 64-bit unsigned integer representing number of minimal token fractions.
|
|
// * Subnet \
|
|
// String ID of Node's storage subnet. There can be only one subnet served
|
|
// by the Storage Node.
|
|
// * Locode \
|
|
// Node's geographic location in
|
|
// [UN/LOCODE](https://www.unece.org/cefact/codesfortrade/codes_index.html)
|
|
// format approximated to the nearest point defined in standard.
|
|
// * Country \
|
|
// Country code in
|
|
// [ISO 3166-1_alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)
|
|
// format. Calculated automatically from `Locode` attribute
|
|
// * Region \
|
|
// Country's administative subdivision where node is located. Calculated
|
|
// automatically from `Locode` attribute based on `SubDiv` field. Presented
|
|
// in [ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2) format.
|
|
// * City \
|
|
// City, town, village or rural area name where node is located written
|
|
// without diacritics . Calculated automatically from `Locode` attribute.
|
|
//
|
|
// For detailed description of each well-known attribute please see the
|
|
// corresponding section in NeoFS Technical specification.
|
|
type NodeInfo_Attribute struct {
|
|
// Key of the node attribute.
|
|
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
// Value of the node attribute.
|
|
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
|
// Parent keys, if any. For example for `City` it could be `Region` and
|
|
// `Country`.
|
|
Parents []string `protobuf:"bytes,3,rep,name=parents,proto3" json:"parents,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *NodeInfo_Attribute) Reset() { *m = NodeInfo_Attribute{} }
|
|
func (m *NodeInfo_Attribute) String() string { return proto.CompactTextString(m) }
|
|
func (*NodeInfo_Attribute) ProtoMessage() {}
|
|
func (*NodeInfo_Attribute) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_91a1332b2376641a, []int{4, 0}
|
|
}
|
|
func (m *NodeInfo_Attribute) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *NodeInfo_Attribute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_NodeInfo_Attribute.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 *NodeInfo_Attribute) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_NodeInfo_Attribute.Merge(m, src)
|
|
}
|
|
func (m *NodeInfo_Attribute) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *NodeInfo_Attribute) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_NodeInfo_Attribute.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_NodeInfo_Attribute proto.InternalMessageInfo
|
|
|
|
func (m *NodeInfo_Attribute) GetKey() string {
|
|
if m != nil {
|
|
return m.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *NodeInfo_Attribute) GetValue() string {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *NodeInfo_Attribute) GetParents() []string {
|
|
if m != nil {
|
|
return m.Parents
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterEnum("neo.fs.v2.netmap.Operation", Operation_name, Operation_value)
|
|
proto.RegisterEnum("neo.fs.v2.netmap.Clause", Clause_name, Clause_value)
|
|
proto.RegisterEnum("neo.fs.v2.netmap.NodeInfo_State", NodeInfo_State_name, NodeInfo_State_value)
|
|
proto.RegisterType((*Filter)(nil), "neo.fs.v2.netmap.Filter")
|
|
proto.RegisterType((*Selector)(nil), "neo.fs.v2.netmap.Selector")
|
|
proto.RegisterType((*Replica)(nil), "neo.fs.v2.netmap.Replica")
|
|
proto.RegisterType((*PlacementPolicy)(nil), "neo.fs.v2.netmap.PlacementPolicy")
|
|
proto.RegisterType((*NodeInfo)(nil), "neo.fs.v2.netmap.NodeInfo")
|
|
proto.RegisterType((*NodeInfo_Attribute)(nil), "neo.fs.v2.netmap.NodeInfo.Attribute")
|
|
}
|
|
|
|
func init() { proto.RegisterFile("v2/netmap/grpc/types.proto", fileDescriptor_91a1332b2376641a) }
|
|
|
|
var fileDescriptor_91a1332b2376641a = []byte{
|
|
// 686 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xcd, 0x6e, 0xda, 0x40,
|
|
0x10, 0x8e, 0x0d, 0x18, 0x98, 0xfc, 0x59, 0xdb, 0x24, 0x75, 0x68, 0x8b, 0x10, 0xea, 0x21, 0x4a,
|
|
0x15, 0xd3, 0x52, 0x35, 0x8d, 0x94, 0x13, 0x01, 0x53, 0x59, 0x4d, 0x0c, 0x35, 0xe4, 0xd2, 0x0b,
|
|
0x5a, 0xcc, 0x42, 0xad, 0x18, 0xaf, 0x65, 0x2f, 0x48, 0xbc, 0x49, 0x0f, 0xbd, 0xf6, 0xd2, 0xd7,
|
|
0xe8, 0xa5, 0xc7, 0x3e, 0x42, 0x95, 0xde, 0xfb, 0x0c, 0x95, 0xd7, 0x3f, 0x90, 0x10, 0x55, 0x3d,
|
|
0xcd, 0xce, 0xce, 0xe7, 0xef, 0xfb, 0x34, 0xb3, 0x63, 0x28, 0xcd, 0xeb, 0x35, 0x97, 0xb0, 0x29,
|
|
0xf6, 0x6a, 0x13, 0xdf, 0xb3, 0x6a, 0x6c, 0xe1, 0x91, 0x40, 0xf5, 0x7c, 0xca, 0x28, 0x92, 0x5d,
|
|
0x42, 0xd5, 0x71, 0xa0, 0xce, 0xeb, 0x6a, 0x04, 0xa9, 0x7e, 0x15, 0x40, 0x6a, 0xdb, 0x0e, 0x23,
|
|
0x3e, 0x42, 0x90, 0x75, 0xf1, 0x94, 0x28, 0x42, 0x45, 0x38, 0x2a, 0x9a, 0xfc, 0x8c, 0x64, 0xc8,
|
|
0xdc, 0x90, 0x85, 0x22, 0xf2, 0xab, 0xf0, 0x88, 0x5e, 0x80, 0x48, 0x3d, 0x25, 0x53, 0x11, 0x8e,
|
|
0x76, 0xea, 0x4f, 0xd4, 0xfb, 0x7c, 0x6a, 0xc7, 0x23, 0x3e, 0x66, 0x36, 0x75, 0x4d, 0x91, 0x7a,
|
|
0x68, 0x0f, 0x72, 0x73, 0xec, 0xcc, 0x88, 0x92, 0xe5, 0x04, 0x51, 0x82, 0xea, 0x90, 0x1f, 0x73,
|
|
0xc9, 0x40, 0xc9, 0x55, 0x32, 0x47, 0x9b, 0x75, 0x65, 0x9d, 0x27, 0xf2, 0x64, 0x26, 0xc0, 0xea,
|
|
0x17, 0x01, 0x0a, 0x3d, 0xe2, 0x10, 0x8b, 0xd1, 0x87, 0x9d, 0xee, 0x41, 0xce, 0xa2, 0x33, 0x97,
|
|
0x71, 0xaf, 0xdb, 0x66, 0x94, 0xa0, 0x97, 0x20, 0x59, 0x0e, 0x9e, 0x05, 0x24, 0x76, 0xfc, 0x80,
|
|
0x52, 0x93, 0xd7, 0xcd, 0x18, 0x87, 0x9e, 0x42, 0x11, 0x33, 0xe6, 0xdb, 0xc3, 0x19, 0x4b, 0x6c,
|
|
0x2f, 0x2f, 0xd0, 0x01, 0x48, 0x91, 0x23, 0x25, 0xc7, 0x4b, 0x71, 0x56, 0x3d, 0x87, 0xbc, 0x49,
|
|
0x3c, 0xc7, 0xb6, 0xf0, 0xd2, 0x88, 0xb0, 0x6a, 0xa4, 0x04, 0x85, 0x20, 0xb6, 0x1f, 0x77, 0x33,
|
|
0xcd, 0xab, 0x7f, 0x04, 0xd8, 0xed, 0x3a, 0xd8, 0x22, 0x53, 0xe2, 0xb2, 0x2e, 0x75, 0x6c, 0x6b,
|
|
0x81, 0xde, 0x40, 0xc1, 0x8f, 0x08, 0x03, 0x45, 0xe0, 0x4d, 0x3a, 0x5c, 0xb7, 0x1e, 0x4b, 0x9a,
|
|
0x29, 0x14, 0x9d, 0xc2, 0x63, 0x8b, 0xba, 0x0c, 0xdb, 0x2e, 0xf1, 0x07, 0x43, 0x6c, 0xdd, 0xcc,
|
|
0xbc, 0xc1, 0x18, 0xa7, 0xaa, 0xdb, 0xe6, 0x7e, 0x5a, 0xbe, 0xe0, 0xd5, 0x36, 0x2f, 0xa2, 0x33,
|
|
0x28, 0x26, 0x76, 0x02, 0x25, 0xc3, 0xf5, 0x4a, 0xeb, 0x7a, 0xc9, 0x00, 0xcc, 0x25, 0x78, 0x75,
|
|
0x98, 0xd9, 0xff, 0x1d, 0xe6, 0x77, 0x11, 0x0a, 0x06, 0x1d, 0x11, 0xdd, 0x1d, 0x53, 0xf4, 0x0c,
|
|
0xc0, 0x9b, 0x0d, 0x1d, 0xdb, 0x1a, 0x84, 0x2f, 0x2d, 0x6c, 0xda, 0x96, 0x59, 0x8c, 0x6e, 0xde,
|
|
0x93, 0x05, 0x52, 0x20, 0x8f, 0x47, 0x23, 0x9f, 0x04, 0x41, 0xdc, 0xb7, 0x24, 0x45, 0x2d, 0x80,
|
|
0x74, 0x30, 0x89, 0xe9, 0xe7, 0xeb, 0xe2, 0x89, 0x90, 0xda, 0x48, 0xc0, 0xe6, 0xca, 0x77, 0xe8,
|
|
0x14, 0x72, 0x01, 0xc3, 0xf1, 0xac, 0x77, 0xea, 0x95, 0x7f, 0x10, 0xf4, 0x42, 0x9c, 0x19, 0xc1,
|
|
0x4b, 0x57, 0x50, 0x4c, 0x09, 0x93, 0x35, 0x11, 0x96, 0x6b, 0x92, 0xbe, 0x7c, 0x71, 0xf5, 0xe5,
|
|
0x2b, 0x90, 0xf7, 0xb0, 0x4f, 0x5c, 0x16, 0xf9, 0x2d, 0x9a, 0x49, 0x5a, 0x7d, 0x05, 0x39, 0x4e,
|
|
0x8f, 0x76, 0x61, 0xf3, 0xda, 0xe8, 0x75, 0xb5, 0xa6, 0xde, 0xd6, 0xb5, 0x96, 0xbc, 0x81, 0x00,
|
|
0xa4, 0x8e, 0x71, 0xa9, 0x1b, 0x9a, 0x2c, 0xa0, 0x4d, 0xc8, 0x77, 0xda, 0x6d, 0x9e, 0x88, 0xc7,
|
|
0x13, 0x28, 0xa6, 0xdb, 0x86, 0x0e, 0x61, 0xbf, 0xd3, 0xd5, 0xcc, 0x46, 0x5f, 0xef, 0x18, 0x83,
|
|
0xbb, 0x04, 0x12, 0x88, 0xda, 0x07, 0x59, 0x08, 0x63, 0xf8, 0x5d, 0x18, 0xdf, 0xf5, 0xe5, 0x0c,
|
|
0x8f, 0x9a, 0x9c, 0x0d, 0xe3, 0x65, 0x5f, 0xce, 0xf1, 0xa8, 0xc9, 0x52, 0x18, 0x3b, 0xa6, 0x9c,
|
|
0x47, 0x79, 0xc8, 0x34, 0x8c, 0x96, 0x5c, 0x38, 0x3e, 0x03, 0x29, 0x5a, 0x12, 0x74, 0x00, 0xa8,
|
|
0x79, 0xd9, 0xb8, 0xee, 0x69, 0xf7, 0x24, 0x0a, 0x90, 0xed, 0x35, 0xae, 0x42, 0x87, 0x5b, 0x50,
|
|
0x68, 0xe9, 0xbd, 0xbe, 0x6e, 0x34, 0xfb, 0xb2, 0x78, 0x31, 0xf8, 0x71, 0x5b, 0x16, 0x7e, 0xde,
|
|
0x96, 0x85, 0x5f, 0xb7, 0x65, 0xe1, 0xf3, 0xef, 0xf2, 0xc6, 0xc7, 0xb7, 0x13, 0x9b, 0x7d, 0x9a,
|
|
0x0d, 0x55, 0x8b, 0x4e, 0x6b, 0x6e, 0xe0, 0x59, 0xd6, 0xc9, 0x88, 0xcc, 0x6b, 0x2e, 0xa1, 0xe3,
|
|
0xe0, 0x04, 0x7b, 0xf6, 0xc9, 0x84, 0xd6, 0xee, 0xfe, 0xbf, 0xce, 0xa3, 0xf3, 0x37, 0xf1, 0x91,
|
|
0x41, 0x68, 0xbb, 0xa7, 0x36, 0xba, 0x7a, 0x38, 0x1b, 0x83, 0xdf, 0x0e, 0x25, 0xfe, 0x5f, 0x7b,
|
|
0xfd, 0x37, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x69, 0xba, 0x7f, 0xf5, 0x04, 0x00, 0x00,
|
|
}
|
|
|
|
func (m *Filter) 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 *Filter) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Filter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
i -= len(m.XXX_unrecognized)
|
|
copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
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 = encodeVarintTypes(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
}
|
|
if len(m.Value) > 0 {
|
|
i -= len(m.Value)
|
|
copy(dAtA[i:], m.Value)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Value)))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
if m.Op != 0 {
|
|
i = encodeVarintTypes(dAtA, i, uint64(m.Op))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if len(m.Key) > 0 {
|
|
i -= len(m.Key)
|
|
copy(dAtA[i:], m.Key)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Name) > 0 {
|
|
i -= len(m.Name)
|
|
copy(dAtA[i:], m.Name)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Name)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Selector) 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 *Selector) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Selector) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
i -= len(m.XXX_unrecognized)
|
|
copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
if len(m.Filter) > 0 {
|
|
i -= len(m.Filter)
|
|
copy(dAtA[i:], m.Filter)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Filter)))
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
if len(m.Attribute) > 0 {
|
|
i -= len(m.Attribute)
|
|
copy(dAtA[i:], m.Attribute)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Attribute)))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
if m.Clause != 0 {
|
|
i = encodeVarintTypes(dAtA, i, uint64(m.Clause))
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if m.Count != 0 {
|
|
i = encodeVarintTypes(dAtA, i, uint64(m.Count))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.Name) > 0 {
|
|
i -= len(m.Name)
|
|
copy(dAtA[i:], m.Name)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Name)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Replica) 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 *Replica) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Replica) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
i -= len(m.XXX_unrecognized)
|
|
copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
if len(m.Selector) > 0 {
|
|
i -= len(m.Selector)
|
|
copy(dAtA[i:], m.Selector)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Selector)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Count != 0 {
|
|
i = encodeVarintTypes(dAtA, i, uint64(m.Count))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *PlacementPolicy) 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 *PlacementPolicy) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *PlacementPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
i -= len(m.XXX_unrecognized)
|
|
copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
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 = encodeVarintTypes(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
}
|
|
if len(m.Selectors) > 0 {
|
|
for iNdEx := len(m.Selectors) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Selectors[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintTypes(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
}
|
|
if m.ContainerBackupFactor != 0 {
|
|
i = encodeVarintTypes(dAtA, i, uint64(m.ContainerBackupFactor))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.Replicas) > 0 {
|
|
for iNdEx := len(m.Replicas) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Replicas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintTypes(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *NodeInfo) 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 *NodeInfo) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *NodeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
i -= len(m.XXX_unrecognized)
|
|
copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
if m.State != 0 {
|
|
i = encodeVarintTypes(dAtA, i, uint64(m.State))
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if len(m.Attributes) > 0 {
|
|
for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintTypes(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
}
|
|
if len(m.Address) > 0 {
|
|
i -= len(m.Address)
|
|
copy(dAtA[i:], m.Address)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Address)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.PublicKey) > 0 {
|
|
i -= len(m.PublicKey)
|
|
copy(dAtA[i:], m.PublicKey)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.PublicKey)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *NodeInfo_Attribute) 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 *NodeInfo_Attribute) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *NodeInfo_Attribute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
i -= len(m.XXX_unrecognized)
|
|
copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
if len(m.Parents) > 0 {
|
|
for iNdEx := len(m.Parents) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.Parents[iNdEx])
|
|
copy(dAtA[i:], m.Parents[iNdEx])
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Parents[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
}
|
|
if len(m.Value) > 0 {
|
|
i -= len(m.Value)
|
|
copy(dAtA[i:], m.Value)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Value)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Key) > 0 {
|
|
i -= len(m.Key)
|
|
copy(dAtA[i:], m.Key)
|
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
|
|
offset -= sovTypes(v)
|
|
base := offset
|
|
for v >= 1<<7 {
|
|
dAtA[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
dAtA[offset] = uint8(v)
|
|
return base
|
|
}
|
|
func (m *Filter) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Name)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
if m.Op != 0 {
|
|
n += 1 + sovTypes(uint64(m.Op))
|
|
}
|
|
l = len(m.Value)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
if len(m.Filters) > 0 {
|
|
for _, e := range m.Filters {
|
|
l = e.Size()
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Selector) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Name)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
if m.Count != 0 {
|
|
n += 1 + sovTypes(uint64(m.Count))
|
|
}
|
|
if m.Clause != 0 {
|
|
n += 1 + sovTypes(uint64(m.Clause))
|
|
}
|
|
l = len(m.Attribute)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
l = len(m.Filter)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Replica) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Count != 0 {
|
|
n += 1 + sovTypes(uint64(m.Count))
|
|
}
|
|
l = len(m.Selector)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *PlacementPolicy) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Replicas) > 0 {
|
|
for _, e := range m.Replicas {
|
|
l = e.Size()
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
}
|
|
if m.ContainerBackupFactor != 0 {
|
|
n += 1 + sovTypes(uint64(m.ContainerBackupFactor))
|
|
}
|
|
if len(m.Selectors) > 0 {
|
|
for _, e := range m.Selectors {
|
|
l = e.Size()
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
}
|
|
if len(m.Filters) > 0 {
|
|
for _, e := range m.Filters {
|
|
l = e.Size()
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *NodeInfo) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.PublicKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
l = len(m.Address)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
if len(m.Attributes) > 0 {
|
|
for _, e := range m.Attributes {
|
|
l = e.Size()
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
}
|
|
if m.State != 0 {
|
|
n += 1 + sovTypes(uint64(m.State))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *NodeInfo_Attribute) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
l = len(m.Value)
|
|
if l > 0 {
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
if len(m.Parents) > 0 {
|
|
for _, s := range m.Parents {
|
|
l = len(s)
|
|
n += 1 + l + sovTypes(uint64(l))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovTypes(x uint64) (n int) {
|
|
return (math_bits.Len64(x|1) + 6) / 7
|
|
}
|
|
func sozTypes(x uint64) (n int) {
|
|
return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *Filter) 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 ErrIntOverflowTypes
|
|
}
|
|
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: Filter: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Filter: 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 ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
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 Key", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Key = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
|
|
}
|
|
m.Op = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Op |= Operation(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
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 ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Value = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 5:
|
|
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 ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Filters = append(m.Filters, &Filter{})
|
|
if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipTypes(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Selector) 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 ErrIntOverflowTypes
|
|
}
|
|
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: Selector: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Selector: 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 ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
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 Count", wireType)
|
|
}
|
|
m.Count = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Count |= uint32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Clause", wireType)
|
|
}
|
|
m.Clause = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Clause |= Clause(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Attribute", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Attribute = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Filter = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipTypes(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Replica) 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 ErrIntOverflowTypes
|
|
}
|
|
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: Replica: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Replica: 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 ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Count |= uint32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
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 ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Selector = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipTypes(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *PlacementPolicy) 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 ErrIntOverflowTypes
|
|
}
|
|
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: PlacementPolicy: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: PlacementPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Replicas = append(m.Replicas, &Replica{})
|
|
if err := m.Replicas[len(m.Replicas)-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 ContainerBackupFactor", wireType)
|
|
}
|
|
m.ContainerBackupFactor = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.ContainerBackupFactor |= uint32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Selectors", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Selectors = append(m.Selectors, &Selector{})
|
|
if err := m.Selectors[len(m.Selectors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
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 ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Filters = append(m.Filters, &Filter{})
|
|
if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipTypes(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *NodeInfo) 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 ErrIntOverflowTypes
|
|
}
|
|
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: NodeInfo: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: NodeInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.PublicKey == nil {
|
|
m.PublicKey = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Address = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Attributes = append(m.Attributes, &NodeInfo_Attribute{})
|
|
if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
|
|
}
|
|
m.State = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.State |= NodeInfo_State(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipTypes(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *NodeInfo_Attribute) 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 ErrIntOverflowTypes
|
|
}
|
|
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: Attribute: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Attribute: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Key = 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 ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Value = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Parents", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowTypes
|
|
}
|
|
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 ErrInvalidLengthTypes
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Parents = append(m.Parents, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipTypes(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthTypes
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func skipTypes(dAtA []byte) (n int, err error) {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
depth := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowTypes
|
|
}
|
|
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, ErrIntOverflowTypes
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx++
|
|
if dAtA[iNdEx-1] < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 1:
|
|
iNdEx += 8
|
|
case 2:
|
|
var length int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowTypes
|
|
}
|
|
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, ErrInvalidLengthTypes
|
|
}
|
|
iNdEx += length
|
|
case 3:
|
|
depth++
|
|
case 4:
|
|
if depth == 0 {
|
|
return 0, ErrUnexpectedEndOfGroupTypes
|
|
}
|
|
depth--
|
|
case 5:
|
|
iNdEx += 4
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
if iNdEx < 0 {
|
|
return 0, ErrInvalidLengthTypes
|
|
}
|
|
if depth == 0 {
|
|
return iNdEx, nil
|
|
}
|
|
}
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow")
|
|
ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
|
|
)
|