Migrate package command from gcr to oras

Author: DhairyaMajmudar

cmd/kro/commands/package/package.go

@@ -15,19 +15,18 @@
 package commands
 
 import (
+	"archive/tar"
+	"context"
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
-	"time"
-
-	"github.com/google/go-containerregistry/pkg/name"
-	v1 "github.com/google/go-containerregistry/pkg/v1"
-	"github.com/google/go-containerregistry/pkg/v1/empty"
-	"github.com/google/go-containerregistry/pkg/v1/mutate"
-	"github.com/google/go-containerregistry/pkg/v1/static"
-	"github.com/google/go-containerregistry/pkg/v1/tarball"
-	"github.com/google/go-containerregistry/pkg/v1/types"
+	"strings"
+
+	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/spf13/cobra"
+	oras "oras.land/oras-go/v2"
+	"oras.land/oras-go/v2/content/oci"
 	"sigs.k8s.io/yaml"
 
 	"github.com/kro-run/kro/api/v1alpha1"
@@ -42,7 +41,7 @@ var packageConfig = &PackageConfig{}
 
 func init() {
 	packageRGDCmd.PersistentFlags().StringVarP(&packageConfig.resourceGraphDefinitionFile,
-		"file", "f", "",
+		"file", "f", "rgd.yaml",
 		"Path to the ResourceGraphDefinition file",
 	)
 
@@ -55,7 +54,7 @@ var packageRGDCmd = &cobra.Command{
 	Use:   "package",
 	Short: "Create an OCI Image packaging the ResourceGraphDefinition",
 	Long: "Package command packages the ResourceGraphDefinition" +
-		"file into an OCI image, which can be used for distribution and deployment.",
+		"file into an OCI image bundle, which can be used for distribution and deployment.",
 	RunE: func(cmd *cobra.Command, args []string) error {
 		if packageConfig.resourceGraphDefinitionFile == "" {
 			return fmt.Errorf("ResourceGraphDefinition file is required")
@@ -72,61 +71,142 @@ var packageRGDCmd = &cobra.Command{
 		}
 
 		basename := filepath.Base(packageConfig.resourceGraphDefinitionFile)
-		extension := filepath.Ext(basename)
-		nameWithoutExt := basename[:len(basename)-len(extension)]
-		outputFile := nameWithoutExt + ".tar"
+		ext := filepath.Ext(basename)
+		nameWithoutExt := basename[:len(basename)-len(ext)]
+		outputTar := nameWithoutExt + ".tar"
 
-		if err = packageRGD(outputFile, data, &rgd); err != nil {
+		if err := packageRGD(outputTar, data, &rgd); err != nil {
 			return fmt.Errorf("failed to package ResourceGraphDefinition: %w", err)
 		}
 
-		fmt.Println("Successfully packaged ResourceGraphDefinition to", outputFile)
-
+		fmt.Println("Successfully packaged ResourceGraphDefinition to", outputTar)
 		return nil
 	},
 }
 
-func packageRGD(outputFile string, data []byte, rgd *v1alpha1.ResourceGraphDefinition) error {
-	layer := static.NewLayer(data, types.MediaType("application/vnd.kro.resourcegraphdefinition.v1alpha1+yaml"))
-
-	img := empty.Image
-
-	img, err := mutate.AppendLayers(img, layer)
+func packageRGD(outputTar string, data []byte, rgd *v1alpha1.ResourceGraphDefinition) error {
+	ctx := context.Background()
 
+	tempDir, err := os.MkdirTemp("", "kro-oci-*")
 	if err != nil {
-		return fmt.Errorf("failed to append layer: %w", err)
+		return fmt.Errorf("failed to create temp dir: %w", err)
 	}
+	defer func() {
+		if err := os.RemoveAll(tempDir); err != nil {
+			fmt.Println("failed to remove temp dir", tempDir, ":", err)
+		}
+	}()
 
-	configFile, err := img.ConfigFile()
+	store, err := oci.New(tempDir)
 	if err != nil {
-		return fmt.Errorf("failed to get config file: %w", err)
+		return fmt.Errorf("failed to create OCI layout store: %w", err)
 	}
 
-	now := time.Now()
-	configFile.Created = v1.Time{Time: now}
+	mediaType := "application/vnd.kro.resourcegraphdefinition"
+	blobDesc, err := oras.PushBytes(ctx, store, mediaType, data)
+	if err != nil {
+		return fmt.Errorf("failed to push RGD blob: %w", err)
+	}
 
-	configFile.Config.Labels = map[string]string{
-		"kro.run/type": "resourcegraphdefinition",
-		"kro.run/name": rgd.Name,
+	layer := blobDesc
+	if layer.Annotations == nil {
+		layer.Annotations = map[string]string{}
+	}
+	layer.Annotations[ocispec.AnnotationTitle] = filepath.Base(packageConfig.resourceGraphDefinitionFile)
+
+	artifactType := "application/vnd.kro.resourcegraphdefinition"
+	packOpts := oras.PackManifestOptions{
+		Layers: []ocispec.Descriptor{layer},
+		ManifestAnnotations: map[string]string{
+			"kro.run/type": "resourcegraphdefinition",
+			"kro.run/name": rgd.Name,
+		},
 	}
 
-	img, err = mutate.ConfigFile(img, configFile)
+	manifestDesc, err := oras.PackManifest(ctx, store, oras.PackManifestVersion1_1, artifactType, packOpts)
 	if err != nil {
-		return fmt.Errorf("failed to update image config: %w", err)
+		return fmt.Errorf("failed to pack manifest: %w", err)
 	}
 
-	ref, err := name.ParseReference(fmt.Sprintf("kro.run/rgd/%s:%s", rgd.Name, packageConfig.tag))
-	if err != nil {
-		return fmt.Errorf("failed to parse image reference: %w", err)
+	tag := fmt.Sprintf("%s:%s", rgd.Name, packageConfig.tag)
+	if err := store.Tag(ctx, manifestDesc, tag); err != nil {
+		return fmt.Errorf("failed to tag manifest in layout: %w", err)
 	}
 
-	if err := tarball.WriteToFile(outputFile, ref, img); err != nil {
-		return fmt.Errorf("failed to write image to file: %w", err)
+	if err := os.RemoveAll(filepath.Join(tempDir, "ingest")); err != nil {
+		fmt.Println("failed to remove ingest folder: ", err)
+	}
+
+	if err := tarDir(tempDir, outputTar); err != nil {
+		return fmt.Errorf("failed to write OCI layout tar: %w", err)
 	}
 
 	return nil
 }
 
+func tarDir(srcDir, tarPath string) error {
+	out, err := os.Create(tarPath)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err := out.Close(); err != nil {
+			fmt.Println("failed to close tar file: ", err)
+		}
+	}()
+
+	tw := tar.NewWriter(out)
+	defer func() {
+		if err := tw.Close(); err != nil {
+			fmt.Println("failed to close tar writer: ", err)
+		}
+	}()
+
+	return filepath.WalkDir(srcDir, func(path string, d os.DirEntry, err error) error {
+		if err != nil || path == srcDir {
+			return err
+		}
+
+		info, _ := d.Info()
+		rel, _ := filepath.Rel(srcDir, path)
+		rel = filepath.ToSlash(rel)
+
+		switch {
+		case strings.HasPrefix(rel, "ingest/"),
+			strings.HasPrefix(rel, "blobs/sha256/") && info.Size() == 0,
+			filepath.Clean(path) == filepath.Clean(tarPath):
+			return nil
+		}
+
+		hdr, err := tar.FileInfoHeader(info, "")
+		if err != nil {
+			return err
+		}
+		hdr.Name = rel
+
+		if err := tw.WriteHeader(hdr); err != nil {
+			return err
+		}
+
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+
+		f, err := os.Open(path)
+		if err != nil {
+			return err
+		}
+		defer func() {
+			if err := f.Close(); err != nil {
+				fmt.Println("failed to close file ", path, ":", err)
+			}
+		}()
+
+		_, err = io.Copy(tw, f)
+		return err
+	})
+}
+
 func AddPackageCommand(rootCmd *cobra.Command) {
 	rootCmd.AddCommand(packageRGDCmd)
 }

cmd/kro/commands/publish/publish.go

@@ -0,0 +1,173 @@
+// Copyright 2025 The Kube Resource Orchestrator Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"archive/tar"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
+	"github.com/spf13/cobra"
+	"oras.land/oras-go/v2"
+	"oras.land/oras-go/v2/content/oci"
+	"oras.land/oras-go/v2/registry/remote"
+)
+
+type PublishConfig struct {
+	ociTarballPath string
+	remoteRef      string
+}
+
+var publishConfig = &PublishConfig{}
+
+func init() {
+	publishCmd.PersistentFlags().StringVarP(&publishConfig.ociTarballPath,
+		"file", "f", "",
+		"Path to the OCI image tarball created by the 'package' command",
+	)
+	publishCmd.PersistentFlags().StringVarP(&publishConfig.remoteRef,
+		"ref", "r", "",
+		"Remote reference to publish the OCI image to (e.g., 'ghcr.io/user/repo:tag')",
+	)
+}
+
+var publishCmd = &cobra.Command{
+	Use:   "publish",
+	Short: "Publish a packaged OCI image to a remote registry",
+	Long: "The publish command takes an OCI image tarball, created by the 'package' command, " +
+		"and pushes it to a specified container registry.",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if publishConfig.ociTarballPath == "" {
+			return fmt.Errorf("path to the OCI tarball is required, please use the --file flag")
+		}
+		if publishConfig.remoteRef == "" {
+			return fmt.Errorf("remote reference is required, please use the --ref flag")
+		}
+
+		tempDir, err := os.MkdirTemp("", "kro-publish-*")
+		if err != nil {
+			return fmt.Errorf("failed to create temp dir: %w", err)
+		}
+		defer func() {
+			if err := os.RemoveAll(tempDir); err != nil {
+				fmt.Printf("Warning: failed to remove temp dir %s: %v\n", tempDir, err)
+			}
+		}()
+
+		fmt.Printf("Extracting %s to %s...\n", publishConfig.ociTarballPath, tempDir)
+		if err := untar(publishConfig.ociTarballPath, tempDir); err != nil {
+			return fmt.Errorf("failed to extract OCI tarball: %w", err)
+		}
+
+		store, err := oci.New(tempDir)
+		if err != nil {
+			return fmt.Errorf("failed to open OCI layout at %s: %w", tempDir, err)
+		}
+
+		rootDesc, err := findRootManifestDescriptor(tempDir)
+		if err != nil {
+			return fmt.Errorf("failed to find root manifest in OCI layout: %w", err)
+		}
+		fmt.Printf("Found manifest to push: %s\n", rootDesc.Digest)
+
+		ctx := context.Background()
+		repo, err := remote.NewRepository(publishConfig.remoteRef)
+		if err != nil {
+			return fmt.Errorf("failed to create remote repository for %s: %w", publishConfig.remoteRef, err)
+		}
+
+		fmt.Printf("Publishing to %s...\n", publishConfig.remoteRef)
+		_, err = oras.Copy(ctx, store, rootDesc.Digest.String(), repo, publishConfig.remoteRef, oras.DefaultCopyOptions)
+		if err != nil {
+			return fmt.Errorf("failed to publish OCI image: %w", err)
+		}
+
+		fmt.Println("Successfully published OCI image to", publishConfig.remoteRef)
+		return nil
+	},
+}
+
+func untar(tarballPath, destDir string) error {
+	file, err := os.Open(tarballPath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	tr := tar.NewReader(file)
+
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		target := filepath.Join(destDir, header.Name)
+
+		switch header.Typeflag {
+		case tar.TypeDir:
+			if err := os.MkdirAll(target, os.FileMode(header.Mode)); err != nil {
+				return err
+			}
+		case tar.TypeReg:
+			if err := os.MkdirAll(filepath.Dir(target), 0755); err != nil {
+				return err
+			}
+			outFile, err := os.OpenFile(target, os.O_CREATE|os.O_RDWR, os.FileMode(header.Mode))
+			if err != nil {
+				return err
+			}
+			if _, err := io.Copy(outFile, tr); err != nil {
+				outFile.Close()
+				return err
+			}
+			outFile.Close()
+		default:
+			return fmt.Errorf("unsupported file type in tar: %c for file %s", header.Typeflag, header.Name)
+		}
+	}
+	return nil
+}
+
+func findRootManifestDescriptor(layoutPath string) (ocispec.Descriptor, error) {
+	indexPath := filepath.Join(layoutPath, "index.json")
+	indexBytes, err := os.ReadFile(indexPath)
+	if err != nil {
+		return ocispec.Descriptor{}, fmt.Errorf("could not read index.json: %w", err)
+	}
+
+	var index ocispec.Index
+	if err := json.Unmarshal(indexBytes, &index); err != nil {
+		return ocispec.Descriptor{}, fmt.Errorf("could not unmarshal index.json: %w", err)
+	}
+
+	if len(index.Manifests) == 0 {
+		return ocispec.Descriptor{}, fmt.Errorf("no manifests found in index.json")
+	}
+
+	return index.Manifests[0], nil
+}
+
+func AddPublishCommand(rootCmd *cobra.Command) {
+	rootCmd.AddCommand(publishCmd)
+}