resolve_ref.go

package ref

import (
	"context"
	"errors"
	"regexp"

	"github.com/treeverse/lakefs/pkg/graveler"
	"github.com/treeverse/lakefs/pkg/ident"
)

type Store interface {
	GetBranch(ctx context.Context, repositoryID graveler.RepositoryID, branchID graveler.BranchID) (*graveler.Branch, error)
	GetTag(ctx context.Context, repositoryID graveler.RepositoryID, tagID graveler.TagID) (*graveler.CommitID, error)
	GetCommitByPrefix(ctx context.Context, repositoryID graveler.RepositoryID, prefix graveler.CommitID) (*graveler.Commit, error)
	GetCommit(ctx context.Context, repositoryID graveler.RepositoryID, prefix graveler.CommitID) (*graveler.Commit, error)
}

type revResolverFunc func(context.Context, Store, ident.AddressProvider, graveler.RepositoryID, string) (*graveler.ResolvedRef, error)

var hashRegexp = regexp.MustCompile("^[a-fA-F0-9]{1,64}$")

func isAHash(part string) bool {
	return hashRegexp.MatchString(part)
}

// revResolve return the first resolve of 'rev' - by hash, branch or tag
func revResolve(ctx context.Context, store Store, addressProvider ident.AddressProvider, repositoryID graveler.RepositoryID, rev string) (*graveler.ResolvedRef, error) {
	resolvers := []revResolverFunc{revResolveAHash, revResolveBranch, revResolveTag}
	for _, resolveHelper := range resolvers {
		r, err := resolveHelper(ctx, store, addressProvider, repositoryID, rev)
		if err != nil {
			return nil, err
		}
		if r != nil {
			return r, nil
		}
	}
	return nil, graveler.ErrNotFound
}

func ResolveRawRef(ctx context.Context, store Store, addressProvider ident.AddressProvider, repositoryID graveler.RepositoryID, rawRef graveler.RawRef) (*graveler.ResolvedRef, error) {
	rr, err := revResolve(ctx, store, addressProvider, repositoryID, rawRef.BaseRef)
	if err != nil {
		return nil, err
	}
	// return the matched reference, when no modifiers on ref or use the commit id as base
	if len(rawRef.Modifiers) == 0 {
		return rr, nil
	}
	baseCommit := rr.CommitID
	for _, mod := range rawRef.Modifiers {
		// lastly, apply modifier
		switch mod.Type {
		case graveler.RefModTypeAt:
			if rr.Type != graveler.ReferenceTypeBranch || len(rawRef.Modifiers) != 1 {
				return nil, graveler.ErrInvalidRef
			}
			return &graveler.ResolvedRef{
				Type:                   graveler.ReferenceTypeBranch,
				ResolvedBranchModifier: graveler.ResolvedBranchModifierCommitted,
				CommitID:               rr.CommitID,
			}, nil

		case graveler.RefModTypeDollar:
			if rr.Type != graveler.ReferenceTypeBranch || len(rawRef.Modifiers) != 1 {
				return nil, graveler.ErrInvalidRef
			}
			return &graveler.ResolvedRef{
				Type:                   graveler.ReferenceTypeBranch,
				ResolvedBranchModifier: graveler.ResolvedBranchModifierStaging,
				StagingToken:           rr.StagingToken,
				CommitID:               rr.CommitID,
				BranchID:               rr.BranchID,
			}, nil

		case graveler.RefModTypeTilde:
			// skip mod.ValueNumeric iterations
			for i := 0; i < mod.Value; i++ {
				commit, err := store.GetCommit(ctx, repositoryID, baseCommit)
				if err != nil {
					return nil, err
				}
				if len(commit.Parents) == 0 {
					return nil, graveler.ErrNotFound
				}
				baseCommit = commit.Parents[0]
			}
		case graveler.RefModTypeCaret:
			if mod.Value == 0 {
				// ^0 = the commit itself
				continue
			}
			// get the commit and extract parents
			c, err := store.GetCommitByPrefix(ctx, repositoryID, baseCommit)
			if err != nil {
				return nil, err
			}
			if mod.Value > len(c.Parents) {
				return nil, graveler.ErrInvalidRef
			}
			baseCommit = c.Parents[mod.Value-1]

		default:
			return nil, graveler.ErrInvalidRef
		}
	}

	return &graveler.ResolvedRef{
		Type:     graveler.ReferenceTypeCommit,
		CommitID: baseCommit,
		BranchID: rr.BranchID,
	}, nil
}

func revResolveAHash(ctx context.Context, store Store, addressProvider ident.AddressProvider, repositoryID graveler.RepositoryID, rev string) (*graveler.ResolvedRef, error) {
	if !isAHash(rev) {
		return nil, nil
	}
	commit, err := store.GetCommitByPrefix(ctx, repositoryID, graveler.CommitID(rev))
	if errors.Is(err, graveler.ErrNotFound) {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	commitID := graveler.CommitID(addressProvider.ContentAddress(commit))
	return &graveler.ResolvedRef{
		Type:     graveler.ReferenceTypeCommit,
		CommitID: commitID,
	}, nil
}

func revResolveBranch(ctx context.Context, store Store, _ ident.AddressProvider, repositoryID graveler.RepositoryID, rev string) (*graveler.ResolvedRef, error) {
	branchID := graveler.BranchID(rev)
	branch, err := store.GetBranch(ctx, repositoryID, branchID)
	if errors.Is(err, graveler.ErrNotFound) {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	return &graveler.ResolvedRef{
		Type:         graveler.ReferenceTypeBranch,
		BranchID:     branchID,
		StagingToken: branch.StagingToken,
		CommitID:     branch.CommitID,
	}, nil
}

func revResolveTag(ctx context.Context, store Store, _ ident.AddressProvider, repositoryID graveler.RepositoryID, rev string) (*graveler.ResolvedRef, error) {
	commitID, err := store.GetTag(ctx, repositoryID, graveler.TagID(rev))
	if errors.Is(err, graveler.ErrNotFound) {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	return &graveler.ResolvedRef{
		Type:     graveler.ReferenceTypeTag,
		CommitID: *commitID,
	}, nil
}