Make cleaner sepeartion between name.Tag and name.Digest paths (WIP)

Signed-off-by: Ilya Dmitrichenko <[email protected]>

Author: errordeveloper

internal/controller/ocirepository_controller.go

@@ -391,6 +391,7 @@ func (r *OCIRepositoryReconciler) reconcileSource(ctx context.Context, sp *patch
 	}
 
 	// Get the upstream revision from the artifact digest
+	// TODO: getRevision resolves the digest, which may change before image is fetched, so it should probaly update ref
 	revision, err := r.getRevision(ref, opts)
 	if err != nil {
 		e := serror.NewGeneric(
@@ -575,33 +576,30 @@ func (r *OCIRepositoryReconciler) selectLayer(obj *ociv1.OCIRepository, image gc
 // getRevision fetches the upstream digest, returning the revision in the
 // format '<tag>@<digest>'.
 func (r *OCIRepositoryReconciler) getRevision(ref name.Reference, options []remote.Option) (string, error) {
-	repoTag := "" // TODO: can it be obtained from name.Reference directly?
-	repoName := ref.Context().RepositoryStr()
-	if s := strings.Split(repoName, ":"); len(s) == 2 && !strings.Contains(repoName, "@") {
-		repoTag = s[1]
-	}
-
-	if repoTag == "" && !strings.Contains(repoName, "@") {
-		repoTag = "latest"
-	}
-
-	var digest v1.Hash
-	desc, err := remote.Head(ref, options...)
-	if err == nil {
-		digest = desc.Digest
-	} else {
-		rdesc, err := remote.Get(ref, options...)
+	switch ref := ref.(type) {
+	case name.Digest:
+		digest, err := v1.NewHash(ref.DigestStr())
 		if err != nil {
 			return "", err
 		}
-		digest = rdesc.Descriptor.Digest
-	}
+		return digest.String(), nil
+	case name.Tag:
+		var digest v1.Hash
 
-	revision := digest.String()
-	if repoTag != "" {
-		revision = fmt.Sprintf("%s@%s", repoTag, revision)
+		desc, err := remote.Head(ref, options...)
+		if err == nil {
+			digest = desc.Digest
+		} else {
+			rdesc, err := remote.Get(ref, options...)
+			if err != nil {
+				return "", err
+			}
+			digest = rdesc.Descriptor.Digest
+		}
+		return fmt.Sprintf("%s@%s", ref.TagStr(), digest.String()), nil
+	default:
+		return "", fmt.Errorf("unsupported reference type: %T", ref)
 	}
-	return revision, nil
 }
 
 // digestFromRevision extracts the digest from the revision string.
@@ -696,53 +694,53 @@ func (r *OCIRepositoryReconciler) verifySignature(ctx context.Context, obj *ociv
 }
 
 // parseRepository validates and extracts the repository URL.
-func (r *OCIRepositoryReconciler) parseRepository(obj *ociv1.OCIRepository) (name.Reference, error) {
-	if !strings.HasPrefix(obj.Spec.URL, ociv1.OCIRepositoryPrefix) {
-		return nil, fmt.Errorf("URL must be in format 'oci://<domain>/<org>/<repo>'")
+func (r *OCIRepositoryReconciler) parseRepository(url string) (name.Repository, error) {
+	if !strings.HasPrefix(url, ociv1.OCIRepositoryPrefix) {
+		return name.Repository{}, fmt.Errorf("URL must be in format 'oci://<domain>/<org>/<repo>'")
 	}
 
-	url := strings.TrimPrefix(obj.Spec.URL, ociv1.OCIRepositoryPrefix)
-	ref, err := name.ParseReference(url)
+	url = strings.TrimPrefix(url, ociv1.OCIRepositoryPrefix)
+	repo, err := name.NewRepository(url)
 	if err != nil {
-		return nil, err
+		return name.Repository{}, err
 	}
 
-	imageName := strings.TrimPrefix(url, ref.Context().RegistryStr())
+	imageName := strings.TrimPrefix(url, repo.RegistryStr())
 	if s := strings.Split(imageName, ":"); len(s) > 1 {
-		return nil, fmt.Errorf("URL must not contain a tag; remove ':%s'", s[1])
+		return name.Repository{}, fmt.Errorf("URL must not contain a tag; remove ':%s'", s[1])
 	}
 
-	return ref, nil
+	return repo, nil
 }
 
 // getArtifactRef determines which tag or revision should be used and returns the OCI artifact FQN.
 func (r *OCIRepositoryReconciler) getArtifactRef(obj *ociv1.OCIRepository, options []remote.Option) (name.Reference, error) {
-	ref, err := r.parseRepository(obj)
+	repo, err := r.parseRepository(obj.Spec.URL)
 	if err != nil {
 		return nil, invalidOCIURLError{err}
 	}
 
 	if obj.Spec.Reference != nil {
 		if obj.Spec.Reference.Digest != "" {
-			return ref.Context().Digest(fmt.Sprintf("%s@%s", ref, obj.Spec.Reference.Digest)), nil
+			return repo.Digest(obj.Spec.Reference.Digest), nil
 		}
 
 		if obj.Spec.Reference.SemVer != "" {
-			return r.getTagBySemver(ref, obj.Spec.Reference.SemVer, options)
+			return r.getTagBySemver(repo, obj.Spec.Reference.SemVer, options)
 		}
 
 		if obj.Spec.Reference.Tag != "" {
-			return ref.Context().Tag(obj.Spec.Reference.Tag), nil
+			return repo.Tag(obj.Spec.Reference.Tag), nil
 		}
 	}
 
-	return ref, nil
+	return repo.Tag("latest"), nil
 }
 
 // getTagBySemver call the remote container registry, fetches all the tags from the repository,
 // and returns the latest tag according to the semver expression.
-func (r *OCIRepositoryReconciler) getTagBySemver(ref name.Reference, exp string, options []remote.Option) (name.Reference, error) {
-	tags, err := remote.List(ref.Context().Repo(), options...)
+func (r *OCIRepositoryReconciler) getTagBySemver(repo name.Repository, exp string, options []remote.Option) (name.Reference, error) {
+	tags, err := remote.List(repo, options...)
 	if err != nil {
 		return nil, err
 	}
@@ -769,7 +767,7 @@ func (r *OCIRepositoryReconciler) getTagBySemver(ref name.Reference, exp string,
 	}
 
 	sort.Sort(sort.Reverse(semver.Collection(matchingVersions)))
-	return ref.Context().Tag(matchingVersions[0].Original()), nil
+	return repo.Tag(matchingVersions[0].Original()), nil
 }
 
 // keychain generates the credential keychain based on the resource