frostfs-http-gw/tree/tree.go

package tree

import (
	"context"
	"fmt"
	"strings"

	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/api"
	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/api/layer"
	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
)

type (
	Tree struct {
		service ServiceClient
	}

	// ServiceClient is a client to interact with tree service.
	// Each method must return ErrNodeNotFound or ErrNodeAccessDenied if relevant.
	ServiceClient interface {
		GetNodes(ctx context.Context, p *GetNodesParams) ([]NodeResponse, error)
	}

	treeNode struct {
		ObjID oid.ID
		Meta  map[string]string
	}

	GetNodesParams struct {
		CnrID      cid.ID
		TreeID     string
		Path       []string
		Meta       []string
		LatestOnly bool
		AllAttrs   bool
	}
)

var (
	// ErrNodeNotFound is returned from ServiceClient in case of not found error.
	ErrNodeNotFound = layer.ErrNodeNotFound

	// ErrNodeAccessDenied is returned from ServiceClient service in case of access denied error.
	ErrNodeAccessDenied = layer.ErrNodeAccessDenied
)

const (
	FileNameKey = "FileName"
)

const (
	oidKV = "OID"

	// keys for delete marker nodes.
	isDeleteMarkerKV = "IsDeleteMarker"

	// versionTree -- ID of a tree with object versions.
	versionTree = "version"

	separator = "/"
)

// NewTree creates instance of Tree using provided address and create grpc connection.
func NewTree(service ServiceClient) *Tree {
	return &Tree{service: service}
}

type Meta interface {
	GetKey() string
	GetValue() []byte
}

type NodeResponse interface {
	GetMeta() []Meta
}

func newTreeNode(nodeInfo NodeResponse) (*treeNode, error) {
	treeNode := &treeNode{
		Meta: make(map[string]string, len(nodeInfo.GetMeta())),
	}

	for _, kv := range nodeInfo.GetMeta() {
		switch kv.GetKey() {
		case oidKV:
			if err := treeNode.ObjID.DecodeString(string(kv.GetValue())); err != nil {
				return nil, err
			}
		default:
			treeNode.Meta[kv.GetKey()] = string(kv.GetValue())
		}
	}

	return treeNode, nil
}

func (n *treeNode) Get(key string) (string, bool) {
	value, ok := n.Meta[key]
	return value, ok
}

func (n *treeNode) FileName() (string, bool) {
	value, ok := n.Meta[FileNameKey]
	return value, ok
}

func newNodeVersion(node NodeResponse) (*api.NodeVersion, error) {
	treeNode, err := newTreeNode(node)
	if err != nil {
		return nil, fmt.Errorf("invalid tree node: %w", err)
	}

	return newNodeVersionFromTreeNode(treeNode), nil
}

func newNodeVersionFromTreeNode(treeNode *treeNode) *api.NodeVersion {
	_, isDeleteMarker := treeNode.Get(isDeleteMarkerKV)

	version := &api.NodeVersion{
		BaseNodeVersion: api.BaseNodeVersion{
			OID: treeNode.ObjID,
		},
		DeleteMarker: isDeleteMarker,
	}

	return version
}

func (c *Tree) GetLatestVersion(ctx context.Context, cnrID *cid.ID, objectName string) (*api.NodeVersion, error) {
	meta := []string{oidKV, isDeleteMarkerKV}
	path := pathFromName(objectName)

	p := &GetNodesParams{
		CnrID:      *cnrID,
		TreeID:     versionTree,
		Path:       path,
		Meta:       meta,
		LatestOnly: true,
		AllAttrs:   false,
	}
	nodes, err := c.service.GetNodes(ctx, p)
	if err != nil {
		return nil, err
	}

	if len(nodes) == 0 {
		return nil, layer.ErrNodeNotFound
	}

	return newNodeVersion(nodes[0])
}

// pathFromName splits name by '/'.
func pathFromName(objectName string) []string {
	return strings.Split(objectName, separator)
}