Add a plugin mechanism to provide custom locator URL schemes

The template reader will attempt to call `limactl-url-$SCHEME` to
rewrite a custom URL as either a local filename, or a URL with a
supported URL like https.

Signed-off-by: Jan Dubois <jan.dubois@suse.com>

Author: jandubois

cmd/limactl/main.go

@@ -20,6 +20,7 @@ import (
 	"github.com/lima-vm/lima/v2/cmd/yq"
 	"github.com/lima-vm/lima/v2/pkg/debugutil"
 	"github.com/lima-vm/lima/v2/pkg/driver/external/server"
+	"github.com/lima-vm/lima/v2/pkg/executil"
 	"github.com/lima-vm/lima/v2/pkg/fsutil"
 	"github.com/lima-vm/lima/v2/pkg/limatype/dirnames"
 	"github.com/lima-vm/lima/v2/pkg/osutil"
@@ -221,8 +222,11 @@ func executeWithPluginSupport(rootCmd *cobra.Command, args []string) error {
 	if len(args) > 0 {
 		cmd, _, err := rootCmd.Find(args)
 		if err != nil || cmd == rootCmd {
-			// Function calls os.Exit() if it found and executed the plugin
-			runExternalPlugin(rootCmd.Context(), args[0], args[1:])
+			_ = executil.WithExecutablePath(func() error {
+				// Function calls os.Exit() if it found and executed the plugin
+				runExternalPlugin(rootCmd.Context(), args[0], args[1:])
+				return nil
+			})
 		}
 	}
 
@@ -235,11 +239,6 @@ func runExternalPlugin(ctx context.Context, name string, args []string) {
 		ctx = context.Background()
 	}
 
-	if err := updatePathEnv(); err != nil {
-		logrus.Warnf("failed to update PATH environment: %v", err)
-		// PATH update failure shouldn't prevent plugin execution
-	}
-
 	externalCmd := "limactl-" + name
 	execPath, err := exec.LookPath(externalCmd)
 	if err != nil {
@@ -260,25 +259,6 @@ func runExternalPlugin(ctx context.Context, name string, args []string) {
 	logrus.Fatalf("external command %q failed: %v", execPath, err)
 }
 
-func updatePathEnv() error {
-	exe, err := os.Executable()
-	if err != nil {
-		return fmt.Errorf("failed to get executable path: %w", err)
-	}
-
-	binDir := filepath.Dir(exe)
-	currentPath := os.Getenv("PATH")
-	newPath := binDir + string(filepath.ListSeparator) + currentPath
-
-	if err := os.Setenv("PATH", newPath); err != nil {
-		return fmt.Errorf("failed to set PATH environment: %w", err)
-	}
-
-	logrus.Debugf("updated PATH to prioritize %s", binDir)
-
-	return nil
-}
-
 // WrapArgsError annotates cobra args error with some context, so the error message is more user-friendly.
 func WrapArgsError(argFn cobra.PositionalArgs) cobra.PositionalArgs {
 	return func(cmd *cobra.Command, args []string) error {

cmd/limactl/template.go

@@ -37,6 +37,7 @@ func newTemplateCommand() *cobra.Command {
 	}
 	templateCommand.AddCommand(
 		newTemplateCopyCommand(),
+		newTemplateURLCommand(),
 		newTemplateValidateCommand(),
 		newTemplateYQCommand(),
 	)
@@ -95,6 +96,25 @@ func fillDefaults(ctx context.Context, tmpl *limatmpl.Template) error {
 	return err
 }
 
+func newTemplateURLCommand() *cobra.Command {
+	templateURLCommand := &cobra.Command{
+		Use:   "url CUSTOM_URL",
+		Short: "Transform custom template URLs to regular file or https URLs",
+		Args:  WrapArgsError(cobra.ExactArgs(1)),
+		RunE:  templateURLAction,
+	}
+	return templateURLCommand
+}
+
+func templateURLAction(cmd *cobra.Command, args []string) error {
+	url, err := limatmpl.TransformCustomURL(cmd.Context(), args[0])
+	if err != nil {
+		return err
+	}
+	_, err = fmt.Fprintln(cmd.OutOrStdout(), url)
+	return err
+}
+
 func templateCopyAction(cmd *cobra.Command, args []string) error {
 	ctx := cmd.Context()
 	source := args[0]

pkg/executil/command.go

@@ -7,9 +7,14 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"os"
 	"os/exec"
+	"path/filepath"
+
+	"github.com/sirupsen/logrus"
 
 	"github.com/lima-vm/lima/v2/pkg/ioutilx"
+	"github.com/lima-vm/lima/v2/pkg/usrlocalsharelima"
 )
 
 type options struct {
@@ -52,3 +57,35 @@ func RunUTF16leCommand(args []string, opts ...Opt) (string, error) {
 	}
 	return outString, err
 }
+
+// WithExecutablePath prepends the directory containing the current executable to the PATH
+// and appends "/usr/local/libexec/lima" to the end before calling fn().
+//
+// This can be used to prefer plugins from the same directory over ones on the PATH and also works if the
+// directory containing the executable itself is not on the path (e.g. "./_output/bin/limactl").
+//
+// It means if plugins call limactl they will invoke back the executable that called them.
+func WithExecutablePath(fn func() error) error {
+	exe, err := os.Executable()
+	if err != nil {
+		return fmt.Errorf("failed to get executable path: %w", err)
+	}
+
+	currentPath := os.Getenv("PATH")
+	defer os.Setenv("PATH", currentPath)
+	newPath := filepath.Dir(exe) + string(filepath.ListSeparator) + currentPath
+
+	prefixDir, err := usrlocalsharelima.Prefix()
+	if err == nil {
+		newPath += string(filepath.ListSeparator) + filepath.Join(prefixDir, "libexec", "lima")
+	} else {
+		// This happens in Go unit tests: https://github.com/lima-vm/lima/issues/3208
+		logrus.Warnf("Couldn't locate libexec path: %v", err)
+	}
+
+	if err := os.Setenv("PATH", newPath); err != nil {
+		return fmt.Errorf("failed to set PATH environment: %w", err)
+	}
+
+	return fn()
+}

pkg/limatmpl/locator.go

@@ -5,11 +5,13 @@ package limatmpl
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"os"
+	"os/exec"
 	"path"
 	"path/filepath"
 	"regexp"
@@ -18,6 +20,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 
+	"github.com/lima-vm/lima/v2/pkg/executil"
 	"github.com/lima-vm/lima/v2/pkg/identifiers"
 	"github.com/lima-vm/lima/v2/pkg/ioutilx"
 	"github.com/lima-vm/lima/v2/pkg/limatype"
@@ -28,12 +31,16 @@ import (
 const yBytesLimit = 4 * 1024 * 1024 // 4MiB
 
 func Read(ctx context.Context, name, locator string) (*Template, error) {
-	var err error
 	tmpl := &Template{
 		Name:    name,
 		Locator: locator,
 	}
 
+	locator, err := TransformCustomURL(ctx, locator)
+	if err != nil {
+		return nil, err
+	}
+
 	if imageTemplate(tmpl, locator) {
 		return tmpl, nil
 	}
@@ -285,3 +292,43 @@ func InstNameFromYAMLPath(yamlPath string) (string, error) {
 	}
 	return s, nil
 }
+
+func transformCustomURL(ctx context.Context, locator string) (string, error) {
+	u, err := url.Parse(locator)
+	if err != nil || len(u.Scheme) <= 1 {
+		return locator, nil
+	}
+
+	// TODO we should call main.updatePathEnv() here (after moving it to some pkg)
+	externalCmd := "limactl-url-" + u.Scheme
+	execPath, err := exec.LookPath(externalCmd)
+	if err != nil {
+		return locator, nil
+	}
+
+	cmd := exec.CommandContext(ctx, execPath, strings.TrimPrefix(u.String(), u.Scheme+":"))
+	cmd.Env = os.Environ()
+
+	stdout, err := cmd.Output()
+	if err != nil {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) {
+			stderrMsg := string(exitErr.Stderr)
+			if stderrMsg != "" {
+				return "", fmt.Errorf("command %q failed: %s", cmd.String(), strings.TrimSpace(stderrMsg))
+			}
+		}
+		return "", fmt.Errorf("command %q failed: %w", cmd.String(), err)
+	}
+
+	return strings.TrimSpace(string(stdout)), nil
+}
+
+func TransformCustomURL(ctx context.Context, locator string) (string, error) {
+	err := executil.WithExecutablePath(func() error {
+		var err error
+		locator, err = transformCustomURL(ctx, locator)
+		return err
+	})
+	return locator, err
+}