From 02e084ddff056c14dace48d247520ed4a8f32ccc Mon Sep 17 00:00:00 2001 From: Chandarith Chea <45872539+chandarith-chea@users.noreply.github.com> Date: Sat, 14 Nov 2026 11:06:39 +0700 Subject: [PATCH 1/2] Choosing Dockiva Engine points the docker CLI at it Selecting Dockiva Engine (or starting it on launch) creates or repairs the "dockiva" docker context for ~/.dockiva-engine/docker.sock and makes it current, the way Docker Desktop and OrbStack take the context when they start. The replaced context is saved beside settings.json and given back when another engine is chosen, unless the user switched contexts since. --- docker_cli_context.go | 113 +++++++++++++++++++++++++++++++++++++ docker_cli_context_test.go | 62 ++++++++++++++++++++ engine_autorecovery.go | 3 + engine_common.go | 12 +++- 4 files changed, 189 insertions(+), 1 deletion(-) create mode 100644 docker_cli_context.go create mode 100644 docker_cli_context_test.go diff --git a/docker_cli_context.go b/docker_cli_context.go new file mode 100644 index 0000000..d6964b8 --- /dev/null +++ b/docker_cli_context.go @@ -0,0 +1,113 @@ +package main + +import ( + "context" + "errors" + "fmt" + "os" + "os/exec" + "path/filepath" + "strings" + "time" +) + +// Choosing Dockiva Engine also points the docker CLI, and the tools that follow +// its context (Compose, buildx, act…), at the engine, the way Docker Desktop and +// OrbStack take the context when they start. The context it replaced is saved and +// given back when another engine is chosen. +const dockivaCLIContext = "dockiva" + +func dockerCLI(args ...string) (string, error) { + path, err := dockerCLIPath() + if err != nil { + return "", err + } + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + cmd := exec.CommandContext(ctx, path, args...) + // The app sets DOCKER_HOST for itself; the CLI must see the user's own context. + for _, kv := range os.Environ() { + if !strings.HasPrefix(kv, "DOCKER_HOST=") && !strings.HasPrefix(kv, "DOCKER_CONTEXT=") { + cmd.Env = append(cmd.Env, kv) + } + } + out, err := cmd.CombinedOutput() + if err != nil { + return "", fmt.Errorf("docker %s: %v: %s", strings.Join(args, " "), err, strings.TrimSpace(string(out))) + } + return strings.TrimSpace(string(out)), nil +} + +func currentCLIContext() (string, error) { + return dockerCLI("context", "inspect", "--format", "{{.Name}}") +} + +func previousCLIContextPath() (string, error) { + dir, err := os.UserConfigDir() + if err != nil { + return "", err + } + return filepath.Join(dir, "Dockiva", "previous-docker-context"), nil +} + +// useDockivaCLIContext creates or repairs the "dockiva" context for the engine at +// home and makes it the docker CLI's current context. +func useDockivaCLIContext(home string) error { + current, err := currentCLIContext() + if err != nil { + return err + } + verb := "update" + if _, err := dockerCLI("context", "inspect", dockivaCLIContext); err != nil { + verb = "create" + } + host := "host=unix://" + filepath.Join(home, "docker.sock") + if _, err := dockerCLI("context", verb, dockivaCLIContext, "--description", "Dockiva Engine", "--docker", host); err != nil { + return err + } + if current == dockivaCLIContext { + return nil + } + path, err := previousCLIContextPath() + if err != nil { + return err + } + if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil { + return err + } + if err := os.WriteFile(path, []byte(current+"\n"), 0600); err != nil { + return err + } + _, err = dockerCLI("context", "use", dockivaCLIContext) + return err +} + +// restoreDockerCLIContext gives back the context useDockivaCLIContext replaced, +// unless the user has switched contexts since. It runs no docker command when +// nothing was replaced. +func restoreDockerCLIContext() error { + path, err := previousCLIContextPath() + if err != nil { + return err + } + data, err := os.ReadFile(path) + if errors.Is(err, os.ErrNotExist) { + return nil + } else if err != nil { + return err + } + current, err := currentCLIContext() + if err != nil { + return err + } + if current == dockivaCLIContext { + previous := strings.TrimSpace(string(data)) + if _, err := dockerCLI("context", "inspect", previous); previous == "" || err != nil { + previous = "default" // the saved context was removed since + } + if _, err := dockerCLI("context", "use", previous); err != nil { + return err + } + } + return os.Remove(path) +} diff --git a/docker_cli_context_test.go b/docker_cli_context_test.go new file mode 100644 index 0000000..f4c8c54 --- /dev/null +++ b/docker_cli_context_test.go @@ -0,0 +1,62 @@ +package main + +import ( + "path/filepath" + "testing" +) + +// Uses the real docker CLI against a throwaway DOCKER_CONFIG, so the user's own +// contexts are never touched. +func TestDockivaCLIContextTakesAndGivesBack(t *testing.T) { + if _, err := dockerCLIPath(); err != nil { + t.Skip("no docker CLI") + } + t.Setenv("DOCKER_CONFIG", t.TempDir()) + t.Setenv("HOME", t.TempDir()) + t.Setenv("XDG_CONFIG_HOME", "") + t.Setenv("DOCKER_HOST", "unix:///app/own/setting.sock") // must not leak into the CLI + + run := func(args ...string) string { + t.Helper() + out, err := dockerCLI(args...) + if err != nil { + t.Fatal(err) + } + return out + } + run("context", "create", "other", "--docker", "host=unix:///tmp/other.sock") + run("context", "use", "other") + // A stale context from before the rename gets repaired, not duplicated. + run("context", "create", dockivaCLIContext, "--docker", "host=unix:///old/.vmfree/docker.sock") + + home := "/tmp/dkv-ctx-test/.dockiva-engine" // the CLI checks the socket path length, not that it exists + if err := useDockivaCLIContext(home); err != nil { + t.Fatal(err) + } + if got := run("context", "inspect", "--format", "{{.Name}}"); got != dockivaCLIContext { + t.Fatalf("current context = %q", got) + } + want := "unix://" + filepath.Join(home, "docker.sock") + if got := run("context", "inspect", dockivaCLIContext, "--format", "{{.Endpoints.docker.Host}}"); got != want { + t.Fatalf("dockiva host = %q, want %q", got, want) + } + // Selecting again (every launch) keeps the original context to give back. + if err := useDockivaCLIContext(home); err != nil { + t.Fatal(err) + } + + if err := restoreDockerCLIContext(); err != nil { + t.Fatal(err) + } + if got := run("context", "inspect", "--format", "{{.Name}}"); got != "other" { + t.Fatalf("restored context = %q, want other", got) + } + // Nothing saved any more: a second restore leaves the user's choice alone. + run("context", "use", dockivaCLIContext) + if err := restoreDockerCLIContext(); err != nil { + t.Fatal(err) + } + if got := run("context", "inspect", "--format", "{{.Name}}"); got != dockivaCLIContext { + t.Fatalf("context after second restore = %q", got) + } +} diff --git a/engine_autorecovery.go b/engine_autorecovery.go index d78d6e0..9b94c7b 100644 --- a/engine_autorecovery.go +++ b/engine_autorecovery.go @@ -19,6 +19,9 @@ func (s *DockerService) AutoRecoverEngine( if err := startVMFreeEngine(r); err != nil { log.Printf("Dockiva Engine startup: %v", err) } else { + if err := useDockivaCLIContext(r.home); err != nil { + log.Printf("docker CLI context: %v", err) + } s.emitEngineRecovered("vmfree-started") } } diff --git a/engine_common.go b/engine_common.go index 2a65741..c1e436c 100644 --- a/engine_common.go +++ b/engine_common.go @@ -3,6 +3,7 @@ package main import ( "context" "errors" + "log" "os" "os/exec" "path/filepath" @@ -144,7 +145,16 @@ func (s *DockerService) SelectEngineBackend( // Keep this identity even while offline; never expose the previous Docker store. r := newVMFreeRuntime() s.replaceRuntime(r) - return "vmfree", startVMFreeEngine(r) + if err := startVMFreeEngine(r); err != nil { + return "vmfree", err + } + if err := useDockivaCLIContext(r.home); err != nil { + log.Printf("docker CLI context: %v", err) + } + return "vmfree", nil + } + if err := restoreDockerCLIContext(); err != nil { + log.Printf("docker CLI context: %v", err) } if backend == "auto" { backend = s.engine.Name() From 030de602144d14b3a7dd3d90e40441e196d1cafd Mon Sep 17 00:00:00 2001 From: Chandarith Chea <45872539+chandarith-chea@users.noreply.github.com> Date: Sat, 14 Nov 2026 11:10:46 +0700 Subject: [PATCH 2/2] Take the docker CLI context on launch even without starting the engine --- engine_autorecovery.go | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/engine_autorecovery.go b/engine_autorecovery.go index 9b94c7b..ff82981 100644 --- a/engine_autorecovery.go +++ b/engine_autorecovery.go @@ -13,17 +13,18 @@ func (s *DockerService) AutoRecoverEngine( ) { backend = normalizeEngineBackend(backend) if backend == "vmfree" { + r := newVMFreeRuntime() + defer r.Close() if startEngine { - r := newVMFreeRuntime() - defer r.Close() if err := startVMFreeEngine(r); err != nil { log.Printf("Dockiva Engine startup: %v", err) - } else { - if err := useDockivaCLIContext(r.home); err != nil { - log.Printf("docker CLI context: %v", err) - } - s.emitEngineRecovered("vmfree-started") + return } + s.emitEngineRecovered("vmfree-started") + } + // Chosen engine, so the docker CLI follows it even when launch does not start it. + if err := useDockivaCLIContext(r.home); err != nil { + log.Printf("docker CLI context: %v", err) } return }