0
0
package cache
import (
"encoding/base64"
"encoding/json"
"fmt"
"maps"
"strings"
"sync"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/opt"
"github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/atproto"
"github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/models"
)
const (
RecordValueFile = "value.json"
PolicyResultFile = "result.json"
PolicyMetaFile = "meta.json"
PolicyKeyPrefix = "policy/"
)
type Store struct {
mu sync.Mutex
entries map[string]models.CacheEntry
order []string
maxEntries int
maxBytes int64
bytes int64
}
func NewStore(maxEntries int, maxBytes int64) *Store {
return &Store{
entries: make(map[string]models.CacheEntry),
maxEntries: maxEntries,
maxBytes: maxBytes,
}
}
func (s *Store) Seed(value models.Cache) {
if s == nil {
return
}
s.mu.Lock()
defer s.mu.Unlock()
s.putLocked(value)
}
func (s *Store) Snapshot(keep func(key string) bool) models.Cache {
if s == nil {
return nil
}
s.mu.Lock()
defer s.mu.Unlock()
s.dropExpiredLocked(time.Now())
out := make(models.Cache)
for key, entry := range s.entries {
if keep != nil && !keep(key) {
continue
}
copied := make(models.CacheEntry, len(entry))
maps.Copy(copied, entry)
out[key] = copied
}
return out
}
func (s *Store) Merge(value models.Cache) {
if s == nil {
return
}
s.mu.Lock()
defer s.mu.Unlock()
s.putLocked(value)
}
func (s *Store) putLocked(value models.Cache) {
now := time.Now()
s.dropExpiredLocked(now)
for _, verdicts := range []bool{false, true} {
for key, entry := range value {
if strings.HasPrefix(key, PolicyKeyPrefix) == verdicts && !Expired(entry, now) {
s.setLocked(key, entry)
}
}
}
}
func (s *Store) Get(key string) (models.CacheEntry, bool) {
if s == nil {
return nil, false
}
s.mu.Lock()
defer s.mu.Unlock()
entry, ok := s.entries[key]
if !ok {
return nil, false
}
s.touchLocked(key)
copied := make(models.CacheEntry, len(entry))
maps.Copy(copied, entry)
return copied, true
}
func (s *Store) Set(key string, entry models.CacheEntry) {
if s == nil {
return
}
s.mu.Lock()
defer s.mu.Unlock()
s.putLocked(models.Cache{key: entry})
}
func (s *Store) Delete(key string) {
if s == nil {
return
}
s.mu.Lock()
defer s.mu.Unlock()
s.deleteLocked(key)
}
func (s *Store) Len() int {
if s == nil {
return 0
}
s.mu.Lock()
defer s.mu.Unlock()
return len(s.entries)
}
func (s *Store) setLocked(key string, entry models.CacheEntry) {
if _, exists := s.entries[key]; exists {
s.deleteLocked(key)
}
s.entries[key] = entry
s.order = append(s.order, key)
s.bytes += entryBytes(key, entry)
s.evictLocked()
}
func (s *Store) deleteLocked(key string) {
entry, ok := s.entries[key]
if !ok {
return
}
s.bytes -= entryBytes(key, entry)
delete(s.entries, key)
for i, existing := range s.order {
if existing == key {
s.order = append(s.order[:i], s.order[i+1:]...)
break
}
}
}
func (s *Store) touchLocked(key string) {
for i, existing := range s.order {
if existing == key {
s.order = append(s.order[:i], s.order[i+1:]...)
s.order = append(s.order, key)
return
}
}
}
func (s *Store) dropExpiredLocked(now time.Time) {
for key, entry := range s.entries {
if Expired(entry, now) {
s.deleteLocked(key)
}
}
}
func (s *Store) evictLocked() {
for {
if s.maxEntries > 0 && len(s.entries) > s.maxEntries {
s.deleteLocked(s.order[0])
continue
}
if s.maxBytes > 0 && s.bytes > s.maxBytes && len(s.order) > 0 {
s.deleteLocked(s.order[0])
continue
}
break
}
}
func entryBytes(key string, entry models.CacheEntry) int64 {
total := int64(len(key))
for path, file := range entry {
total += int64(len(path) + len(file.Data) + len(file.Encoding))
}
return total
}
type RecordSet struct {
RFP *atproto.StrongRef
Bid *atproto.StrongRef
Accept *atproto.StrongRef
}
func RecordKey(ref atproto.StrongRef) string {
return fmt.Sprintf("rec/%s/%s", ref.URI, ref.CID)
}
func ReadRecord(store *Store, ref atproto.StrongRef) (map[string]any, bool) {
entry, ok := store.Get(RecordKey(ref))
if !ok {
return nil, false
}
file, ok := entry[RecordValueFile]
if !ok {
return nil, false
}
var value map[string]any
if err := json.Unmarshal([]byte(file.Data), &value); err != nil {
return nil, false
}
return value, true
}
func ReadRecordCache(seed models.Cache, ref atproto.StrongRef) (map[string]any, bool) {
if len(seed) == 0 || ref.URI == "" {
return nil, false
}
entry, ok := seed[RecordKey(ref)]
if !ok {
return nil, false
}
file, ok := entry[RecordValueFile]
if !ok {
return nil, false
}
var value map[string]any
if err := decodeFile(file, &value); err != nil {
return nil, false
}
return value, true
}
func decodeFile(file models.CacheFile, into any) error {
data := []byte(file.Data)
if file.Encoding == models.CacheEncodingBase64 {
decoded, err := base64.StdEncoding.DecodeString(file.Data)
if err != nil {
return err
}
data = decoded
}
return json.Unmarshal(data, into)
}
func WriteRecord(store *Store, ref atproto.StrongRef, value map[string]any) {
data, err := json.Marshal(value)
if err != nil {
return
}
store.Set(RecordKey(ref), models.CacheEntry{
RecordValueFile: {Data: string(data), Encoding: models.CacheEncodingText},
})
}
func policyRecordPart(ref *atproto.StrongRef) string {
if ref == nil || ref.URI == "" {
return ""
}
return ref.URI + "/" + ref.CID
}
func PolicyKey(name string, records RecordSet, args map[string]any) string {
suffix := ""
if len(args) > 0 {
if data, err := json.Marshal(args); err == nil {
suffix = ":" + HashString(string(data))
}
}
return PolicyKeyPrefix + name + "/" + policyRecordsPart(records) + suffix
}
func policyRecordsPart(records RecordSet) string {
return policyRecordPart(records.RFP) + "|" + policyRecordPart(records.Bid) + "|" + policyRecordPart(records.Accept)
}
func IsPolicyKeyOf(key string, records RecordSet) bool {
rest, ok := strings.CutPrefix(key, PolicyKeyPrefix)
if !ok {
return false
}
_, tail, ok := strings.Cut(rest, "/")
want := policyRecordsPart(records)
return ok && (tail == want || strings.HasPrefix(tail, want+":"))
}
type PolicyMeta struct {
CachedAt int64 `json:"cachedAt"`
TTLMs int64 `json:"ttlMs"`
}
func ReadVerdict(store *Store, key string) ([]byte, bool) {
entry, ok := store.Get(key)
if !ok {
return nil, false
}
if Expired(entry, time.Now()) {
store.Delete(key)
return nil, false
}
file, ok := entry[PolicyResultFile]
if !ok {
return nil, false
}
return []byte(file.Data), true
}
func Expired(entry models.CacheEntry, now time.Time) bool {
file, ok := entry[PolicyMetaFile]
if !ok {
return false
}
var meta PolicyMeta
if decodeFile(file, &meta) != nil || meta.TTLMs <= 0 {
return true
}
age := now.UnixMilli() - meta.CachedAt
return age < 0 || age > meta.TTLMs
}
func WriteVerdict(store *Store, key string, data []byte, ttl time.Duration) {
ttl = opt.Positive(ttl, 30*time.Second)
meta, err := json.Marshal(PolicyMeta{CachedAt: time.Now().UnixMilli(), TTLMs: ttl.Milliseconds()})
if err != nil {
return
}
store.Set(key, models.CacheEntry{
PolicyResultFile: {Data: string(data), Encoding: models.CacheEncodingText},
PolicyMetaFile: {Data: string(meta), Encoding: models.CacheEncodingText},
})
}
func HashString(value string) string {
var hash uint32 = 5381
for i := 0; i < len(value); i++ {
hash = (hash << 5) + hash + uint32(value[i])
}
return encodeBase36(uint64(hash))
}
func encodeBase36(value uint64) string {
if value == 0 {
return "0"
}
const digits = "0123456789abcdefghijklmnopqrstuvwxyz"
var buffer [16]byte
index := len(buffer)
for value > 0 {
index--
buffer[index] = digits[value%36]
value /= 36
}
return string(buffer[index:])
}