Skip to content

Router that virtually distributes inference across connected devices in the home.

Go
14.4 KB
Raw Blame
// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"net"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"nvpair-shared/engines"
	settings "nvpair-shared/enginesettings"
	"nvpair-shared/noderec"
	"nvpair-ui-broker/relay"
)

type settingsHarness struct {
	b                   *Broker
	applies             atomic.Int32
	proxyRebinds        atomic.Int32
	fail                atomic.Bool
	failBeforeStop      atomic.Bool
	loseProxyOnStop     atomic.Bool
	failResultSave      atomic.Bool
	otherEnginePort     atomic.Int32
	previewPreserveCORS atomic.Bool
	entered, release    chan struct{}
	// launchMu guards the fixture's launch state, which a suspended
	// engine:configure-launch mutates while the reader loop keeps serving.
	launchMu sync.Mutex
}

func newSettingsHarness(t *testing.T) *settingsHarness {
	t.Helper()
	return newSettingsHarnessForEngine(t, "ollama")
}

func newSettingsHarnessForEngine(t *testing.T, engine string) *settingsHarness {
	t.Helper()
	ports := make([]int, 4)
	listeners := []net.Listener{}
	for i := range ports {
		ln, err := net.Listen("tcp", "127.0.0.1:0")
		if err != nil {
			t.Fatal(err)
		}
		listeners = append(listeners, ln)
		ports[i] = ln.Addr().(*net.TCPAddr).Port
	}
	for _, ln := range listeners {
		_ = ln.Close()
	}
	h := &settingsHarness{b: &Broker{codec: NewCodec(&bytes.Buffer{}), nodeID: "target", clusterDir: filepath.Join(t.TempDir(), "cluster")}}
	worker, codec := newTestRPCWorkerPipe(t)
	h.b.setEngineMgr(worker)
	proxyWorker, proxyCodec := newTestRPCWorkerPipe(t)
	proxy := &proxyProcess{peer: proxyWorker.peer, facadeState: map[string]proxyFacadeState{
		"ollama":   {ready: true, port: ports[1]},
		"lmstudio": {ready: true, port: ports[2]},
		"llamacpp": {ready: true, port: ports[3]},
	}}
	for _, profile := range engineProxyProfiles {
		h.b.setEngineProxyHandle(profile, proxy)
	}
	go func() {
		for {
			msg, err := proxyCodec.Read()
			if err != nil {
				return
			}
			if !msg.IsRequest() {
				continue
			}
			engine, method := engines.SplitAddressedMethod(msg.Method)
			if engine == "" || method != "set-port" {
				_ = proxyCodec.Respond(msg.ID, map[string]bool{"ok": true})
				continue
			}
			var p struct {
				Port int `json:"port"`
			}
			if err := json.Unmarshal(msg.Params, &p); err != nil {
				t.Errorf("decode proxy port request: %v", err)
				return
			}
			h.proxyRebinds.Add(1)
			proxy.readyMu.Lock()
			proxy.facadeState[engine] = proxyFacadeState{ready: true, port: p.Port}
			proxy.readyMu.Unlock()
			_ = proxyCodec.Respond(msg.ID, map[string]int{"port": p.Port})
		}
	}()
	launch := settings.LaunchState{Engine: engine, ServerPort: ports[0], EffectivePort: ports[0], LaunchText: "--fixture-option", Running: true, Editable: true, Format: "pair-arguments-v1"}
	go func() {
		for {
			msg, err := codec.Read()
			if err != nil {
				return
			}
			if !msg.IsRequest() {
				continue
			}
			switch msg.Method {
			case "engine:get-launch":
				h.launchMu.Lock()
				current := launch
				h.launchMu.Unlock()
				_ = codec.Respond(msg.ID, current)
			case "engine:configured-ports":
				_ = codec.Respond(msg.ID, map[string]any{"engines": []any{map[string]any{"engine": "lmstudio", "port": h.otherEnginePort.Load()}}})
			case "engine:preview-launch":
				var p settings.Request
				_ = json.Unmarshal(msg.Params, &p)
				h.previewPreserveCORS.Store(p.PreserveCORS)
				if p.Format == "pair-launch-v1" {
					p.Settings.LaunchText = strings.TrimPrefix(p.Settings.LaunchText, "managed serve ")
				}
				h.launchMu.Lock()
				restart := launch.Running && (p.Settings.ServerPort != launch.ServerPort || p.Settings.LaunchText != launch.LaunchText)
				h.launchMu.Unlock()
				_ = codec.Respond(msg.ID, settings.Preview{Settings: p.Settings, Restart: restart})
			case "engine:configure-launch":
				// Serve this off the reader loop: a suspended apply must not
				// stop the fixture from answering an unrelated read, which is
				// exactly what the broker's lock split makes possible.
				go func(msg *Message) {
					h.applies.Add(1)
					if h.entered != nil {
						h.entered <- struct{}{}
						<-h.release
					}
					if h.failBeforeStop.Load() {
						if h.loseProxyOnStop.Load() {
							proxy.readyMu.Lock()
							state := proxy.facadeState[engine]
							state.ready = false
							proxy.facadeState[engine] = state
							proxy.readyMu.Unlock()
						}
						_ = codec.RespondError(msg.ID, -32000, "stop failure")
						return
					}
					var p settings.Configure
					_ = json.Unmarshal(msg.Params, &p)
					h.launchMu.Lock()
					launch.ServerPort = p.Settings.ServerPort
					launch.LaunchText = p.Settings.LaunchText
					launch.Running = false
					h.launchMu.Unlock()
					if err := h.b.rebindSettingsProxy(p.Engine, p.Settings.ProxyPort); err != nil {
						_ = codec.RespondError(msg.ID, -32000, err.Error())
						return
					}
					if h.fail.Load() {
						_ = codec.RespondError(msg.ID, -32000, "startup failure")
						return
					}
					h.launchMu.Lock()
					launch.EffectivePort = p.Settings.ServerPort
					launch.Running = p.Resume
					current := launch
					h.launchMu.Unlock()
					if h.failResultSave.Load() {
						journal, _ := h.b.engineSettingsPath()
						if err := os.Remove(journal); err != nil {
							t.Error(err)
						}
						if err := os.Mkdir(journal, 0700); err != nil {
							t.Error(err)
						}
					}
					_ = codec.Respond(msg.ID, current)
				}(msg)
			default:
				_ = codec.RespondError(msg.ID, -32601, "unsupported fixture method")
			}
		}
	}()
	return h
}

func (h *settingsHarness) request(t *testing.T) settings.Request {
	t.Helper()
	s, err := h.b.getEngineSettings(context.Background(), settings.Request{Engine: "ollama"}, "")
	if err != nil {
		t.Fatal(err)
	}
	return settings.Request{Engine: "ollama", ExpectedRevision: s.Revision, RequestID: settingsID(), Settings: s.Settings}
}

func TestSettingsCoordinatorRevisionDedupNoopAndFailure(t *testing.T) {
	h := newSettingsHarness(t)
	p := h.request(t)
	receipt, err := h.b.applyEngineSettings(context.Background(), p, "")
	if err != nil {
		t.Fatal(err)
	}
	if h.applies.Load() != 0 || receipt.Phase != "succeeded" {
		t.Fatal("no-op mutated runtime")
	}
	p = h.request(t)
	p.Settings.LaunchText += " --parallel 2"
	receipt, err = h.b.applyEngineSettings(context.Background(), p, "")
	if err != nil {
		t.Fatal(err)
	}
	if receipt.Revision != p.ExpectedRevision+1 || receipt.Phase != "succeeded" || h.applies.Load() != 1 {
		t.Fatalf("receipt=%+v applies=%d", receipt, h.applies.Load())
	}
	if _, err = h.b.applyEngineSettings(context.Background(), p, ""); err != nil || h.applies.Load() != 1 {
		t.Fatal("duplicate restarted")
	}
	reused := p
	reused.Settings.LaunchText += " --different"
	if _, err = h.b.applyEngineSettings(context.Background(), reused, ""); err == nil {
		t.Fatal("reused identifier accepted")
	}
	p.RequestID = settingsID()
	if _, err = h.b.applyEngineSettings(context.Background(), p, ""); err == nil {
		t.Fatal("stale revision accepted")
	}
	p = h.request(t)
	p.Settings.LaunchText += " --invalid"
	h.fail.Store(true)
	receipt, err = h.b.applyEngineSettings(context.Background(), p, "")
	if err != nil || receipt.Phase != "failed" {
		t.Fatalf("failure receipt %+v %v", receipt, err)
	}
	s := h.b.engineSettings["ollama"].Snapshot
	if s.Settings != p.Settings || s.Running || s.AppliedRevision >= s.Revision || s.Error == "" {
		t.Fatalf("untruthful failed snapshot: %+v", s)
	}
	h.fail.Store(false)
	p = h.request(t)
	if _, err = h.b.applyEngineSettings(context.Background(), p, ""); err != nil {
		t.Fatal(err)
	}
	if s := h.b.engineSettings["ollama"].Snapshot; !s.Running || s.Phase != "succeeded" {
		t.Fatalf("retry lost resume intent: %+v", s)
	}
}

func TestSettingsFailedApplyRestoresOnlyRunningReadyService(t *testing.T) {
	for _, tc := range []struct {
		name       string
		stopFails  bool
		proxyReady bool
		advertised bool
	}{
		{"stop failed with engine still running", true, true, true},
		{"engine stopped before startup failed", false, true, false},
		{"proxy unavailable", true, false, false},
	} {
		t.Run(tc.name, func(t *testing.T) {
			h := newSettingsHarness(t)
			p := h.request(t)
			oldPort := p.Settings.ProxyPort
			h.b.regCache = relay.NewRegistrationCache()
			h.b.registerService(noderec.RegisterParams{Service: noderec.ServiceOllama, Port: oldPort})
			h.failBeforeStop.Store(tc.stopFails)
			h.fail.Store(true)
			h.loseProxyOnStop.Store(!tc.proxyReady)
			p.Settings.LaunchText += " --new-option"
			receipt, err := h.b.applyEngineSettings(context.Background(), p, "")
			if err != nil || receipt.Phase != "failed" {
				t.Fatalf("expected failed receipt, got %+v, %v", receipt, err)
			}
			registered := h.b.regCache.Snapshot()
			if tc.advertised {
				if len(registered) != 1 || registered[0].Service != noderec.ServiceOllama || registered[0].Port != oldPort {
					t.Fatalf("running engine lost registration: %+v", registered)
				}
			} else if len(registered) != 0 {
				t.Fatalf("unavailable service advertised: %+v", registered)
			}
		})
	}
}

func TestSettingsCoordinatorSerializesAndCancelsQueuedRequests(t *testing.T) {
	h := newSettingsHarness(t)
	p := h.request(t)
	p.Settings.LaunchText += " --first"
	h.entered = make(chan struct{}, 1)
	h.release = make(chan struct{})
	done := make(chan error, 1)
	go func() { _, err := h.b.applyEngineSettings(context.Background(), p, ""); done <- err }()
	<-h.entered
	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	other := p
	other.RequestID = settingsID()
	canceled := make(chan error, 1)
	go func() { _, err := h.b.applyEngineSettings(ctx, other, ""); canceled <- err }()
	close(h.release)
	if err := <-done; err != nil {
		t.Fatal(err)
	}
	if err := <-canceled; err == nil {
		t.Fatal("canceled queued mutation accepted")
	}
	if h.applies.Load() != 1 {
		t.Fatal("concurrent request mutated runtime")
	}
}

// An apply stops and restarts an engine, which can run for minutes. Holding the
// journal lock across that froze the other engine's editor and the refresh
// poller for the whole restart.
func TestSettingsApplyDoesNotBlockUnrelatedReads(t *testing.T) {
	h := newSettingsHarness(t)
	p := h.request(t)
	p.Settings.LaunchText += " --busy"
	h.entered = make(chan struct{}, 1)
	h.release = make(chan struct{})
	done := make(chan error, 1)
	go func() { _, err := h.b.applyEngineSettings(context.Background(), p, ""); done <- err }()
	<-h.entered

	read := make(chan error, 1)
	go func() {
		_, err := h.b.getEngineSettings(context.Background(), settings.Request{Engine: "lmstudio"}, "")
		read <- err
	}()
	select {
	case err := <-read:
		if err != nil {
			t.Fatalf("read during an in-flight apply failed: %v", err)
		}
	case <-time.After(10 * time.Second):
		t.Fatal("engine settings read blocked behind an in-flight apply")
	}

	close(h.release)
	if err := <-done; err != nil {
		t.Fatal(err)
	}
}

func TestSettingsResultPersistenceFailureReturnsFailedReceipt(t *testing.T) {
	h := newSettingsHarness(t)
	p := h.request(t)
	p.Settings.LaunchText += " --new"
	h.failResultSave.Store(true)
	receipt, err := h.b.applyEngineSettings(context.Background(), p, "")
	if err != nil || receipt.Phase != "failed" || h.b.engineSettings["ollama"].Snapshot.Phase != "failed" {
		t.Fatalf("result persistence failure claimed success: %+v %v", receipt, err)
	}
}

func TestSettingsJournalFailureAndInterruptedRecovery(t *testing.T) {
	h := newSettingsHarness(t)
	p := h.request(t)
	p.Settings.LaunchText += " --new"
	path, _ := h.b.engineSettingsPath()
	if err := os.Remove(path); err != nil {
		t.Fatal(err)
	}
	if err := os.Mkdir(path, 0700); err != nil {
		t.Fatal(err)
	}
	if _, err := h.b.applyEngineSettings(context.Background(), p, ""); err == nil || h.applies.Load() != 0 {
		t.Fatal("runtime changed despite failed journal write")
	}
	if err := os.Remove(path); err != nil {
		t.Fatal(err)
	}
	r := h.b.engineSettings["ollama"]
	r.Snapshot.Settings = p.Settings
	r.Snapshot.Revision++
	r.Snapshot.Phase = "applying"
	r.Resume = true
	r.Explicit = true
	if err := h.b.saveEngineSettingsLocked(); err != nil {
		t.Fatal(err)
	}
	// Simulate a fresh coordinator after its journal was written but component
	// writes/rebind/start had not completed. The same replay handles later cuts.
	h.b.engineSettingsLoaded = false
	if !h.b.recoverEngineSettings() {
		t.Fatal("recovery refused")
	}
	if h.applies.Load() != 1 || h.b.engineSettings["ollama"].Snapshot.Phase != "succeeded" {
		t.Fatal("accepted operation not recovered")
	}
	if !h.b.recoverEngineSettings() || h.applies.Load() != 1 {
		t.Fatal("completed operation replayed")
	}
	if _, ok := h.b.explicitEngineSettings("ollama"); !ok {
		t.Fatal("explicit startup preference lost")
	}
}

func TestSettingsPortValidationIncludesStoppedEnginesAndAliases(t *testing.T) {
	h := newSettingsHarness(t)
	p := h.request(t)
	p.Settings.ProxyPort = p.Settings.ServerPort
	preview, err := h.b.previewEngineSettings(context.Background(), p, "")
	if err != nil {
		t.Fatal(err)
	}
	if len(preview.Errors) == 0 {
		t.Fatal("equal ports accepted")
	}
	p = h.request(t)
	p.Settings.ServerPort = engineControlPort
	preview, err = h.b.previewEngineSettings(context.Background(), p, "")
	if err != nil || len(preview.Errors) == 0 {
		t.Fatalf("reserved control port accepted: %v %v", preview, err)
	}
	p = h.request(t)
	h.otherEnginePort.Store(int32(p.Settings.ServerPort))
	preview, err = h.b.previewEngineSettings(context.Background(), p, "")
	if err != nil || len(preview.Errors) == 0 {
		t.Fatalf("stopped engine reservation ignored: %v %v", preview, err)
	}
	h.otherEnginePort.Store(0)
	h.b.ollamaHostAliasMu.Lock()
	h.b.ollamaHostAlias.Port = p.Settings.ProxyPort
	h.b.ollamaHostAliasMu.Unlock()
	preview, err = h.b.previewEngineSettings(context.Background(), p, "")
	if err != nil || len(preview.Errors) == 0 {
		t.Fatalf("proxy alias reservation ignored: %v %v", preview, err)
	}
}

func TestSettingsMigratesLegacyProxyChoiceBeforeManagedDefaults(t *testing.T) {
	h := newSettingsHarness(t)
	path, _ := h.b.engineSettingsPath()
	if err := os.WriteFile(filepath.Join(filepath.Dir(path), "proxy-port.json"), []byte(`{"port":26080}`), 0600); err != nil {
		t.Fatal(err)
	}
	h.b.migrateLegacyEngineSettings()
	config, ok := h.b.explicitEngineSettings("ollama")
	if !ok || config.ProxyPort != 26080 {
		t.Fatalf("legacy choice lost: %+v %v", config, ok)
	}
	if !h.b.prepareExplicitEngineSettings("ollama") || h.b.ollamaState().startupPort.Load() != 26080 || h.b.ollamaState().managedFacade.Load() {
		t.Fatal("automatic startup overrode saved proxy choice")
	}
}