diff --git a/internal/modules/dnd/locations/registry/registry.go b/internal/modules/dnd/locations/registry/registry.go index cc8e22a..ef979fe 100644 --- a/internal/modules/dnd/locations/registry/registry.go +++ b/internal/modules/dnd/locations/registry/registry.go @@ -7,9 +7,6 @@ import ( "encoding/hex" "encoding/json" "fmt" - "mime" - "strings" - "sync" "gitea.maximumdirect.net/eric/notarius/internal/core/source" "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" @@ -17,6 +14,7 @@ import ( locationcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/locations" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/locations/identity" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics" + "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/registryresolver" ) const ( @@ -37,38 +35,20 @@ type Registry struct { lookupByID map[string]int } -// Resolver retains the construction-time registry and memoizes immutable -// operation-time registries. It never retains caller-owned reference bytes. +// Resolver selects and memoizes immutable location registry views. type Resolver struct { - seeded *Registry - - mu sync.Mutex - cache map[string]*Registry - rawCache map[string]*Registry + resolver *registryresolver.Resolver[*Registry] } // NewResolver validates a materialized construction-time location reference. // An empty slot is permitted because a generated reference is supplied only at // operation time. func NewResolver(references contracts.ReferenceSet) (*Resolver, error) { - seeded, err := Resolve(constructionReferences(references)) + resolver, err := registryresolver.New(registryResolverConfig(), references) if err != nil { return nil, err } - return &Resolver{seeded: seeded, cache: make(map[string]*Registry), rawCache: make(map[string]*Registry)}, nil -} - -func constructionReferences(references contracts.ReferenceSet) contracts.ReferenceSet { - slot, ok := references.Slots[ReferenceSlot] - if !ok || len(slot.Items) > 0 { - return references - } - cloned := contracts.ReferenceSet{Slots: make(map[string]contracts.ResolvedReferenceSlot, len(references.Slots))} - for name, value := range references.Slots { - cloned.Slots[name] = value - } - delete(cloned.Slots, ReferenceSlot) - return cloned + return &Resolver{resolver: resolver}, nil } // Seeded returns the validated construction-time registry. @@ -76,95 +56,63 @@ func (r *Resolver) Seeded() *Registry { if r == nil { return nil } - return r.seeded + return r.resolver.Seeded() } // Resolve returns the generated operation-time registry when the locations // slot is present, otherwise it returns the construction-time registry. func (r *Resolver) Resolve(references contracts.ReferenceSet) (*Registry, error) { - if r == nil { + if r == nil || r.resolver == nil { return Resolve(references) } - if _, ok := references.Slots[ReferenceSlot]; !ok { - return r.seeded, nil - } - - slot := references.Slots[ReferenceSlot] - rawKey := "" - if len(slot.Items) == 1 { - rawKey = strings.ToLower(strings.TrimSpace(slot.Items[0].MediaType)) + "\x00" + semanticDigest(slot.Items[0].Content) - } - - r.mu.Lock() - defer r.mu.Unlock() - if rawKey != "" { - if cached, ok := r.rawCache[rawKey]; ok { - return cached, nil - } - } - resolved, err := Resolve(references) - if err != nil { - return nil, err - } - if sameRegistryIdentity(r.seeded, resolved) { - if rawKey != "" { - r.rawCache[rawKey] = r.seeded - } - return r.seeded, nil - } - if cached, ok := r.cache[resolved.Digest()]; ok { - if rawKey != "" { - r.rawCache[rawKey] = cached - } - return cached, nil - } - r.cache[resolved.Digest()] = resolved - if rawKey != "" { - r.rawCache[rawKey] = resolved - } - return resolved, nil -} - -func sameRegistryIdentity(first, second *Registry) bool { - if first == nil || second == nil { - return first == second - } - return first.bound == second.bound && first.digest == second.digest + return r.resolver.Resolve(references) } // Resolve validates an optional location-list reference. An absent reference // uses the canonical empty projection and has no durable registry identity. func Resolve(references contracts.ReferenceSet) (*Registry, error) { - slot, ok := references.Slots[ReferenceSlot] - if !ok { - content := []byte(emptyPrompt) - projectionDigest := semanticDigest(content) - return &Registry{ - list: dnd.LocationList{Locations: []dnd.Location{}}, - canonical: append([]byte(nil), content...), - projectionDigest: projectionDigest, - promptInput: contracts.NewLLMInputMaterial(ReferenceSlot, locationcodec.MediaType, content, projectionDigest, ""), - lookupByID: map[string]int{}, - }, nil - } - if len(slot.Items) != 1 { - return nil, fmt.Errorf("reference slot %q must contain exactly one item", ReferenceSlot) - } - - item := slot.Items[0] - mediaType, _, err := mime.ParseMediaType(item.MediaType) + item, present, err := registryresolver.ResolveOptionalSingleItem(references, locationReferenceSpec()) if err != nil { - return nil, fmt.Errorf("reference slot %q item media type is invalid", ReferenceSlot) + return nil, err } - if !strings.EqualFold(mediaType, locationcodec.MediaType) { - return nil, fmt.Errorf("reference slot %q item media type must be %s", ReferenceSlot, locationcodec.MediaType) - } - if len(item.Content) > MaxBytes { - return nil, fmt.Errorf("reference slot %q item is %d bytes, limit %d", ReferenceSlot, len(item.Content), MaxBytes) + if !present { + return emptyRegistry(), nil } + return loadRegistry(item.Content) +} +func registryResolverConfig() registryresolver.Config[*Registry] { + return registryresolver.Config[*Registry]{ + Reference: locationReferenceSpec(), + Absent: func() (*Registry, error) { + return emptyRegistry(), nil + }, + Load: loadRegistry, + SemanticIdentity: func(registry *Registry) string { + return registry.Digest() + }, + } +} + +func locationReferenceSpec() registryresolver.ReferenceSpec { + return registryresolver.ReferenceSpec{SlotName: ReferenceSlot, AcceptedMediaType: locationcodec.MediaType, MaxBytes: MaxBytes} +} + +func emptyRegistry() *Registry { + content := []byte(emptyPrompt) + projectionDigest := semanticDigest(content) + return &Registry{ + list: dnd.LocationList{Locations: []dnd.Location{}}, + canonical: append([]byte(nil), content...), + projectionDigest: projectionDigest, + promptInput: contracts.NewLLMInputMaterial(ReferenceSlot, locationcodec.MediaType, content, projectionDigest, ""), + lookupByID: map[string]int{}, + } +} + +func loadRegistry(referenceContent []byte) (*Registry, error) { codec := locationcodec.New() - value, err := codec.Decode(item.Content) + value, err := codec.Decode(referenceContent) if err != nil { return nil, fmt.Errorf("decode location registry: invalid approved location JSON") } diff --git a/internal/modules/dnd/locations/registry/registry_test.go b/internal/modules/dnd/locations/registry/registry_test.go index 6723f08..b6cce41 100644 --- a/internal/modules/dnd/locations/registry/registry_test.go +++ b/internal/modules/dnd/locations/registry/registry_test.go @@ -100,18 +100,47 @@ func TestResolveRejectsInvalidReferenceInputs(t *testing.T) { } } -func TestNewResolverValidatesStaticReferenceBeforeOperations(t *testing.T) { - if _, err := NewResolver(referenceSet(item([]byte(`{"locations":[`)))); err == nil || !strings.Contains(err.Error(), "invalid approved") { - t.Fatalf("NewResolver() error = %v, want malformed static reference failure", err) +func TestResolverValidatesStaticAndOperationReferences(t *testing.T) { + placeholder, err := NewResolver(referenceSet()) + if err != nil || placeholder.Seeded().Bound() { + t.Fatalf("generated placeholder = %#v, %v; want unbound seed", placeholder, err) } - resolver, err := NewResolver(referenceSet(item(encodeList(t, registryFixture())))) - if err != nil || !resolver.Seeded().Bound() || resolver.Seeded().Count() != 2 { - t.Fatalf("NewResolver() = %#v, %v", resolver, err) + + validContent := encodeList(t, registryFixture()) + invalidSets := []contracts.ReferenceSet{ + referenceSet(item([]byte(`{"locations":[`))), + referenceSet(contracts.ReferenceItem{MediaType: "text/plain", Content: validContent}), + referenceSet(item(make([]byte, MaxBytes+1))), + referenceSet(item(validContent), item(validContent)), + } + for index, references := range invalidSets { + if _, err := NewResolver(references); err == nil { + t.Fatalf("NewResolver(invalid %d) error = nil", index) + } + if _, err := placeholder.Resolve(references); err == nil { + t.Fatalf("Resolve(invalid %d) error = nil", index) + } + } + + staticContent := append([]byte(nil), validContent...) + staticReferences := referenceSet(item(staticContent)) + seeded, err := NewResolver(staticReferences) + if err != nil { + t.Fatal(err) + } + resolved, err := seeded.Resolve(staticReferences) + if err != nil || resolved != seeded.Seeded() { + t.Fatalf("seed reuse = %p / %p, %v", resolved, seeded.Seeded(), err) + } + staticContent[0] = '[' + delete(staticReferences.Slots, ReferenceSlot) + if seeded.Seeded().Count() != 2 || seeded.Seeded().CanonicalBytes()[0] != '{' { + t.Fatalf("seeded registry retained construction references: %#v", seeded.Seeded()) } } -func TestResolverCachesRawAndSemanticallyEquivalentRegistriesConcurrently(t *testing.T) { - resolver, err := NewResolver(contracts.ReferenceSet{}) +func TestResolverCachesEquivalentRegistriesConcurrentlyAndIgnoresCallerDigest(t *testing.T) { + resolver, err := NewResolver(referenceSet()) if err != nil { t.Fatal(err) } @@ -130,7 +159,7 @@ func TestResolverCachesRawAndSemanticallyEquivalentRegistriesConcurrently(t *tes } spaced := append([]byte("\n "), content...) spaced = append(spaced, '\n') - third, err := resolver.Resolve(referenceSet(item(spaced))) + third, err := resolver.Resolve(referenceSet(contracts.ReferenceItem{MediaType: "APPLICATION/JSON; charset=utf-8", Content: spaced})) if err != nil || third != first { t.Fatalf("semantic cache Resolve() = %p, %p, %v", first, third, err) } @@ -153,13 +182,29 @@ func TestResolverCachesRawAndSemanticallyEquivalentRegistriesConcurrently(t *tes t.Error(err) } - firstSet.Slots[ReferenceSlot].Items[0].Content[0] = '[' - if registry, err := resolver.Resolve(contracts.ReferenceSet{}); err != nil || registry != resolver.Seeded() || registry.Count() != 0 { - t.Fatalf("caller bytes affected resolver: %#v, %v", registry, err) + sharedDigest := "sha256:" + strings.Repeat("0", 64) + firstItem := contracts.ReferenceItem{MediaType: locationcodec.MediaType, Content: content, Digest: sharedDigest} + otherList := registryFixture() + otherList.Locations[0].Name = "Moon Gate" + otherList.Locations[0].ID = identity.DeriveID(otherList.Locations[0].Name, otherList.Locations[0].SourceRefs) + otherContent := encodeList(t, otherList) + otherItem := contracts.ReferenceItem{MediaType: locationcodec.MediaType, Content: otherContent, Digest: sharedDigest} + byDigestFirst, err := resolver.Resolve(referenceSet(firstItem)) + if err != nil { + t.Fatal(err) } + byDigestOther, err := resolver.Resolve(referenceSet(otherItem)) + if err != nil || byDigestFirst == byDigestOther || byDigestFirst.Digest() == byDigestOther.Digest() { + t.Fatalf("caller digest aliased different registries: %p / %p, %v", byDigestFirst, byDigestOther, err) + } + + firstSet.Slots[ReferenceSlot].Items[0].Content[0] = '[' if got, ok := first.Lookup(registryFixture().Locations[0].ID); !ok || got.Name != "The Tavern" { t.Fatalf("cached registry retained caller bytes: %#v, %t", got, ok) } + if fallback, err := resolver.Resolve(contracts.ReferenceSet{}); err != nil || fallback != resolver.Seeded() || fallback.Bound() { + t.Fatalf("fallback = %#v, %v; want unbound seed", fallback, err) + } } func registryFixture() dnd.LocationList {