mirror of
https://github.com/netbirdio/netbird.git
synced 2026-09-25 16:19:07 +02:00
Maycon Santos
b416063bcc
* [agent-network] Shared proto, OpenAPI schema, and generated types * [agent-network] Management: store, manager, synthesizer, policy engine, provider catalog, HTTP/gRPC API Adds the account-scoped agent-network module: provider/policy/budget CRUD and store, the reverse-proxy service synthesizer, policy selection + limit enforcement, the provider catalog (incl. Vertex AI and AWS Bedrock entries), and the management HTTP + proxy gRPC surfaces. * [management] Fix agent-network proxy-peer fan-out on affected-peer recompute The affected-peers resolver loaded only persisted reverse-proxy services, but agent-network services are synthesized on demand and never persisted. As a result the embedded proxy peer was never folded into the affected set when a client's group changed, so the proxy received no network-map update for a newly authorised client and rejected its handshake until a full resync (restart). loadProxyServices now merges the synthesized agent-network services (injected via a registration hook to avoid an import cycle), so proxy peers learn newly authorised clients immediately. * [proxy] Reverse-proxy middleware framework, chain, and request plumbing The per-target middleware chain (slots, dispatcher, mutation gate, metadata merger), body capture, access-log terminal sink, and the proxy wiring that builds + runs chains for synthesized agent-network services. * [proxy] LLM parsers, pricing, and builtin middlewares (OpenAI, Anthropic, Vertex AI, AWS Bedrock) Request/response parsers and SSE/event-stream metering, the embedded pricing table, and the builtin middleware set: request parser, router, policy limit-check/record, cost meter, guardrail, identity inject, response parser. Includes the path-routed providers — Google Vertex AI (keyfile:: service-account OAuth minting) and AWS Bedrock (bearer auth, invoke/converse/streaming, optional /bedrock prefix) — plus the Models allowlist and unmeterable-publisher deny. * [proxy] IPv6 in-place apply and TCP accept-loop hardening on netstack listeners * [agent-network] End-to-end test suite, module docs, and deployment preset * [agent-network] Fix codespell typos and exclude false positives - labelgen word pool: vermillion -> vermilion, racoon -> raccoon. - codespell ignore list: add flate (Go compress/flate package), recordin (a test-local identifier), and unparseable (a valid alternative spelling used consistently across identifiers + a metadata-value constant). * [management] Set LastSeen on injected proxy peer in realstack test (MySQL strict-mode) The injected embedded proxy peer had a PeerStatus with a zero LastSeen, which serializes to '0000-00-00' and is rejected by MySQL in strict mode (SQLite tolerates it). Set LastSeen to a valid time so SaveAccount succeeds on both engines. * [agent-network] Remove e2e shell-script suite from this branch The end-to-end shell scripts under scripts/e2e/ are maintained in a separate testing suite and are not part of this change set. * [agent-network] Polish module docs: remove internal review scaffolding, fix links, verify diagrams Strip PR-review framing, commit references, absolute paths, and stale internal references from the agent-network module docs; fix broken relative links; verify all diagrams against the current architecture. Remove the internal AI-reviewer prompt file. * [management] Refine session expiration handling to support 3-state encoding for SSO deadlines * [agent-network] Relocate agentnetwork package to internals/modules Move management/server/agentnetwork (and its catalog/, labelgen/, types/ subpackages) to management/internals/modules/agentnetwork, alongside the reverse-proxy module, and rewrite all importers. Pure relocation: package names, the synthesizer + affectedpeers registration hook, and store access (shared store.Store) are unchanged, so no import cycle is introduced (affectedpeers still depends only on the agentnetwork/types leaf). * [agent-network] Co-locate HTTP handlers in the module (RegisterEndpoints) Move the agent-network HTTP handlers from server/http/handlers/agentnetwork into the module at internals/modules/agentnetwork/handlers (package handlers) and rename the entrypoint AddEndpoints -> RegisterEndpoints, matching the reverse-proxy module convention. Wiring in http/handler.go updated accordingly.
102 lines
3.1 KiB
Go
102 lines
3.1 KiB
Go
package labelgen
|
|
|
|
import (
|
|
"math/rand"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// TestPickUnique_DeterministicWithSeededRng locks the property the
|
|
// caller relies on: same seed + same taken set → same pick. Without
|
|
// that, the bootstrap flow can't reproduce a label across retries.
|
|
func TestPickUnique_DeterministicWithSeededRng(t *testing.T) {
|
|
taken := map[string]struct{}{}
|
|
|
|
rngA := rand.New(rand.NewSource(42))
|
|
rngB := rand.New(rand.NewSource(42))
|
|
|
|
a := PickUnique(rngA, taken, "abcd")
|
|
b := PickUnique(rngB, taken, "abcd")
|
|
|
|
assert.Equal(t, a, b, "Same seed and taken set must produce identical pick")
|
|
}
|
|
|
|
// TestPickUnique_AvoidsTakenWordsWhenMostAreReserved seeds taken with
|
|
// every word in the pool except a handful and confirms PickUnique
|
|
// finds one of the remaining free entries instead of returning the
|
|
// fallback form.
|
|
func TestPickUnique_AvoidsTakenWordsWhenMostAreReserved(t *testing.T) {
|
|
pool := uniqueWords()
|
|
require.NotEmpty(t, pool, "wordlist must be populated for the test to mean anything")
|
|
|
|
free := map[string]struct{}{
|
|
pool[0]: {},
|
|
pool[len(pool)/2]: {},
|
|
pool[len(pool)-1]: {},
|
|
}
|
|
|
|
taken := make(map[string]struct{}, len(pool))
|
|
for _, w := range pool {
|
|
if _, ok := free[w]; ok {
|
|
continue
|
|
}
|
|
taken[w] = struct{}{}
|
|
}
|
|
|
|
rng := rand.New(rand.NewSource(7))
|
|
got := PickUnique(rng, taken, "abcd")
|
|
|
|
_, isFree := free[got]
|
|
assert.True(t, isFree, "PickUnique must return one of the free words; got %q", got)
|
|
assert.NotContains(t, got, "-", "Free pick must not be the suffix fallback form")
|
|
}
|
|
|
|
// TestPickUnique_FallsBackWhenAllReserved exhausts the pool and
|
|
// confirms PickUnique appends the supplied suffix instead of
|
|
// returning a duplicate.
|
|
func TestPickUnique_FallsBackWhenAllReserved(t *testing.T) {
|
|
pool := uniqueWords()
|
|
|
|
taken := make(map[string]struct{}, len(pool))
|
|
for _, w := range pool {
|
|
taken[w] = struct{}{}
|
|
}
|
|
|
|
rng := rand.New(rand.NewSource(99))
|
|
got := PickUnique(rng, taken, "abcd")
|
|
|
|
assert.True(t, strings.HasSuffix(got, "-abcd"), "Exhausted pool must produce <word>-<suffix>; got %q", got)
|
|
|
|
prefix := strings.TrimSuffix(got, "-abcd")
|
|
found := false
|
|
for _, w := range pool {
|
|
if w == prefix {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
assert.True(t, found, "Fallback prefix must be drawn from the wordlist; got %q", prefix)
|
|
}
|
|
|
|
// TestUniqueWords_DropsDuplicates guards against authoring slips in
|
|
// words.go: every entry must be unique and DNS-safe.
|
|
func TestUniqueWords_DropsDuplicates(t *testing.T) {
|
|
pool := uniqueWords()
|
|
seen := make(map[string]struct{}, len(pool))
|
|
for _, w := range pool {
|
|
_, dup := seen[w]
|
|
assert.False(t, dup, "Duplicate entry %q in deduplicated pool", w)
|
|
seen[w] = struct{}{}
|
|
assert.GreaterOrEqual(t, len(w), 4, "Word %q is shorter than 4 chars", w)
|
|
assert.LessOrEqual(t, len(w), 12, "Word %q is longer than 12 chars", w)
|
|
for _, r := range w {
|
|
ok := r >= 'a' && r <= 'z'
|
|
assert.True(t, ok, "Word %q contains non-lowercase-ASCII rune %q", w, r)
|
|
}
|
|
}
|
|
assert.GreaterOrEqual(t, len(pool), 500, "Pool must contain at least 500 unique words")
|
|
}
|