[#11] services/container: Implement Neo:Morph executor and service

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

pkg/services/container/morph/executor.go

@@ -0,0 +1,179 @@
+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
+}