frostfs-node/pkg/services/container/morph/executor.go

180 lines
5 KiB
Go
Raw Normal View History

package container
import (
"context"
"crypto/sha256"
"github.com/nspcc-dev/neofs-api-go/v2/acl"
aclGRPC "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
"github.com/nspcc-dev/neofs-api-go/v2/container"
container2 "github.com/nspcc-dev/neofs-api-go/v2/container/grpc"
"github.com/nspcc-dev/neofs-api-go/v2/refs"
containerMorph "github.com/nspcc-dev/neofs-node/pkg/morph/client/container"
containerSvc "github.com/nspcc-dev/neofs-node/pkg/services/container"
"github.com/pkg/errors"
)
type morphExecutor struct {
// TODO: use client wrapper
client *containerMorph.Client
}
func NewExecutor(client *containerMorph.Client) containerSvc.ServiceExecutor {
return &morphExecutor{
client: client,
}
}
func (s *morphExecutor) Put(ctx context.Context, body *container.PutRequestBody) (*container.PutResponseBody, error) {
cnr := body.GetContainer()
// marshal owner ID of the container
ownerBytes, err := cnr.GetOwnerID().StableMarshal(nil)
if err != nil {
return nil, errors.Wrap(err, "could not marshal owner ID")
}
// marshal the container
cnrBytes, err := cnr.StableMarshal(nil)
if err != nil {
return nil, errors.Wrap(err, "could not marshal the container")
}
args := containerMorph.PutArgs{}
args.SetOwnerID(ownerBytes)
args.SetContainer(cnrBytes)
args.SetSignature(body.GetSignature().GetSign())
if err := s.client.Put(args); err != nil {
return nil, errors.Wrap(err, "could not call Put method")
}
res := new(container.PutResponseBody)
// FIXME: implement and use CID calculation
cidBytes := sha256.Sum256(cnrBytes)
cid := new(refs.ContainerID)
cid.SetValue(cidBytes[:])
res.SetContainerID(cid)
return res, nil
}
func (s *morphExecutor) Delete(ctx context.Context, body *container.DeleteRequestBody) (*container.DeleteResponseBody, error) {
// marshal container identifier
cidBytes, err := body.GetContainerID().StableMarshal(nil)
if err != nil {
return nil, errors.Wrap(err, "could not marshal container ID")
}
args := containerMorph.DeleteArgs{}
args.SetCID(cidBytes)
args.SetSignature(body.GetSignature().GetSign())
if err := s.client.Delete(args); err != nil {
return nil, errors.Wrap(err, "could not call Delete method")
}
return new(container.DeleteResponseBody), nil
}
func (s *morphExecutor) Get(ctx context.Context, body *container.GetRequestBody) (*container.GetResponseBody, error) {
args := containerMorph.GetArgs{}
args.SetCID(body.GetContainerID().GetValue())
val, err := s.client.Get(args)
if err != nil {
return nil, errors.Wrap(err, "could not call Get method")
}
// FIXME: implement and use stable unmarshaler
cnrGRPC := new(container2.Container)
if err := cnrGRPC.Unmarshal(val.Container()); err != nil {
return nil, errors.Wrap(err, "could not unmarshal the container")
}
res := new(container.GetResponseBody)
res.SetContainer(container.ContainerFromGRPCMessage(cnrGRPC))
return res, nil
}
func (s *morphExecutor) List(ctx context.Context, body *container.ListRequestBody) (*container.ListResponseBody, error) {
// marshal owner ID
ownerBytes, err := body.GetOwnerID().StableMarshal(nil)
if err != nil {
return nil, errors.Wrap(err, "could not marshal owner ID")
}
args := containerMorph.ListArgs{}
args.SetOwnerID(ownerBytes)
val, err := s.client.List(args)
if err != nil {
return nil, errors.Wrap(err, "could not call List method")
}
binCidList := val.CIDList()
cidList := make([]*refs.ContainerID, 0, len(binCidList))
for i := range binCidList {
cid := new(refs.ContainerID)
cid.SetValue(binCidList[i])
cidList = append(cidList, cid)
}
res := new(container.ListResponseBody)
res.SetContainerIDs(cidList)
return res, nil
}
func (s *morphExecutor) SetExtendedACL(ctx context.Context, body *container.SetExtendedACLRequestBody) (*container.SetExtendedACLResponseBody, error) {
eacl := body.GetEACL()
cidBytes, err := eacl.GetContainerID().StableMarshal(nil)
if err != nil {
return nil, errors.Wrap(err, "could not marshal container ID")
}
eaclBytes, err := eacl.StableMarshal(nil)
if err != nil {
return nil, errors.Wrap(err, "could not marshal eACL table")
}
args := containerMorph.SetEACLArgs{}
args.SetCID(cidBytes)
args.SetEACL(eaclBytes)
args.SetSignature(body.GetSignature().GetSign())
if err := s.client.SetEACL(args); err != nil {
return nil, errors.Wrap(err, "could not call SetEACL method")
}
return new(container.SetExtendedACLResponseBody), nil
}
func (s *morphExecutor) GetExtendedACL(ctx context.Context, req *container.GetExtendedACLRequestBody) (*container.GetExtendedACLResponseBody, error) {
args := containerMorph.EACLArgs{}
args.SetCID(req.GetContainerID().GetValue())
val, err := s.client.EACL(args)
if err != nil {
return nil, errors.Wrap(err, "could not call EACL method")
}
// FIXME: implement and use stable unmarshaler
eaclGRPC := new(aclGRPC.EACLTable)
if err := eaclGRPC.Unmarshal(val.EACL()); err != nil {
return nil, errors.Wrap(err, "could not unmarshal eACL table")
}
eacl := acl.TableFromGRPCMessage(eaclGRPC)
res := new(container.GetExtendedACLResponseBody)
res.SetEACL(eacl)
return res, nil
}