Merge pull request #978 from k0sproject/remember-config-origin

Resolve relative paths relative to config file location

Author: kke

cmd/flags.go

@@ -226,7 +226,22 @@ func initConfig(ctx *cli.Context) error {
 
 		log.Debugf("parsing configuration from %s", f)
 
-		if err := manifestReader.ParseBytes(subst); err != nil {
+		origin := cfgName
+		if cfgName == "-" {
+			cwd, err := os.Getwd()
+			if err != nil {
+				return fmt.Errorf("failed to determine working directory: %w", err)
+			}
+			origin = cwd
+		} else if named, ok := cfgFile.(interface{ Name() string }); ok {
+			if n := named.Name(); n != "" {
+				origin = n
+			}
+		} else if abs, err := filepath.Abs(origin); err == nil {
+			origin = abs
+		}
+
+		if err := manifestReader.ParseBytesWithOrigin(subst, origin); err != nil {
 			return fmt.Errorf("failed to parse config: %w", err)
 		}
 
@@ -280,6 +295,10 @@ func readConfig(ctx *cli.Context) (*v1beta1.Cluster, error) {
 	if err := ctlConfigs[0].Unmarshal(cfg); err != nil {
 		return nil, fmt.Errorf("failed to unmarshal cluster config: %w", err)
 	}
+	cfg.Origin = ctlConfigs[0].Origin
+	if err := cfg.Resolve(configBaseDir(cfg.Origin)); err != nil {
+		return nil, fmt.Errorf("failed to resolve upload file paths: %w", err)
+	}
 	if k0sConfigs, err := mr.GetResources("k0s.k0sproject.io/v1beta1", "ClusterConfig"); err == nil && len(k0sConfigs) > 0 {
 		if cfg.Spec.K0s.Config == nil {
 			cfg.Spec.K0s.Config = make(dig.Mapping)
@@ -318,6 +337,20 @@ func readConfig(ctx *cli.Context) (*v1beta1.Cluster, error) {
 	return cfg, nil
 }
 
+func configBaseDir(origin string) string {
+	if origin == "" {
+		return ""
+	}
+	cleaned := origin
+	if abs, err := filepath.Abs(origin); err == nil {
+		cleaned = abs
+	}
+	if info, err := os.Stat(cleaned); err == nil && info.IsDir() {
+		return filepath.ToSlash(cleaned)
+	}
+	return filepath.ToSlash(filepath.Dir(cleaned))
+}
+
 func initManager(ctx *cli.Context) error {
 	cfg, err := readConfig(ctx)
 	if err != nil {

cmd/flags_test.go

@@ -0,0 +1,79 @@
+package cmd
+
+import (
+	"context"
+	"flag"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/k0sproject/k0sctl/pkg/manifest"
+	"github.com/stretchr/testify/require"
+	"github.com/urfave/cli/v2"
+)
+
+func TestReadConfigSetsOrigin(t *testing.T) {
+	origin := filepath.Join(t.TempDir(), "cluster.yaml")
+	clusterYAML := `apiVersion: k0sctl.k0sproject.io/v1beta1
+kind: Cluster
+metadata:
+  name: test
+spec:
+  hosts:
+    - role: controller
+      ssh:
+        address: 10.0.0.1
+`
+
+	mr := &manifest.Reader{}
+	require.NoError(t, mr.ParseBytesWithOrigin([]byte(clusterYAML), origin))
+
+	app := cli.NewApp()
+	flagSet := flag.NewFlagSet("test", flag.ContinueOnError)
+	ctx := cli.NewContext(app, flagSet, nil)
+	ctx.Context = context.WithValue(context.Background(), ctxConfigsKey{}, mr)
+
+	cfg, err := readConfig(ctx)
+	require.NoError(t, err)
+	require.Equal(t, origin, cfg.Origin)
+}
+
+func TestReadConfigResolvesUploadFilesRelativeToOrigin(t *testing.T) {
+	dir := t.TempDir()
+	assetsDir := filepath.Join(dir, "assets", "bin")
+	require.NoError(t, os.MkdirAll(assetsDir, 0o755))
+	require.NoError(t, os.WriteFile(filepath.Join(assetsDir, "script.sh"), []byte("#!/bin/sh\n"), 0o755))
+
+	origin := filepath.Join(dir, "cluster.yaml")
+	clusterYAML := `apiVersion: k0sctl.k0sproject.io/v1beta1
+kind: Cluster
+metadata:
+  name: test
+spec:
+  hosts:
+    - role: controller
+      ssh:
+        address: 10.0.0.1
+      files:
+        - src: assets/bin/script.sh
+          dstDir: /tmp
+`
+	require.NoError(t, os.WriteFile(origin, []byte(clusterYAML), 0o644))
+
+	mr := &manifest.Reader{}
+	require.NoError(t, mr.ParseBytesWithOrigin([]byte(clusterYAML), origin))
+
+	app := cli.NewApp()
+	flagSet := flag.NewFlagSet("test", flag.ContinueOnError)
+	ctx := cli.NewContext(app, flagSet, nil)
+	ctx.Context = context.WithValue(context.Background(), ctxConfigsKey{}, mr)
+
+	cfg, err := readConfig(ctx)
+	require.NoError(t, err)
+	require.Equal(t, origin, cfg.Origin)
+	require.Len(t, cfg.Spec.Hosts, 1)
+	require.Len(t, cfg.Spec.Hosts[0].Files, 1)
+	require.Equal(t, filepath.ToSlash(assetsDir), cfg.Spec.Hosts[0].Files[0].Base)
+	require.Len(t, cfg.Spec.Hosts[0].Files[0].Sources, 1)
+	require.Equal(t, "script.sh", cfg.Spec.Hosts[0].Files[0].Sources[0].Path)
+}

pkg/apis/k0sctl.k0sproject.io/v1beta1/cluster.go

@@ -29,6 +29,7 @@ type Cluster struct {
 	Kind       string           `yaml:"kind"`
 	Metadata   *ClusterMetadata `yaml:"metadata"`
 	Spec       *cluster.Spec    `yaml:"spec"`
+	Origin     string           `yaml:"-"`
 }
 
 // UnmarshalYAML sets in some sane defaults when unmarshaling the data from yaml
@@ -110,3 +111,11 @@ func (c *Cluster) StorageType() string {
 	// default to etcd otherwise
 	return "etcd"
 }
+
+// Resolve prepares cluster-level data after unmarshalling by cascading down to the spec.
+func (c *Cluster) Resolve(baseDir string) error {
+	if c.Spec == nil {
+		return nil
+	}
+	return c.Spec.Resolve(baseDir)
+}

pkg/apis/k0sctl.k0sproject.io/v1beta1/cluster/host.go

@@ -1,12 +1,12 @@
 package cluster
 
 import (
-    "context"
-    "fmt"
-    "net/url"
-    gos "os"
-    gopath "path"
-    "slices"
+	"context"
+	"fmt"
+	"net/url"
+	gos "os"
+	gopath "path"
+	"slices"
 	"strings"
 	"time"
 
@@ -132,6 +132,16 @@ func (h *Host) Validate() error {
 	)
 }
 
+// ResolveUploadFiles resolves host file sources relative to baseDir.
+func (h *Host) ResolveUploadFiles(baseDir string) error {
+	for _, f := range h.Files {
+		if err := f.ResolveRelativeTo(baseDir); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 type configurer interface {
 	Kind() string
 	CheckPrivilege(os.Host) error
@@ -203,6 +213,11 @@ type HostMetadata struct {
 	DryRunFakeLeader  bool
 }
 
+// Resolve prepares host-scoped data after unmarshalling by resolving upload files.
+func (h *Host) Resolve(baseDir string) error {
+	return h.ResolveUploadFiles(baseDir)
+}
+
 // UnmarshalYAML sets in some sane defaults when unmarshaling the data from yaml
 func (h *Host) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	type host Host
@@ -686,26 +701,26 @@ func (h *Host) FlagsChanged() bool {
 
 // HasHooks returns true when the host has hooks defined for the action and stage.
 func (h *Host) HasHooks(action, stage string) bool {
-    return len(h.Hooks.ForActionAndStage(action, stage)) > 0
+	return len(h.Hooks.ForActionAndStage(action, stage)) > 0
 }
 
 // RunHooks runs the hooks for the given action and stage (such as "apply", "before" would run the "before apply" hooks).
 // It respects context cancellation between hook executions.
 func (h *Host) RunHooks(ctx context.Context, action, stage string) error {
-    commands := h.Hooks.ForActionAndStage(action, stage)
-    if len(commands) == 0 {
-        return nil
-    }
-    for _, cmd := range commands {
-        // Abort early if the context has been canceled.
-        if err := ctx.Err(); err != nil {
-            return err
-        }
-
-        log.Infof("%s: running %s %s hook: %q", h, stage, action, cmd)
-        if err := h.Exec(cmd); err != nil {
-            return fmt.Errorf("failed to execute hook %q for action %q stage %q on host %s: %w", cmd, action, stage, h.Address(), err)
-        }
-    }
-    return nil
+	commands := h.Hooks.ForActionAndStage(action, stage)
+	if len(commands) == 0 {
+		return nil
+	}
+	for _, cmd := range commands {
+		// Abort early if the context has been canceled.
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+
+		log.Infof("%s: running %s %s hook: %q", h, stage, action, cmd)
+		if err := h.Exec(cmd); err != nil {
+			return fmt.Errorf("failed to execute hook %q for action %q stage %q on host %s: %w", cmd, action, stage, h.Address(), err)
+		}
+	}
+	return nil
 }

pkg/apis/k0sctl.k0sproject.io/v1beta1/cluster/hosts.go

@@ -38,6 +38,16 @@ func (hosts Hosts) Validate() error {
 	return nil
 }
 
+// Resolve runs Host.Resolve for each host.
+func (hosts Hosts) Resolve(baseDir string) error {
+	for _, h := range hosts {
+		if err := h.Resolve(baseDir); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // First returns the first host
 func (hosts Hosts) First() *Host {
 	if len(hosts) == 0 {

pkg/apis/k0sctl.k0sproject.io/v1beta1/cluster/spec.go

@@ -96,6 +96,21 @@ func (s *Spec) Validate() error {
 	)
 }
 
+// ResolveUploadFilePaths resolves all host file sources relative to baseDir.
+func (s *Spec) ResolveUploadFilePaths(baseDir string) error {
+	for _, h := range s.Hosts {
+		if err := h.ResolveUploadFiles(baseDir); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Resolve prepares spec-level data after unmarshalling by cascading to hosts.
+func (s *Spec) Resolve(baseDir string) error {
+	return s.ResolveUploadFilePaths(baseDir)
+}
+
 type k0sCPLBConfig struct {
 	Spec struct {
 		Network struct {
@@ -187,6 +202,8 @@ func (s *Spec) NodeInternalKubeAPIURL(h *Host) string {
 	return fmt.Sprintf("https://%s:%d", formatIPV6(addr), s.APIPort())
 }
 
+// Resolve prepares spec-scoped resources after unmarshalling.
+// Currently cascades resolution into hosts using the given origin.
 func formatIPV6(address string) string {
 	if strings.Contains(address, ":") {
 		return fmt.Sprintf("[%s]", address)

pkg/apis/k0sctl.k0sproject.io/v1beta1/cluster/uploadfile.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path"
+	"path/filepath"
 	"strconv"
 	"strings"
 
@@ -88,6 +89,7 @@ func permToString(val interface{}) (string, error) {
 }
 
 // UnmarshalYAML sets in some sane defaults when unmarshaling the data from yaml
+
 func (u *UploadFile) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	type uploadFile UploadFile
 	yu := (*uploadFile)(u)
@@ -108,7 +110,7 @@ func (u *UploadFile) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	}
 	u.DirPermString = dp
 
-	return u.resolve()
+	return nil
 }
 
 // String returns the file bundle name or if it is empty, the source.
@@ -129,8 +131,8 @@ func isGlob(s string) bool {
 	return strings.ContainsAny(s, "*%?[]{}")
 }
 
-// sets the destination and resolves any globs/local paths into u.Sources
-func (u *UploadFile) resolve() error {
+// ResolveRelativeTo sets the destination and resolves globs/local paths relative to baseDir.
+func (u *UploadFile) ResolveRelativeTo(baseDir string) error {
 	if u.IsURL() {
 		if u.DestinationFile == "" {
 			if u.DestinationDir != "" {
@@ -146,27 +148,42 @@ func (u *UploadFile) resolve() error {
 		return nil
 	}
 
+	u.Base = ""
+	u.Sources = nil
+
+	src := filepath.ToSlash(u.Source)
+	if src == "" {
+		return fmt.Errorf("failed to resolve local path for %s: empty source", u)
+	}
+	if !path.IsAbs(src) {
+		if baseDir != "" {
+			src = path.Join(baseDir, src)
+		}
+	}
+	src = path.Clean(src)
+
 	if isGlob(u.Source) {
-		return u.glob(u.Source)
+		return u.glob(src)
 	}
 
-	stat, err := os.Stat(u.Source)
+	fsPath := filepath.FromSlash(src)
+	stat, err := os.Stat(fsPath)
 	if err != nil {
 		return fmt.Errorf("failed to stat local path for %s: %w", u, err)
 	}
 
 	if stat.IsDir() {
-		log.Tracef("source %s is a directory, assuming %s/**/*", u.Source, u.Source)
-		return u.glob(path.Join(u.Source, "**/*"))
+		log.Tracef("source %s is a directory, assuming %s/**/*", src, src)
+		return u.glob(path.Join(src, "**/*"))
 	}
 
 	perm := u.PermString
 	if perm == "" {
 		perm = fmt.Sprintf("%o", stat.Mode())
 	}
-	u.Base = path.Dir(u.Source)
+	u.Base = path.Dir(src)
 	u.Sources = []*LocalFile{
-		{Path: path.Base(u.Source), PermMode: perm},
+		{Path: path.Base(src), PermMode: perm},
 	}
 
 	return nil
@@ -176,7 +193,7 @@ func (u *UploadFile) resolve() error {
 func (u *UploadFile) glob(src string) error {
 	base, pattern := doublestar.SplitPattern(src)
 	u.Base = base
-	fsys := os.DirFS(base)
+	fsys := os.DirFS(filepath.FromSlash(base))
 	sources, err := doublestar.Glob(fsys, pattern)
 	if err != nil {
 		return err
@@ -185,7 +202,7 @@ func (u *UploadFile) glob(src string) error {
 	for _, s := range sources {
 		abs := path.Join(base, s)
 		log.Tracef("glob %s found: %s", abs, s)
-		stat, err := os.Stat(abs)
+		stat, err := os.Stat(filepath.FromSlash(abs))
 		if err != nil {
 			return fmt.Errorf("failed to stat file %s: %w", u, err)
 		}