446 lines
9.1 KiB
Go
446 lines
9.1 KiB
Go
package control
|
|
|
|
import (
|
|
"github.com/nspcc-dev/neofs-api-go/v2/util/proto"
|
|
"google.golang.org/protobuf/encoding/protojson"
|
|
)
|
|
|
|
// SetKey sets public key used for signing.
|
|
func (x *Signature) SetKey(v []byte) {
|
|
if x != nil {
|
|
x.Key = v
|
|
}
|
|
}
|
|
|
|
// SetSign sets binary signature.
|
|
func (x *Signature) SetSign(v []byte) {
|
|
if x != nil {
|
|
x.Sign = v
|
|
}
|
|
}
|
|
|
|
// SetKey sets key of the node attribute.
|
|
func (x *NodeInfo_Attribute) SetKey(v string) {
|
|
if x != nil {
|
|
x.Key = v
|
|
}
|
|
}
|
|
|
|
// SetValue sets value of the node attribute.
|
|
func (x *NodeInfo_Attribute) SetValue(v string) {
|
|
if x != nil {
|
|
x.Value = v
|
|
}
|
|
}
|
|
|
|
// SetParents sets parent keys.
|
|
func (x *NodeInfo_Attribute) SetParents(v []string) {
|
|
if x != nil {
|
|
x.Parents = v
|
|
}
|
|
}
|
|
|
|
const (
|
|
_ = iota
|
|
nodeAttrKeyFNum
|
|
nodeAttrValueFNum
|
|
nodeAttrParentsFNum
|
|
)
|
|
|
|
// StableMarshal reads binary representation of node attribute
|
|
// in protobuf binary format.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *NodeInfo_Attribute) StableMarshal(buf []byte) ([]byte, error) {
|
|
if x == nil {
|
|
return []byte{}, nil
|
|
}
|
|
|
|
if sz := x.StableSize(); len(buf) < sz {
|
|
buf = make([]byte, sz)
|
|
}
|
|
|
|
var (
|
|
offset, n int
|
|
err error
|
|
)
|
|
|
|
n, err = proto.StringMarshal(nodeAttrKeyFNum, buf[offset:], x.Key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
n, err = proto.StringMarshal(nodeAttrValueFNum, buf[offset:], x.Value)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
for i := range x.Parents {
|
|
n, err = proto.StringMarshal(nodeAttrParentsFNum, buf[offset:], x.Parents[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
}
|
|
|
|
return buf, nil
|
|
}
|
|
|
|
// StableSize returns binary size of node attribute
|
|
// in protobuf binary format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *NodeInfo_Attribute) StableSize() int {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
|
|
size := 0
|
|
|
|
size += proto.StringSize(nodeAttrKeyFNum, x.Key)
|
|
size += proto.StringSize(nodeAttrValueFNum, x.Value)
|
|
|
|
parents := x.GetParents()
|
|
for i := range parents {
|
|
size += proto.StringSize(nodeAttrParentsFNum, parents[i])
|
|
}
|
|
|
|
return size
|
|
}
|
|
|
|
// SetPublicKey sets public key of the NeoFS node in a binary format.
|
|
func (x *NodeInfo) SetPublicKey(v []byte) {
|
|
if x != nil {
|
|
x.PublicKey = v
|
|
}
|
|
}
|
|
|
|
// SetAddresses sets ways to connect to a node.
|
|
func (x *NodeInfo) SetAddresses(v []string) {
|
|
if x != nil {
|
|
x.Addresses = v
|
|
}
|
|
}
|
|
|
|
// SetAttributes sets attributes of the NeoFS Storage Node.
|
|
func (x *NodeInfo) SetAttributes(v []*NodeInfo_Attribute) {
|
|
if x != nil {
|
|
x.Attributes = v
|
|
}
|
|
}
|
|
|
|
// SetState sets state of the NeoFS node.
|
|
func (x *NodeInfo) SetState(v NetmapStatus) {
|
|
if x != nil {
|
|
x.State = v
|
|
}
|
|
}
|
|
|
|
const (
|
|
_ = iota
|
|
nodePubKeyFNum
|
|
nodeAddrFNum
|
|
nodeAttrsFNum
|
|
nodeStateFNum
|
|
)
|
|
|
|
// StableMarshal reads binary representation of node information
|
|
// in protobuf binary format.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *NodeInfo) StableMarshal(buf []byte) ([]byte, error) {
|
|
if x == nil {
|
|
return []byte{}, nil
|
|
}
|
|
|
|
if sz := x.StableSize(); len(buf) < sz {
|
|
buf = make([]byte, sz)
|
|
}
|
|
|
|
var (
|
|
offset, n int
|
|
err error
|
|
)
|
|
|
|
n, err = proto.BytesMarshal(nodePubKeyFNum, buf[offset:], x.PublicKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
n, err = proto.RepeatedStringMarshal(nodeAddrFNum, buf[offset:], x.Addresses)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
for i := range x.Attributes {
|
|
n, err = proto.NestedStructureMarshal(nodeAttrsFNum, buf[offset:], x.Attributes[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
}
|
|
|
|
_, err = proto.EnumMarshal(nodeStateFNum, buf[offset:], int32(x.State))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return buf, nil
|
|
}
|
|
|
|
// StableSize returns binary size of node information
|
|
// in protobuf binary format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *NodeInfo) StableSize() int {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
|
|
size := 0
|
|
|
|
size += proto.BytesSize(nodePubKeyFNum, x.PublicKey)
|
|
size += proto.RepeatedStringSize(nodeAddrFNum, x.Addresses)
|
|
|
|
for i := range x.Attributes {
|
|
size += proto.NestedStructureSize(nodeAttrsFNum, x.Attributes[i])
|
|
}
|
|
|
|
size += proto.EnumSize(nodeStateFNum, int32(x.State))
|
|
|
|
return size
|
|
}
|
|
|
|
// SetEpoch sets revision number of the network map.
|
|
func (x *Netmap) SetEpoch(v uint64) {
|
|
if x != nil {
|
|
x.Epoch = v
|
|
}
|
|
}
|
|
|
|
// SetNodes sets nodes presented in network.
|
|
func (x *Netmap) SetNodes(v []*NodeInfo) {
|
|
if x != nil {
|
|
x.Nodes = v
|
|
}
|
|
}
|
|
|
|
const (
|
|
_ = iota
|
|
netmapEpochFNum
|
|
netmapNodesFNum
|
|
)
|
|
|
|
// StableMarshal reads binary representation of netmap in protobuf binary format.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *Netmap) StableMarshal(buf []byte) ([]byte, error) {
|
|
if x == nil {
|
|
return []byte{}, nil
|
|
}
|
|
|
|
if sz := x.StableSize(); len(buf) < sz {
|
|
buf = make([]byte, sz)
|
|
}
|
|
|
|
var (
|
|
offset, n int
|
|
err error
|
|
)
|
|
|
|
n, err = proto.UInt64Marshal(netmapEpochFNum, buf[offset:], x.Epoch)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
for i := range x.Nodes {
|
|
n, err = proto.NestedStructureMarshal(netmapNodesFNum, buf[offset:], x.Nodes[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
}
|
|
|
|
return buf, nil
|
|
}
|
|
|
|
// StableSize returns binary size of netmap in protobuf binary format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *Netmap) StableSize() int {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
|
|
size := 0
|
|
|
|
size += proto.UInt64Size(netmapEpochFNum, x.Epoch)
|
|
|
|
for i := range x.Nodes {
|
|
size += proto.NestedStructureSize(netmapNodesFNum, x.Nodes[i])
|
|
}
|
|
|
|
return size
|
|
}
|
|
|
|
func (x *Netmap) MarshalJSON() ([]byte, error) {
|
|
return protojson.MarshalOptions{
|
|
EmitUnpopulated: true,
|
|
}.Marshal(x)
|
|
}
|
|
|
|
// SetID sets identificator of the shard.
|
|
func (x *ShardInfo) SetID(v []byte) {
|
|
x.Shard_ID = v
|
|
}
|
|
|
|
// SetMetabasePath sets path to shard's metabase.
|
|
func (x *ShardInfo) SetMetabasePath(v string) {
|
|
x.MetabasePath = v
|
|
}
|
|
|
|
// SetBlobstorPath sets path to shard's blobstor.
|
|
func (x *ShardInfo) SetBlobstorPath(v string) {
|
|
x.BlobstorPath = v
|
|
}
|
|
|
|
// SetWriteCachePath sets path to shard's write-cache.
|
|
func (x *ShardInfo) SetWriteCachePath(v string) {
|
|
x.WritecachePath = v
|
|
}
|
|
|
|
// SetMode sets path to shard's work mode.
|
|
func (x *ShardInfo) SetMode(v ShardMode) {
|
|
x.Mode = v
|
|
}
|
|
|
|
// SetErrorCount sets shard's error counter.
|
|
func (x *ShardInfo) SetErrorCount(count uint32) {
|
|
x.ErrorCount = count
|
|
}
|
|
|
|
const (
|
|
_ = iota
|
|
shardInfoIDFNum
|
|
shardInfoMetabaseFNum
|
|
shardInfoBlobstorFNum
|
|
shardInfoWriteCacheFNum
|
|
shardInfoModeFNum
|
|
shardInfoErrorCountFNum
|
|
)
|
|
|
|
// StableSize returns binary size of shard information
|
|
// in protobuf binary format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *ShardInfo) StableSize() int {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
|
|
size := 0
|
|
|
|
size += proto.BytesSize(shardInfoIDFNum, x.Shard_ID)
|
|
size += proto.StringSize(shardInfoMetabaseFNum, x.MetabasePath)
|
|
size += proto.StringSize(shardInfoBlobstorFNum, x.BlobstorPath)
|
|
size += proto.StringSize(shardInfoWriteCacheFNum, x.WritecachePath)
|
|
size += proto.EnumSize(shardInfoModeFNum, int32(x.Mode))
|
|
size += proto.UInt32Size(shardInfoErrorCountFNum, x.ErrorCount)
|
|
|
|
return size
|
|
}
|
|
|
|
// StableMarshal reads binary representation of shard information
|
|
// in protobuf binary format.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *ShardInfo) StableMarshal(buf []byte) ([]byte, error) {
|
|
if x == nil {
|
|
return []byte{}, nil
|
|
}
|
|
|
|
if sz := x.StableSize(); len(buf) < sz {
|
|
buf = make([]byte, sz)
|
|
}
|
|
|
|
var (
|
|
offset, n int
|
|
err error
|
|
)
|
|
|
|
n, err = proto.BytesMarshal(shardInfoIDFNum, buf[offset:], x.Shard_ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
n, err = proto.StringMarshal(shardInfoMetabaseFNum, buf[offset:], x.MetabasePath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
n, err = proto.StringMarshal(shardInfoBlobstorFNum, buf[offset:], x.BlobstorPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
n, err = proto.StringMarshal(shardInfoWriteCacheFNum, buf[offset:], x.WritecachePath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
n, err = proto.EnumMarshal(shardInfoModeFNum, buf[offset:], int32(x.Mode))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset += n
|
|
|
|
_, err = proto.EnumMarshal(shardInfoErrorCountFNum, buf[offset:], int32(x.ErrorCount))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return buf, nil
|
|
}
|