Skip to content

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

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

package main

import (
	"context"
	"encoding/json"
	"net"
	"os"
	"strings"
	"testing"
	"time"

	settings "nvpair-shared/enginesettings"
)

func callBrokerPortRequest(t *testing.T, b *Broker, method string, params json.RawMessage) *Message {
	t.Helper()
	client, server := net.Pipe()
	t.Cleanup(func() { _ = client.Close(); _ = server.Close() })
	if err := client.SetReadDeadline(time.Now().Add(5 * time.Second)); err != nil {
		t.Fatalf("set response deadline: %v", err)
	}
	b.codec = NewCodec(server)
	id := json.RawMessage(`1`)
	go b.handleMessage(&Message{JSONRPC: "2.0", ID: &id, Method: method, Params: params})
	codec := NewCodec(client)
	for {
		response, err := codec.Read()
		if err != nil {
			t.Fatalf("read %s response: %v", method, err)
		}
		if response.IsNotification() {
			continue
		}
		if response.ID == nil || string(*response.ID) != string(id) {
			t.Fatalf("unexpected response ID: %+v", response)
		}
		return response
	}
}

func TestBrokerProxySetPortRejectsInvalidPorts(t *testing.T) {
	for _, profile := range engineProxyProfiles {
		t.Run(profile.Name, func(t *testing.T) {
			for _, tc := range []struct{ name, params string }{
				{"malformed parameters", `{`},
				{"missing port", `{}`},
				{"zero port", `{"port":0}`},
				{"negative port", `{"port":-1}`},
				{"oversized port", `{"port":65536}`},
			} {
				t.Run(tc.name, func(t *testing.T) {
					response := callBrokerPortRequest(t, &Broker{}, profile.ComponentName()+":set-port", json.RawMessage(tc.params))
					if response.Error == nil || response.Error.Code != -32602 || response.Error.Message != "port must be between 1 and 65535" {
						t.Fatalf("response = %+v, want invalid-port error", response)
					}
				})
			}
		})
	}
}

func TestBrokerProxySetPortRejectsInheritedAlias(t *testing.T) {
	for _, profile := range engineProxyProfiles {
		t.Run(profile.Name, func(t *testing.T) {
			b := &Broker{}
			b.setOllamaHostAlias(ollamaHostAlias{Port: 11433})
			response := callBrokerPortRequest(t, b, profile.ComponentName()+":set-port", json.RawMessage(`{"port":11433}`))
			if response.Error == nil || response.Error.Code != -32000 || !strings.Contains(response.Error.Message, "OLLAMA_HOST proxy alias") {
				t.Fatalf("response = %+v, want alias-port rejection", response)
			}
		})
	}
}

func TestBrokerLlamaCPPProxySetPortRejectsConflicts(t *testing.T) {
	test := func(name string, port func(*testing.T, *settingsHarness, settings.Snapshot) int) {
		t.Run(name, func(t *testing.T) {
			h := newSettingsHarnessForEngine(t, "llamacpp")
			before, err := h.b.getEngineSettings(context.Background(), settings.Request{Engine: "llamacpp"}, "")
			if err != nil {
				t.Fatalf("read initial settings: %v", err)
			}
			target := port(t, h, before)
			response := callBrokerPortRequest(t, h.b, "llamacpp-proxy:set-port", settingsJSON(map[string]int{"port": target}))
			if response.Error == nil || response.Error.Code != -32000 || response.Error.Message != "resolve settings errors and port conflicts before applying" {
				t.Fatalf("error = %+v, want settings-conflict rejection", response.Error)
			}
			if h.applies.Load() != 0 || h.proxyRebinds.Load() != 0 {
				t.Fatal("rejected port request changed runtime")
			}
			h.b.engineConfigMu.Lock()
			after := h.b.engineSettings["llamacpp"].Snapshot
			h.b.engineConfigMu.Unlock()
			if after.Settings != before.Settings || after.Revision != before.Revision {
				t.Fatalf("rejection changed desired settings: before=%+v after=%+v", before, after)
			}
		})
	}
	test("PAIR service port", func(t *testing.T, h *settingsHarness, before settings.Snapshot) int {
		return engineControlPort
	})
	test("same engine server port", func(t *testing.T, h *settingsHarness, before settings.Snapshot) int {
		return before.Settings.ServerPort
	})
	test("another configured engine", func(t *testing.T, h *settingsHarness, before settings.Snapshot) int {
		h.otherEnginePort.Store(25001)
		return 25001
	})
	test("another proxy listener", func(t *testing.T, h *settingsHarness, before settings.Snapshot) int {
		_, port := h.b.getProxy().Status("ollama")
		return port
	})
	test("occupied listener", func(t *testing.T, h *settingsHarness, before settings.Snapshot) int {
		ln, err := net.Listen("tcp", ":0")
		if err != nil {
			t.Fatalf("bind occupied port: %v", err)
		}
		t.Cleanup(func() { _ = ln.Close() })
		return ln.Addr().(*net.TCPAddr).Port
	})
}

func TestBrokerLlamaCPPProxySetPortPersistsOnlyRequestedFacade(t *testing.T) {
	h := newSettingsHarnessForEngine(t, "llamacpp")
	before, err := h.b.getEngineSettings(context.Background(), settings.Request{Engine: "llamacpp"}, "")
	if err != nil {
		t.Fatalf("read initial settings: %v", err)
	}
	otherPorts := make(map[string]int)
	for _, engine := range []string{"ollama", "lmstudio"} {
		_, otherPorts[engine] = h.b.getProxy().Status(engine)
	}
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("allocate target port: %v", err)
	}
	target := ln.Addr().(*net.TCPAddr).Port
	if err := ln.Close(); err != nil {
		t.Fatalf("release target port: %v", err)
	}
	// The namespace determines the engine, even if parameters name another.
	response := callBrokerPortRequest(t, h.b, "llamacpp-proxy:set-port", settingsJSON(map[string]any{"engine": "ollama", "port": target}))
	if response.Error != nil {
		t.Fatalf("set proxy port: %+v", response.Error)
	}
	var result struct {
		Port int `json:"port"`
	}
	if err := json.Unmarshal(response.Result, &result); err != nil {
		t.Fatalf("decode port result: %v", err)
	}
	if result.Port != target || h.proxyRebinds.Load() != 1 {
		t.Fatalf("port=%d rebinds=%d, want port=%d and one rebind", result.Port, h.proxyRebinds.Load(), target)
	}
	ready, actual := h.b.getProxy().Status("llamacpp")
	if !ready || actual != target {
		t.Fatalf("llama.cpp facade ready=%v port=%d, want %d", ready, actual, target)
	}
	for engine, want := range otherPorts {
		_, actual := h.b.getProxy().Status(engine)
		if actual != want {
			t.Fatalf("%s facade moved from %d to %d", engine, want, actual)
		}
	}
	path, err := h.b.engineSettingsPath()
	if err != nil {
		t.Fatalf("resolve journal path: %v", err)
	}
	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("read journal: %v", err)
	}
	var records map[string]*engineSettingsRecord
	if err := json.Unmarshal(data, &records); err != nil {
		t.Fatalf("decode journal: %v", err)
	}
	record := records["llamacpp"]
	want := before.Settings
	want.ProxyPort = target
	if record == nil || !record.Explicit || record.Snapshot.Settings != want || record.Snapshot.Phase != "succeeded" || record.Snapshot.Revision != before.Revision+1 {
		t.Fatalf("persisted record = %+v, want successful explicit proxy-port change", record)
	}
}