234 lines
7.4 KiB
Go
234 lines
7.4 KiB
Go
package ape
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"fmt"
|
|
"net"
|
|
"strconv"
|
|
|
|
objectV2 "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/object"
|
|
aperequest "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/ape/request"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/netmap"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/object"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/acl"
|
|
cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
|
|
objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
|
|
oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/user"
|
|
commonschema "git.frostfs.info/TrueCloudLab/policy-engine/schema/common"
|
|
nativeschema "git.frostfs.info/TrueCloudLab/policy-engine/schema/native"
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
|
|
"google.golang.org/grpc/peer"
|
|
)
|
|
|
|
var defaultRequest = aperequest.Request{}
|
|
|
|
func nativeSchemaRole(role acl.Role) string {
|
|
switch role {
|
|
case acl.RoleOwner:
|
|
return nativeschema.PropertyValueContainerRoleOwner
|
|
case acl.RoleContainer:
|
|
return nativeschema.PropertyValueContainerRoleContainer
|
|
case acl.RoleInnerRing:
|
|
return nativeschema.PropertyValueContainerRoleIR
|
|
case acl.RoleOthers:
|
|
return nativeschema.PropertyValueContainerRoleOthers
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func resourceName(cid cid.ID, oid *oid.ID, namespace string) string {
|
|
if namespace == "root" || namespace == "" {
|
|
if oid != nil {
|
|
return fmt.Sprintf(nativeschema.ResourceFormatRootContainerObject, cid.EncodeToString(), oid.EncodeToString())
|
|
}
|
|
return fmt.Sprintf(nativeschema.ResourceFormatRootContainerObjects, cid.EncodeToString())
|
|
}
|
|
if oid != nil {
|
|
return fmt.Sprintf(nativeschema.ResourceFormatNamespaceContainerObject, namespace, cid.EncodeToString(), oid.EncodeToString())
|
|
}
|
|
return fmt.Sprintf(nativeschema.ResourceFormatNamespaceContainerObjects, namespace, cid.EncodeToString())
|
|
}
|
|
|
|
// objectProperties collects object properties from address parameters and a header if it is passed.
|
|
func objectProperties(cnr cid.ID, oid *oid.ID, cnrOwner user.ID, header *objectV2.Header) map[string]string {
|
|
objectProps := map[string]string{
|
|
nativeschema.PropertyKeyObjectContainerID: cnr.EncodeToString(),
|
|
}
|
|
|
|
objectProps[nativeschema.PropertyKeyContainerOwnerID] = cnrOwner.EncodeToString()
|
|
|
|
if oid != nil {
|
|
objectProps[nativeschema.PropertyKeyObjectID] = oid.String()
|
|
}
|
|
|
|
if header == nil {
|
|
return objectProps
|
|
}
|
|
|
|
objV2 := new(objectV2.Object)
|
|
objV2.SetHeader(header)
|
|
objSDK := objectSDK.NewFromV2(objV2)
|
|
|
|
objectProps[nativeschema.PropertyKeyObjectVersion] = objSDK.Version().String()
|
|
objectProps[nativeschema.PropertyKeyObjectOwnerID] = objSDK.OwnerID().EncodeToString()
|
|
objectProps[nativeschema.PropertyKeyObjectCreationEpoch] = strconv.Itoa(int(objSDK.CreationEpoch()))
|
|
objectProps[nativeschema.PropertyKeyObjectPayloadLength] = strconv.Itoa(int(objSDK.PayloadSize()))
|
|
objectProps[nativeschema.PropertyKeyObjectType] = objSDK.Type().String()
|
|
|
|
pcs, isSet := objSDK.PayloadChecksum()
|
|
if isSet {
|
|
objectProps[nativeschema.PropertyKeyObjectPayloadHash] = pcs.String()
|
|
}
|
|
hcs, isSet := objSDK.PayloadHomomorphicHash()
|
|
if isSet {
|
|
objectProps[nativeschema.PropertyKeyObjectHomomorphicHash] = hcs.String()
|
|
}
|
|
|
|
for _, attr := range header.GetAttributes() {
|
|
objectProps[attr.GetKey()] = attr.GetValue()
|
|
}
|
|
|
|
return objectProps
|
|
}
|
|
|
|
// newAPERequest creates an APE request to be passed to a chain router. It collects resource properties from
|
|
// header provided by headerProvider. If it cannot be found in headerProvider, then properties are
|
|
// initialized from header given in prm (if it is set). Otherwise, just CID and OID are set to properties.
|
|
func (c *checkerImpl) newAPERequest(ctx context.Context, prm Prm) (aperequest.Request, error) {
|
|
switch prm.Method {
|
|
case nativeschema.MethodGetObject,
|
|
nativeschema.MethodHeadObject,
|
|
nativeschema.MethodRangeObject,
|
|
nativeschema.MethodHashObject,
|
|
nativeschema.MethodDeleteObject,
|
|
nativeschema.MethodPatchObject:
|
|
if prm.Object == nil {
|
|
return defaultRequest, fmt.Errorf("method %s: %w", prm.Method, errMissingOID)
|
|
}
|
|
case nativeschema.MethodSearchObject, nativeschema.MethodPutObject:
|
|
default:
|
|
return defaultRequest, fmt.Errorf("unknown method: %s", prm.Method)
|
|
}
|
|
|
|
var header *objectV2.Header
|
|
if prm.Header != nil {
|
|
header = prm.Header
|
|
} else if prm.Object != nil && !prm.WithoutHeaderRequest {
|
|
headerObjSDK, err := c.headerProvider.GetHeader(ctx, prm.Container, *prm.Object, true)
|
|
if err == nil {
|
|
header = headerObjSDK.ToV2().GetHeader()
|
|
}
|
|
}
|
|
header = c.fillHeaderWithECParent(ctx, prm, header)
|
|
reqProps := map[string]string{
|
|
nativeschema.PropertyKeyActorPublicKey: prm.SenderKey,
|
|
nativeschema.PropertyKeyActorRole: prm.Role,
|
|
}
|
|
|
|
for _, xhead := range prm.XHeaders {
|
|
xheadKey := fmt.Sprintf(commonschema.PropertyKeyFrostFSXHeader, xhead.GetKey())
|
|
reqProps[xheadKey] = xhead.GetValue()
|
|
}
|
|
|
|
var err error
|
|
reqProps, err = c.fillWithUserClaimTags(reqProps, prm)
|
|
if err != nil {
|
|
return defaultRequest, err
|
|
}
|
|
|
|
if p, ok := peer.FromContext(ctx); ok {
|
|
if tcpAddr, ok := p.Addr.(*net.TCPAddr); ok {
|
|
reqProps[commonschema.PropertyKeyFrostFSSourceIP] = tcpAddr.IP.String()
|
|
}
|
|
}
|
|
|
|
return aperequest.NewRequest(
|
|
prm.Method,
|
|
aperequest.NewResource(
|
|
resourceName(prm.Container, prm.Object, prm.Namespace),
|
|
objectProperties(prm.Container, prm.Object, prm.ContainerOwner, header),
|
|
),
|
|
reqProps,
|
|
), nil
|
|
}
|
|
|
|
func (c *checkerImpl) fillHeaderWithECParent(ctx context.Context, prm Prm, header *objectV2.Header) *objectV2.Header {
|
|
if header == nil {
|
|
return header
|
|
}
|
|
if header.GetEC() == nil {
|
|
return header
|
|
}
|
|
if prm.Role == nativeschema.PropertyValueContainerRoleContainer ||
|
|
prm.Role == nativeschema.PropertyValueContainerRoleIR {
|
|
return header
|
|
}
|
|
parentObjRefID := header.GetEC().Parent
|
|
if parentObjRefID == nil {
|
|
return header
|
|
}
|
|
var parentObjID oid.ID
|
|
if err := parentObjID.ReadFromV2(*parentObjRefID); err != nil {
|
|
return header
|
|
}
|
|
// only container node have access to collect parent object
|
|
contNode, err := c.currentNodeIsContainerNode(prm.Container)
|
|
if err != nil || !contNode {
|
|
return header
|
|
}
|
|
parentObj, err := c.headerProvider.GetHeader(ctx, prm.Container, parentObjID, false)
|
|
if err != nil {
|
|
return header
|
|
}
|
|
return parentObj.ToV2().GetHeader()
|
|
}
|
|
|
|
func (c *checkerImpl) currentNodeIsContainerNode(cnrID cid.ID) (bool, error) {
|
|
cnr, err := c.cnrSource.Get(cnrID)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
nm, err := netmap.GetLatestNetworkMap(c.nm)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
idCnr := make([]byte, sha256.Size)
|
|
cnrID.Encode(idCnr)
|
|
|
|
in, err := object.LookupKeyInContainer(nm, c.nodePK, idCnr, cnr.Value)
|
|
if err != nil {
|
|
return false, err
|
|
} else if in {
|
|
return true, nil
|
|
}
|
|
|
|
nm, err = netmap.GetPreviousNetworkMap(c.nm)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
return object.LookupKeyInContainer(nm, c.nodePK, idCnr, cnr.Value)
|
|
}
|
|
|
|
// fillWithUserClaimTags fills ape request properties with user claim tags getting them from frostfsid contract by actor public key.
|
|
func (c *checkerImpl) fillWithUserClaimTags(reqProps map[string]string, prm Prm) (map[string]string, error) {
|
|
if reqProps == nil {
|
|
reqProps = make(map[string]string)
|
|
}
|
|
pk, err := keys.NewPublicKeyFromString(prm.SenderKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
props, err := aperequest.FormFrostfsIDRequestProperties(c.frostFSIDClient, pk)
|
|
if err != nil {
|
|
return reqProps, err
|
|
}
|
|
for propertyName, properyValue := range props {
|
|
reqProps[propertyName] = properyValue
|
|
}
|
|
return reqProps, nil
|
|
}
|