feat: read runx actions from a remote image

Access to an image and reads the configuration manifest to extract
runnable actions.

    docker runx IMAGE

Signed-off-by: Yves Brissaud <[email protected]>

Author: eunomie

docs/reference/docker_runx.yaml

@@ -1,7 +1,7 @@
 command: docker runx
 short: Docker Run, better
 long: Docker Run, better
-usage: docker runx [command]
+usage: docker runx [IMAGE]
 pname: docker
 plink: docker.yaml
 cname:

examples/alpine-hello.runx.yaml

@@ -1,4 +1,4 @@
 actions:
   - id: hello
     type: run
-    cmds: --rm {{.Ref}} echo hello
+    cmd: --rm {{.Ref}} echo hello

go.mod

@@ -9,6 +9,7 @@ require (
 	github.com/google/go-containerregistry v0.20.2
 	github.com/spf13/cobra v1.8.1
 	github.com/spf13/pflag v1.0.5
+	gopkg.in/yaml.v2 v2.4.0
 )
 
 require (

internal/commands/root/root.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v2"
 
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli-plugins/plugin"
@@ -12,23 +13,28 @@ import (
 	"github.com/eunomie/docker-runx/internal/commands/help"
 	"github.com/eunomie/docker-runx/internal/commands/version"
 	"github.com/eunomie/docker-runx/internal/constants"
+	"github.com/eunomie/docker-runx/runkit"
 )
 
 func NewCmd(dockerCli command.Cli, isPlugin bool) *cobra.Command {
 	var (
 		name = commandName(isPlugin)
 		cmd  = &cobra.Command{
-			Use:   fmt.Sprintf("%s [command]", name),
+			Use:   fmt.Sprintf("%s [IMAGE]", name),
 			Short: "Docker Run, better",
 			RunE: func(cmd *cobra.Command, args []string) error {
 				if len(args) == 0 {
 					return cmd.Help()
 				}
-				_ = cmd.Help()
-				return cli.StatusError{
-					StatusCode: 1,
-					Status:     fmt.Sprintf("unknown command: %q", args[0]),
+
+				src := args[0]
+
+				actions, err := runkit.Get(cmd.Context(), src)
+				if err != nil {
+					return err
 				}
+
+				return yaml.NewEncoder(cmd.OutOrStdout()).Encode(actions)
 			},
 		}
 	)

internal/runkit/image.go

@@ -10,6 +10,7 @@ import (
 )
 
 const (
+	RunxAnnotation   = "vnd.docker.reference.type"
 	RunxManifestType = "runx-manifest"
 	RunxConfigType   = "application/vnd.runx.config+yaml"
 )
@@ -34,7 +35,7 @@ func Image(runxConfig []byte) (v1.Image, *v1.Descriptor, error) {
 	desc, _ := partial.Descriptor(img)
 	desc.Platform = config.Platform()
 	desc.Annotations = make(map[string]string)
-	desc.Annotations["vnd.docker.reference.type"] = RunxManifestType
+	desc.Annotations[RunxAnnotation] = RunxManifestType
 
 	return img, desc, nil
 }

runkit/decorate.go

@@ -21,6 +21,7 @@ func Decorate(ctx context.Context, src, dest string, runxConfig []byte) error {
 		index                    v1.ImageIndex
 		remoteOpts               = registry.WithOptions(ctx, nil)
 		ref, _                   = name.ParseReference(src)
+		desc                     *remote.Descriptor
 		destRef, _               = name.ParseReference(dest)
 		runxImage, runxDesc, err = runkit.Image(runxConfig)
 	)
@@ -29,7 +30,7 @@ func Decorate(ctx context.Context, src, dest string, runxConfig []byte) error {
 		return fmt.Errorf("could not create runx image: %w", err)
 	}
 
-	desc, err := remote.Get(ref, remoteOpts...)
+	desc, err = remote.Get(ref, remoteOpts...)
 	if err != nil {
 		return fmt.Errorf("could not get image %s: %w", src, err)
 	}

runkit/read.go

@@ -0,0 +1,93 @@
+package runkit
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"github.com/google/go-containerregistry/pkg/name"
+	v1 "github.com/google/go-containerregistry/pkg/v1"
+	"github.com/google/go-containerregistry/pkg/v1/remote"
+	"gopkg.in/yaml.v2"
+
+	"github.com/eunomie/docker-runx/internal/registry"
+	"github.com/eunomie/docker-runx/internal/runkit"
+)
+
+func Get(ctx context.Context, src string) (*RunKit, error) {
+	var (
+		err        error
+		index      v1.ImageIndex
+		desc       *remote.Descriptor
+		manifest   v1.Descriptor
+		runxImg    v1.Image
+		layers     []v1.Layer
+		runxConfig []byte
+		actions    RunKit
+		remoteOpts = registry.WithOptions(ctx, nil)
+		ref, _     = name.ParseReference(src)
+	)
+
+	desc, err = remote.Get(ref, remoteOpts...)
+	if err != nil {
+		return nil, fmt.Errorf("could not get image %s: %w", src, err)
+	}
+
+	if !desc.MediaType.IsIndex() {
+		return nil, fmt.Errorf("image %s can't be read by 'docker runx': should be an index", src)
+	}
+
+	index, err = remote.Index(ref, remoteOpts...)
+	if err != nil {
+		return nil, fmt.Errorf("could not get index %s: %w", src, err)
+	}
+
+	found := false
+	manifests, _ := index.IndexManifest()
+	for _, m := range manifests.Manifests {
+		if a, ok := m.Annotations[runkit.RunxAnnotation]; ok && a == runkit.RunxManifestType {
+			manifest = m
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		return nil, fmt.Errorf("image %s can't be read by 'docker runx': no runx manifest found", src)
+	}
+	runxImg, err = index.Image(manifest.Digest)
+	if err != nil {
+		return nil, fmt.Errorf("could not get runx image %s: %w", src, err)
+	}
+
+	layers, err = runxImg.Layers()
+	if err != nil {
+		return nil, fmt.Errorf("could not get runx layers %s: %w", src, err)
+	}
+
+	for _, l := range layers {
+		if mt, err := l.MediaType(); err == nil && mt == runkit.RunxConfigType {
+			dataReader, err := l.Uncompressed()
+			if err != nil {
+				return nil, fmt.Errorf("could not read runx actions %s: %w", src, err)
+			}
+			runxConfig, err = io.ReadAll(dataReader)
+			if err != nil {
+				return nil, fmt.Errorf("could not read runx actions %s: %w", src, err)
+			}
+			break
+		}
+	}
+
+	if len(runxConfig) == 0 {
+		return nil, fmt.Errorf("image %s can't be read by 'docker runx': no runx actions found", src)
+	}
+
+	if err = yaml.Unmarshal(runxConfig, &actions); err != nil {
+		return nil, fmt.Errorf("could not unmarshal runx actions %s: %w", src, err)
+	}
+
+	actions.src = src
+
+	return &actions, nil
+}

runkit/types.go

@@ -0,0 +1,20 @@
+package runkit
+
+type (
+	RunKit struct {
+		Actions []Action `yaml:"actions" json:"actions"`
+		src     string
+	}
+
+	Action struct {
+		ID      string     `yaml:"id" json:"id"`
+		Type    ActionType `yaml:"type" json:"type"`
+		Command string     `yaml:"cmd" json:"cmd,omitempty"`
+	}
+
+	ActionType string
+)
+
+const (
+	ActionTypeRun ActionType = "run"
+)