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..ff82981 100644 --- a/engine_autorecovery.go +++ b/engine_autorecovery.go @@ -13,14 +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 { - 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 } 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()