[#311] control: Rewrite methods for binary encoding and signatures

Rewrite marshalers and sizers using proto library from API repo.

Signed-off-by: Leonard Lyubich <leonard@nspcc.ru>

pkg/services/control/service.go

@@ -1,119 +1,291 @@
 package control
 
+import (
+	"github.com/nspcc-dev/neofs-api-go/util/proto"
+)
+
+// StableMarshal reads binary representation of health check request body
+// 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 *HealthCheckRequest_Body) StableMarshal(buf []byte) ([]byte, error) {
+	return buf, nil
+}
+
+// StableSize returns binary size of health check request body
+// in protobuf binary format.
+//
+// Structures with the same field values have the same binary size.
+func (x *HealthCheckRequest_Body) StableSize() int {
+	return 0
+}
+
 // SetBody sets health check request body.
-func (m *HealthCheckRequest) SetBody(v *HealthCheckRequest_Body) {
+func (x *HealthCheckRequest) SetBody(v *HealthCheckRequest_Body) {
-	if m != nil {
+	if x != nil {
-		m.Body = v
+		x.Body = v
 	}
 }
 
 // SetSignature sets signature of the health check request body.
-func (m *HealthCheckRequest) SetSignature(body *Signature) {
+func (x *HealthCheckRequest) SetSignature(body *Signature) {
-	if m != nil {
+	if x != nil {
-		m.Signature = body
+		x.Signature = body
 	}
 }
 
-// ReadSignedData marshals request body to buf.
+// ReadSignedData reads signed data of health check request to buf.
-func (m *HealthCheckRequest) ReadSignedData(buf []byte) ([]byte, error) {
+//
-	_, err := m.GetBody().MarshalTo(buf)
+// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
-
+//
-	return buf, err
+// 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 signed data.
+func (x *HealthCheckRequest) ReadSignedData(buf []byte) ([]byte, error) {
+	return x.GetBody().StableMarshal(buf)
 }
 
-// SignedDataSize returns binary size of the request body.
+// SignedDataSize returns binary size of the signed data
-func (m *HealthCheckRequest) SignedDataSize() int {
+// of health check request.
-	return m.GetBody().Size()
+//
+// Structures with the same field values have the same signed data size.
+func (x *HealthCheckRequest) SignedDataSize() int {
+	return x.GetBody().StableSize()
 }
 
 // SetStatus sets health status of storage node.
-func (m *HealthCheckResponse_Body) SetStatus(v HealthStatus) {
+func (x *HealthCheckResponse_Body) SetStatus(v HealthStatus) {
-	if m != nil {
+	if x != nil {
-		m.Status = v
+		x.Status = v
 	}
 }
 
+const (
+	_ = iota
+	healthRespBodyStatusFNum
+)
+
+// StableMarshal reads binary representation of health check response body
+// 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 *HealthCheckResponse_Body) StableMarshal(buf []byte) ([]byte, error) {
+	if x == nil {
+		return []byte{}, nil
+	}
+
+	if sz := x.StableSize(); len(buf) < sz {
+		buf = make([]byte, sz)
+	}
+
+	_, err := proto.EnumMarshal(healthRespBodyStatusFNum, buf, int32(x.Status))
+	if err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+// StableSize returns binary size of health check response body
+// in protobuf binary format.
+//
+// Structures with the same field values have the same binary size.
+func (x *HealthCheckResponse_Body) StableSize() int {
+	if x == nil {
+		return 0
+	}
+
+	size := 0
+
+	size += proto.EnumSize(healthRespBodyStatusFNum, int32(x.Status))
+
+	return size
+}
+
 // SetBody sets health check response body.
-func (m *HealthCheckResponse) SetBody(v *HealthCheckResponse_Body) {
+func (x *HealthCheckResponse) SetBody(v *HealthCheckResponse_Body) {
-	if m != nil {
+	if x != nil {
-		m.Body = v
+		x.Body = v
 	}
 }
 
 // SetSignature sets signature of the health check response body.
-func (m *HealthCheckResponse) SetSignature(v *Signature) {
+func (x *HealthCheckResponse) SetSignature(v *Signature) {
-	if m != nil {
+	if x != nil {
-		m.Signature = v
+		x.Signature = v
 	}
 }
 
-// ReadSignedData marshals response body to buf.
+// ReadSignedData reads signed data of health check response to buf.
-func (m *HealthCheckResponse) ReadSignedData(buf []byte) ([]byte, error) {
+//
-	_, err := m.GetBody().MarshalTo(buf)
+// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
-
+//
-	return buf, err
+// 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 signed data.
+func (x *HealthCheckResponse) ReadSignedData(buf []byte) ([]byte, error) {
+	return x.GetBody().StableMarshal(buf)
 }
 
-// SignedDataSize returns binary size of the response body.
+// SignedDataSize returns binary size of the signed data
-func (m *HealthCheckResponse) SignedDataSize() int {
+// of health check response.
-	return m.GetBody().Size()
+//
+// Structures with the same field values have the same signed data size.
+func (x *HealthCheckResponse) SignedDataSize() int {
+	return x.GetBody().StableSize()
+}
+
+// StableMarshal reads binary representation of netmap snapshot request body
+// 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 *NetmapSnapshotRequest_Body) StableMarshal(buf []byte) ([]byte, error) {
+	return buf, nil
+}
+
+// StableSize returns binary size of netmap snapshot request body
+// in protobuf binary format.
+//
+// Structures with the same field values have the same binary size.
+func (x *NetmapSnapshotRequest_Body) StableSize() int {
+	return 0
 }
 
 // SetBody sets get netmap snapshot request body.
-func (m *NetmapSnapshotRequest) SetBody(v *NetmapSnapshotRequest_Body) {
+func (x *NetmapSnapshotRequest) SetBody(v *NetmapSnapshotRequest_Body) {
-	if m != nil {
+	if x != nil {
-		m.Body = v
+		x.Body = v
 	}
 }
 
 // SetSignature sets signature of the netmap snapshot request body.
-func (m *NetmapSnapshotRequest) SetSignature(body *Signature) {
+func (x *NetmapSnapshotRequest) SetSignature(body *Signature) {
-	if m != nil {
+	if x != nil {
-		m.Signature = body
+		x.Signature = body
 	}
 }
 
-// ReadSignedData marshals request body to buf.
+// ReadSignedData reads signed data of netmap snapshot request to buf.
-func (m *NetmapSnapshotRequest) ReadSignedData(buf []byte) ([]byte, error) {
+//
-	_, err := m.GetBody().MarshalTo(buf)
+// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
-
+//
-	return buf, err
+// 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 signed data.
+func (x *NetmapSnapshotRequest) ReadSignedData(buf []byte) ([]byte, error) {
+	return x.GetBody().StableMarshal(buf)
 }
 
-// SignedDataSize returns binary size of the request body.
+// SignedDataSize returns binary size of the signed data
-func (m *NetmapSnapshotRequest) SignedDataSize() int {
+// of netmap snapshot request.
-	return m.GetBody().Size()
+//
+// Structures with the same field values have the same signed data size.
+func (x *NetmapSnapshotRequest) SignedDataSize() int {
+	return x.GetBody().StableSize()
 }
 
 // SetNetmap sets structure of the current network map.
-func (m *NetmapSnapshotResponse_Body) SetNetmap(v *Netmap) {
+func (x *NetmapSnapshotResponse_Body) SetNetmap(v *Netmap) {
-	if m != nil {
+	if x != nil {
-		m.Netmap = v
+		x.Netmap = v
 	}
 }
 
+const (
+	_ = iota
+	snapshotRespBodyNetmapFNum
+)
+
+// StableMarshal reads binary representation of netmap snapshot response body
+// 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 *NetmapSnapshotResponse_Body) StableMarshal(buf []byte) ([]byte, error) {
+	if x == nil {
+		return []byte{}, nil
+	}
+
+	if sz := x.StableSize(); len(buf) < sz {
+		buf = make([]byte, sz)
+	}
+
+	_, err := proto.NestedStructureMarshal(snapshotRespBodyNetmapFNum, buf, x.Netmap)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+// StableSize returns binary size of netmap snapshot response body
+// in protobuf binary format.
+//
+// Structures with the same field values have the same binary size.
+func (x *NetmapSnapshotResponse_Body) StableSize() int {
+	if x == nil {
+		return 0
+	}
+
+	size := 0
+
+	size += proto.NestedStructureSize(snapshotRespBodyNetmapFNum, x.Netmap)
+
+	return size
+}
+
 // SetBody sets get netmap snapshot response body.
-func (m *NetmapSnapshotResponse) SetBody(v *NetmapSnapshotResponse_Body) {
+func (x *NetmapSnapshotResponse) SetBody(v *NetmapSnapshotResponse_Body) {
-	if m != nil {
+	if x != nil {
-		m.Body = v
+		x.Body = v
 	}
 }
 
 // SetSignature sets signature of the get netmap snapshot response body.
-func (m *NetmapSnapshotResponse) SetSignature(v *Signature) {
+func (x *NetmapSnapshotResponse) SetSignature(v *Signature) {
-	if m != nil {
+	if x != nil {
-		m.Signature = v
+		x.Signature = v
 	}
 }
 
-// ReadSignedData marshals request body to buf.
+// ReadSignedData reads signed data of netmap snapshot response to buf.
-func (m *NetmapSnapshotResponse) ReadSignedData(buf []byte) ([]byte, error) {
+//
-	_, err := m.GetBody().MarshalTo(buf)
+// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
-
+//
-	return buf, err
+// 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 signed data.
+func (x *NetmapSnapshotResponse) ReadSignedData(buf []byte) ([]byte, error) {
+	return x.GetBody().StableMarshal(buf)
 }
 
-// SignedDataSize returns binary size of the request body.
+// SignedDataSize returns binary size of the signed data
-func (m *NetmapSnapshotResponse) SignedDataSize() int {
+// of netmap snapshot response.
-	return m.GetBody().Size()
+//
+// Structures with the same field values have the same signed data size.
+func (x *NetmapSnapshotResponse) SignedDataSize() int {
+	return x.GetBody().StableSize()
 }

pkg/services/control/types.go

@@ -1,78 +1,311 @@
 package control
 
+import (
+	"github.com/nspcc-dev/neofs-api-go/util/proto"
+)
+
 // SetKey sets public key used for signing.
-func (m *Signature) SetKey(v []byte) {
+func (x *Signature) SetKey(v []byte) {
-	if m != nil {
+	if x != nil {
-		m.Key = v
+		x.Key = v
 	}
 }
 
 // SetSign sets binary signature.
-func (m *Signature) SetSign(v []byte) {
+func (x *Signature) SetSign(v []byte) {
-	if m != nil {
+	if x != nil {
-		m.Sign = v
+		x.Sign = v
 	}
 }
 
 // SetKey sets key of the node attribute.
-func (m *NodeInfo_Attribute) SetKey(v string) {
+func (x *NodeInfo_Attribute) SetKey(v string) {
-	if m != nil {
+	if x != nil {
-		m.Key = v
+		x.Key = v
 	}
 }
 
 // SetValue sets value of the node attribute.
-func (m *NodeInfo_Attribute) SetValue(v string) {
+func (x *NodeInfo_Attribute) SetValue(v string) {
-	if m != nil {
+	if x != nil {
-		m.Value = v
+		x.Value = v
 	}
 }
 
 // SetParents sets parent keys.
-func (m *NodeInfo_Attribute) SetParents(v []string) {
+func (x *NodeInfo_Attribute) SetParents(v []string) {
-	if m != nil {
+	if x != nil {
-		m.Parents = v
+		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 (m *NodeInfo) SetPublicKey(v []byte) {
+func (x *NodeInfo) SetPublicKey(v []byte) {
-	if m != nil {
+	if x != nil {
-		m.PublicKey = v
+		x.PublicKey = v
 	}
 }
 
 // SetAddress sets ways to connect to a node.
-func (m *NodeInfo) SetAddress(v string) {
+func (x *NodeInfo) SetAddress(v string) {
-	if m != nil {
+	if x != nil {
-		m.Address = v
+		x.Address = v
 	}
 }
 
 // SetAttributes sets attributes of the NeoFS Storage Node.
-func (m *NodeInfo) SetAttributes(v []*NodeInfo_Attribute) {
+func (x *NodeInfo) SetAttributes(v []*NodeInfo_Attribute) {
-	if m != nil {
+	if x != nil {
-		m.Attributes = v
+		x.Attributes = v
 	}
 }
 
 // SetState sets state of the NeoFS node.
-func (m *NodeInfo) SetState(v HealthStatus) {
+func (x *NodeInfo) SetState(v HealthStatus) {
-	if m != nil {
+	if x != nil {
-		m.State = v
+		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.StringMarshal(nodeAddrFNum, buf[offset:], x.Address)
+	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.StringSize(nodeAddrFNum, x.Address)
+
+	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 (m *Netmap) SetEpoch(v uint64) {
+func (x *Netmap) SetEpoch(v uint64) {
-	if m != nil {
+	if x != nil {
-		m.Epoch = v
+		x.Epoch = v
 	}
 }
 
 // SetNodes sets nodes presented in network.
-func (m *Netmap) SetNodes(v []*NodeInfo) {
+func (x *Netmap) SetNodes(v []*NodeInfo) {
-	if m != nil {
+	if x != nil {
-		m.Nodes = v
+		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
+}