frostfs-node/pkg/network/transport/object/grpc/delete.go

286 lines
6.4 KiB
Go
Raw Normal View History

package object
import (
"context"
"crypto/sha256"
"time"
"github.com/nspcc-dev/neofs-api-go/object"
"github.com/nspcc-dev/neofs-api-go/service"
"github.com/nspcc-dev/neofs-api-go/session"
2020-07-24 13:54:03 +00:00
"github.com/nspcc-dev/neofs-node/pkg/services/object_manager/transformer"
"github.com/nspcc-dev/neofs-node/pkg/services/object_manager/transport"
"github.com/nspcc-dev/neofs-node/pkg/services/object_manager/transport/storagegroup"
"github.com/pkg/errors"
"go.uber.org/zap"
)
type (
objectRemover interface {
delete(context.Context, deleteInfo) error
}
coreObjRemover struct {
delPrep deletePreparer
straightRem objectRemover
tokenStore session.PrivateTokenStore
// Set of potential deletePreparer errors that won't be converted into errDeletePrepare
mErr map[error]struct{}
log *zap.Logger
}
straightObjRemover struct {
tombCreator tombstoneCreator
objStorer objectStorer
}
tombstoneCreator interface {
createTombstone(context.Context, deleteInfo) *Object
}
coreTombCreator struct{}
deletePreparer interface {
prepare(context.Context, deleteInfo) ([]deleteInfo, error)
}
coreDelPreparer struct {
timeout time.Duration
childLister objectChildrenLister
}
deleteInfo interface {
transport.AddressInfo
GetOwnerID() OwnerID
}
rawDeleteInfo struct {
rawAddrInfo
ownerID OwnerID
}
)
const emRemovePart = "could not remove object part #%d of #%d"
var (
_ tombstoneCreator = (*coreTombCreator)(nil)
_ deleteInfo = (*rawDeleteInfo)(nil)
_ deletePreparer = (*coreDelPreparer)(nil)
_ objectRemover = (*straightObjRemover)(nil)
_ objectRemover = (*coreObjRemover)(nil)
_ deleteInfo = (*transportRequest)(nil)
checksumOfEmptyPayload = sha256.Sum256([]byte{})
)
func (s *objectService) Delete(ctx context.Context, req *object.DeleteRequest) (res *object.DeleteResponse, err error) {
defer func() {
if r := recover(); r != nil {
s.log.Error(panicLogMsg,
zap.Stringer("request", object.RequestDelete),
zap.Any("reason", r),
)
err = errServerPanic
}
err = s.statusCalculator.make(requestError{
t: object.RequestDelete,
e: err,
})
}()
if _, err = s.requestHandler.handleRequest(ctx, handleRequestParams{
request: req,
executor: s,
}); err != nil {
return
}
res = makeDeleteResponse()
err = s.respPreparer.prepareResponse(ctx, req, res)
return
}
func (s *coreObjRemover) delete(ctx context.Context, dInfo deleteInfo) error {
token := dInfo.GetSessionToken()
if token == nil {
return errNilToken
}
key := session.PrivateTokenKey{}
key.SetOwnerID(dInfo.GetOwnerID())
key.SetTokenID(token.GetID())
pToken, err := s.tokenStore.Fetch(key)
if err != nil {
return &detailedError{
error: errTokenRetrieval,
d: privateTokenRecvDetails(token.GetID(), token.GetOwnerID()),
}
}
deleteList, err := s.delPrep.prepare(ctx, dInfo)
if err != nil {
if _, ok := s.mErr[errors.Cause(err)]; !ok {
s.log.Error("delete info preparation failure",
zap.String("error", err.Error()),
)
err = errDeletePrepare
}
return err
}
ctx = contextWithValues(ctx,
transformer.PrivateSessionToken, pToken,
transformer.PublicSessionToken, token,
2020-07-24 13:54:03 +00:00
storagegroup.BearerToken, dInfo.GetBearerToken(),
storagegroup.ExtendedHeaders, dInfo.ExtendedHeaders(),
)
for i := range deleteList {
if err := s.straightRem.delete(ctx, deleteList[i]); err != nil {
return errors.Wrapf(err, emRemovePart, i+1, len(deleteList))
}
}
return nil
}
func (s *coreDelPreparer) prepare(ctx context.Context, src deleteInfo) ([]deleteInfo, error) {
var (
ownerID = src.GetOwnerID()
token = src.GetSessionToken()
addr = src.GetAddress()
bearer = src.GetBearerToken()
extHdrs = src.ExtendedHeaders()
)
dInfo := newRawDeleteInfo()
dInfo.setOwnerID(ownerID)
dInfo.setAddress(addr)
dInfo.setTTL(service.NonForwardingTTL)
dInfo.setSessionToken(token)
dInfo.setBearerToken(bearer)
dInfo.setExtendedHeaders(extHdrs)
dInfo.setTimeout(s.timeout)
ctx = contextWithValues(ctx,
transformer.PublicSessionToken, src.GetSessionToken(),
2020-07-24 13:54:03 +00:00
storagegroup.BearerToken, bearer,
storagegroup.ExtendedHeaders, extHdrs,
)
children := s.childLister.children(ctx, addr)
res := make([]deleteInfo, 0, len(children)+1)
res = append(res, dInfo)
for i := range children {
dInfo = newRawDeleteInfo()
dInfo.setOwnerID(ownerID)
dInfo.setAddress(Address{
ObjectID: children[i],
CID: addr.CID,
})
dInfo.setTTL(service.NonForwardingTTL)
dInfo.setSessionToken(token)
dInfo.setBearerToken(bearer)
dInfo.setExtendedHeaders(extHdrs)
dInfo.setTimeout(s.timeout)
res = append(res, dInfo)
}
return res, nil
}
func (s *straightObjRemover) delete(ctx context.Context, dInfo deleteInfo) error {
putInfo := newRawPutInfo()
putInfo.setHead(
s.tombCreator.createTombstone(ctx, dInfo),
)
putInfo.setSessionToken(dInfo.GetSessionToken())
putInfo.setBearerToken(dInfo.GetBearerToken())
putInfo.setExtendedHeaders(dInfo.ExtendedHeaders())
putInfo.setTTL(dInfo.GetTTL())
putInfo.setTimeout(dInfo.GetTimeout())
_, err := s.objStorer.putObject(ctx, putInfo)
return err
}
func (s *coreTombCreator) createTombstone(ctx context.Context, dInfo deleteInfo) *Object {
addr := dInfo.GetAddress()
obj := &Object{
SystemHeader: SystemHeader{
ID: addr.ObjectID,
CID: addr.CID,
OwnerID: dInfo.GetOwnerID(),
},
Headers: []Header{
{
Value: &object.Header_Tombstone{
Tombstone: new(object.Tombstone),
},
},
{
Value: &object.Header_PayloadChecksum{
PayloadChecksum: checksumOfEmptyPayload[:],
},
},
},
}
return obj
}
func (s *rawDeleteInfo) GetAddress() Address {
return s.addr
}
func (s *rawDeleteInfo) setAddress(addr Address) {
s.addr = addr
}
func (s *rawDeleteInfo) GetOwnerID() OwnerID {
return s.ownerID
}
func (s *rawDeleteInfo) setOwnerID(id OwnerID) {
s.ownerID = id
}
func (s *rawDeleteInfo) setAddrInfo(v *rawAddrInfo) {
s.rawAddrInfo = *v
s.setType(object.RequestDelete)
}
func newRawDeleteInfo() *rawDeleteInfo {
res := new(rawDeleteInfo)
res.setAddrInfo(newRawAddressInfo())
return res
}
func (s *transportRequest) GetToken() *session.Token {
return s.serviceRequest.(*object.DeleteRequest).GetToken()
}
func (s *transportRequest) GetHead() *Object {
return &Object{SystemHeader: SystemHeader{
ID: s.serviceRequest.(*object.DeleteRequest).Address.ObjectID,
}}
}
func (s *transportRequest) GetOwnerID() OwnerID {
return s.serviceRequest.(*object.DeleteRequest).OwnerID
}