af33dd65b2
Add optional parameters to the client call signature. Signed-off-by: Pavel Karpy <carpawell@nspcc.ru>
420 lines
9.9 KiB
Go
420 lines
9.9 KiB
Go
package wrapper
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"errors"
|
|
"fmt"
|
|
|
|
v2refs "github.com/nspcc-dev/neofs-api-go/v2/refs"
|
|
core "github.com/nspcc-dev/neofs-node/pkg/core/container"
|
|
staticli "github.com/nspcc-dev/neofs-node/pkg/morph/client"
|
|
client "github.com/nspcc-dev/neofs-node/pkg/morph/client/container"
|
|
"github.com/nspcc-dev/neofs-sdk-go/container"
|
|
cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
|
|
"github.com/nspcc-dev/neofs-sdk-go/owner"
|
|
"github.com/nspcc-dev/neofs-sdk-go/session"
|
|
"github.com/nspcc-dev/neofs-sdk-go/signature"
|
|
)
|
|
|
|
var (
|
|
errNilArgument = errors.New("empty argument")
|
|
errUnsupported = errors.New("unsupported structure version")
|
|
)
|
|
|
|
// Put marshals container, and passes it to Wrapper's Put method
|
|
// along with sig.Key() and sig.Sign().
|
|
//
|
|
// Returns error if container is nil.
|
|
func Put(w *Wrapper, cnr *container.Container) (*cid.ID, error) {
|
|
if cnr == nil {
|
|
return nil, errNilArgument
|
|
}
|
|
|
|
data, err := cnr.Marshal()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("can't marshal container: %w", err)
|
|
}
|
|
|
|
binToken, err := cnr.SessionToken().Marshal()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("could not marshal session token: %w", err)
|
|
}
|
|
|
|
sig := cnr.Signature()
|
|
|
|
name, zone := container.GetNativeNameWithZone(cnr)
|
|
|
|
err = w.Put(PutPrm{
|
|
cnr: data,
|
|
key: sig.Key(),
|
|
sig: sig.Sign(),
|
|
token: binToken,
|
|
name: name,
|
|
zone: zone,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
id := cid.New()
|
|
id.SetSHA256(sha256.Sum256(data))
|
|
|
|
return id, nil
|
|
}
|
|
|
|
// PutPrm groups parameters of Put operation.
|
|
type PutPrm struct {
|
|
cnr []byte
|
|
key []byte
|
|
sig []byte
|
|
token []byte
|
|
name string
|
|
zone string
|
|
|
|
staticli.InvokePrmOptional
|
|
}
|
|
|
|
// SetContainer sets container data.
|
|
func (p *PutPrm) SetContainer(cnr []byte) {
|
|
p.cnr = cnr
|
|
}
|
|
|
|
// SetKey sets public key.
|
|
func (p *PutPrm) SetKey(key []byte) {
|
|
p.key = key
|
|
}
|
|
|
|
// SetSignature sets signature.
|
|
func (p *PutPrm) SetSignature(sig []byte) {
|
|
p.sig = sig
|
|
}
|
|
|
|
// SetToken sets session token.
|
|
func (p *PutPrm) SetToken(token []byte) {
|
|
p.token = token
|
|
}
|
|
|
|
// SetName sets native name.
|
|
func (p *PutPrm) SetName(name string) {
|
|
p.name = name
|
|
}
|
|
|
|
// SetZone sets zone.
|
|
func (p *PutPrm) SetZone(zone string) {
|
|
p.zone = zone
|
|
}
|
|
|
|
// Put saves binary container with its session token, key and signature
|
|
// in NeoFS system through Container contract call.
|
|
//
|
|
// Returns calculated container identifier and any error
|
|
// encountered that caused the saving to interrupt.
|
|
//
|
|
// If TryNotary is provided, calls notary contract.
|
|
func (w *Wrapper) Put(prm PutPrm) error {
|
|
if len(prm.sig) == 0 || len(prm.key) == 0 {
|
|
return errNilArgument
|
|
}
|
|
|
|
var args client.PutArgs
|
|
|
|
args.SetContainer(prm.cnr)
|
|
args.SetSignature(prm.sig)
|
|
args.SetPublicKey(prm.key)
|
|
args.SetSessionToken(prm.token)
|
|
args.SetNativeNameWithZone(prm.name, prm.zone)
|
|
args.InvokePrmOptional = prm.InvokePrmOptional
|
|
|
|
err := w.client.Put(args)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type containerSource Wrapper
|
|
|
|
func (x *containerSource) Get(cid *cid.ID) (*container.Container, error) {
|
|
return Get((*Wrapper)(x), cid)
|
|
}
|
|
|
|
// AsContainerSource provides container Source interface
|
|
// from Wrapper instance.
|
|
func AsContainerSource(w *Wrapper) core.Source {
|
|
return (*containerSource)(w)
|
|
}
|
|
|
|
// Get marshals container ID, and passes it to Wrapper's Get method.
|
|
//
|
|
// Returns error if cid is nil.
|
|
func Get(w *Wrapper, cid *cid.ID) (*container.Container, error) {
|
|
return w.Get(cid.ToV2().GetValue())
|
|
}
|
|
|
|
// Get reads the container from NeoFS system by binary identifier
|
|
// through Container contract call.
|
|
//
|
|
// If an empty slice is returned for the requested identifier,
|
|
// storage.ErrNotFound error is returned.
|
|
func (w *Wrapper) Get(cid []byte) (*container.Container, error) {
|
|
var args client.GetArgs
|
|
|
|
args.SetCID(cid)
|
|
|
|
// ask RPC neo node to get serialized container
|
|
rpcAnswer, err := w.client.Get(args)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// In #37 we've decided to remove length check, because smart contract would
|
|
// fail on casting `nil` value from storage to `[]byte` producing FAULT state.
|
|
// Apparently it does not fail, so we have to check length explicitly.
|
|
if len(rpcAnswer.Container()) == 0 {
|
|
return nil, core.ErrNotFound
|
|
}
|
|
|
|
// unmarshal container
|
|
cnr := container.New()
|
|
if err := cnr.Unmarshal(rpcAnswer.Container()); err != nil {
|
|
// use other major version if there any
|
|
return nil, fmt.Errorf("can't unmarshal container: %w", err)
|
|
}
|
|
|
|
binToken := rpcAnswer.SessionToken()
|
|
if len(binToken) > 0 {
|
|
tok := session.NewToken()
|
|
|
|
err = tok.Unmarshal(binToken)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("could not unmarshal session token: %w", err)
|
|
}
|
|
|
|
cnr.SetSessionToken(tok)
|
|
}
|
|
|
|
sig := signature.New()
|
|
sig.SetKey(rpcAnswer.PublicKey())
|
|
sig.SetSign(rpcAnswer.Signature())
|
|
|
|
cnr.SetSignature(sig)
|
|
|
|
return cnr, nil
|
|
}
|
|
|
|
// Delete marshals container ID, and passes it to Wrapper's Delete method
|
|
// along with signature and session token.
|
|
//
|
|
// Returns error if container ID is nil.
|
|
func Delete(w *Wrapper, witness core.RemovalWitness) error {
|
|
id := witness.ContainerID()
|
|
if id == nil {
|
|
return errNilArgument
|
|
}
|
|
|
|
binToken, err := witness.SessionToken().Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("could not marshal session token: %w", err)
|
|
}
|
|
|
|
return w.Delete(
|
|
DeletePrm{
|
|
cid: id.ToV2().GetValue(),
|
|
signature: witness.Signature(),
|
|
token: binToken,
|
|
})
|
|
}
|
|
|
|
// DeletePrm groups parameters of Delete client operation.
|
|
type DeletePrm struct {
|
|
cid []byte
|
|
signature []byte
|
|
token []byte
|
|
|
|
staticli.InvokePrmOptional
|
|
}
|
|
|
|
// SetCID sets container ID.
|
|
func (d *DeletePrm) SetCID(cid []byte) {
|
|
d.cid = cid
|
|
}
|
|
|
|
// SetSignature sets signature.
|
|
func (d *DeletePrm) SetSignature(signature []byte) {
|
|
d.signature = signature
|
|
}
|
|
|
|
// SetToken sets session token.
|
|
func (d *DeletePrm) SetToken(token []byte) {
|
|
d.token = token
|
|
}
|
|
|
|
// Delete removes the container from NeoFS system
|
|
// through Container contract call.
|
|
//
|
|
// Returns any error encountered that caused
|
|
// the removal to interrupt.
|
|
//
|
|
// If TryNotary is provided, calls notary contract.
|
|
func (w *Wrapper) Delete(prm DeletePrm) error {
|
|
if len(prm.signature) == 0 {
|
|
return errNilArgument
|
|
}
|
|
|
|
var args client.DeleteArgs
|
|
|
|
args.SetSignature(prm.signature)
|
|
args.SetCID(prm.cid)
|
|
args.SetSessionToken(prm.token)
|
|
args.InvokePrmOptional = prm.InvokePrmOptional
|
|
|
|
return w.client.Delete(args)
|
|
}
|
|
|
|
// List returns a list of container identifiers belonging
|
|
// to the specified owner of NeoFS system. The list is composed
|
|
// through Container contract call.
|
|
//
|
|
// Returns the identifiers of all NeoFS containers if pointer
|
|
// to owner identifier is nil.
|
|
func (w *Wrapper) List(ownerID *owner.ID) ([]*cid.ID, error) {
|
|
args := client.ListArgs{}
|
|
|
|
if ownerID == nil {
|
|
args.SetOwnerID([]byte{})
|
|
} else if v2 := ownerID.ToV2(); v2 == nil {
|
|
return nil, errUnsupported // use other major version if there any
|
|
} else {
|
|
args.SetOwnerID(v2.GetValue())
|
|
}
|
|
|
|
// ask RPC neo node to get serialized container
|
|
rpcAnswer, err := w.client.List(args)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
rawIDs := rpcAnswer.CIDList()
|
|
result := make([]*cid.ID, 0, len(rawIDs))
|
|
|
|
for i := range rawIDs {
|
|
v2 := new(v2refs.ContainerID)
|
|
v2.SetValue(rawIDs[i])
|
|
|
|
id := cid.NewFromV2(v2)
|
|
|
|
result = append(result, id)
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// AnnounceLoadPrm groups parameters of AnnounceLoad operation.
|
|
type AnnounceLoadPrm struct {
|
|
a container.UsedSpaceAnnouncement
|
|
key []byte
|
|
|
|
staticli.InvokePrmOptional
|
|
}
|
|
|
|
// SetAnnouncement sets announcement.
|
|
func (a2 *AnnounceLoadPrm) SetAnnouncement(a container.UsedSpaceAnnouncement) {
|
|
a2.a = a
|
|
}
|
|
|
|
// SetReporter sets public key of the reporter.
|
|
func (a2 *AnnounceLoadPrm) SetReporter(key []byte) {
|
|
a2.key = key
|
|
}
|
|
|
|
// AnnounceLoad saves container size estimation calculated by storage node
|
|
// with key in NeoFS system through Container contract call.
|
|
//
|
|
// Returns any error encountered that caused the saving to interrupt.
|
|
func (w *Wrapper) AnnounceLoad(prm AnnounceLoadPrm) error {
|
|
v2 := prm.a.ContainerID().ToV2()
|
|
if v2 == nil {
|
|
return errUnsupported // use other major version if there any
|
|
}
|
|
|
|
args := client.PutSizeArgs{}
|
|
args.SetContainerID(v2.GetValue())
|
|
args.SetEpoch(prm.a.Epoch())
|
|
args.SetSize(prm.a.UsedSpace())
|
|
args.SetReporterKey(prm.key)
|
|
args.InvokePrmOptional = prm.InvokePrmOptional
|
|
|
|
return w.client.PutSize(args)
|
|
}
|
|
|
|
// EstimationID is an identity of container load estimation inside Container contract.
|
|
type EstimationID []byte
|
|
|
|
// ListLoadEstimationsByEpoch returns a list of container load estimations for to the specified epoch.
|
|
// The list is composed through Container contract call.
|
|
func (w *Wrapper) ListLoadEstimationsByEpoch(epoch uint64) ([]EstimationID, error) {
|
|
args := client.ListSizesArgs{}
|
|
args.SetEpoch(epoch)
|
|
|
|
// ask RPC neo node to get serialized container
|
|
rpcAnswer, err := w.client.ListSizes(args)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
rawIDs := rpcAnswer.IDList()
|
|
result := make([]EstimationID, 0, len(rawIDs))
|
|
|
|
for i := range rawIDs {
|
|
result = append(result, rawIDs[i])
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// Estimation is a structure of single container load estimation
|
|
// reported by storage node.
|
|
type Estimation struct {
|
|
Size uint64
|
|
|
|
Reporter []byte
|
|
}
|
|
|
|
// Estimations is a structure of grouped container load estimation inside Container contract.
|
|
type Estimations struct {
|
|
ContainerID *cid.ID
|
|
|
|
Values []Estimation
|
|
}
|
|
|
|
// GetUsedSpaceEstimations returns a list of container load estimations by ID.
|
|
// The list is composed through Container contract call.
|
|
func (w *Wrapper) GetUsedSpaceEstimations(id EstimationID) (*Estimations, error) {
|
|
args := client.GetSizeArgs{}
|
|
args.SetID(id)
|
|
|
|
rpcAnswer, err := w.client.GetContainerSize(args)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
es := rpcAnswer.Estimations()
|
|
|
|
v2 := new(v2refs.ContainerID)
|
|
v2.SetValue(es.ContainerID)
|
|
|
|
res := &Estimations{
|
|
ContainerID: cid.NewFromV2(v2),
|
|
Values: make([]Estimation, 0, len(es.Estimations)),
|
|
}
|
|
|
|
for i := range es.Estimations {
|
|
res.Values = append(res.Values, Estimation{
|
|
Size: uint64(es.Estimations[i].Size),
|
|
Reporter: es.Estimations[i].Reporter,
|
|
})
|
|
}
|
|
|
|
return res, nil
|
|
}
|