feat: add cache, outbound HTTP, request protection, tasks and module scaffolding

2026-09-23 13:38:25 +08:00
parent 467c890363
commit fe66221a9c
34 changed files with 3100 additions and 1 deletions
--- a/cache/memory.go
+++ b/cache/memory.go
@@ -0,0 +1,135 @@
+package cache
+
+import (
+	"container/list"
+	"context"
+	"errors"
+	"sync"
+	"time"
+)
+
+type MemoryConfig struct {
+	MaxEntries int `json:"maxEntries"`
+	MaxBytes   int `json:"maxBytes"` // Sum of key and value bytes, excluding Go object overhead.
+}
+
+type entry struct {
+	key     string
+	value   []byte
+	expires time.Time
+}
+
+// Memory is an LRU cache with lazy expiration and no background goroutines.
+type Memory struct {
+	mu     sync.Mutex
+	config MemoryConfig
+	items  map[string]*list.Element
+	lru    *list.List
+	bytes  int
+	closed bool
+	now    func() time.Time
+}
+
+func NewMemory(cfg MemoryConfig) (*Memory, error) {
+	if cfg.MaxEntries < 0 || cfg.MaxBytes < 0 {
+		return nil, errors.New("cache: negative capacity")
+	}
+	if cfg.MaxEntries == 0 {
+		cfg.MaxEntries = 4096
+	}
+	if cfg.MaxBytes == 0 {
+		cfg.MaxBytes = 32 << 20
+	}
+	return &Memory{config: cfg, items: make(map[string]*list.Element), lru: list.New(), now: time.Now}, nil
+}
+
+func (m *Memory) Get(ctx context.Context, key string) ([]byte, error) {
+	if err := Check(ctx, key, 0); err != nil {
+		return nil, err
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.closed {
+		return nil, ErrClosed
+	}
+	e := m.items[key]
+	if e == nil {
+		return nil, ErrMiss
+	}
+	item := e.Value.(*entry)
+	if !item.expires.IsZero() && !m.now().Before(item.expires) {
+		m.remove(e)
+		return nil, ErrMiss
+	}
+	m.lru.MoveToFront(e)
+	return append([]byte(nil), item.value...), nil
+}
+
+func (m *Memory) Set(ctx context.Context, key string, value []byte, ttl time.Duration) error {
+	if err := Check(ctx, key, ttl); err != nil {
+		return err
+	}
+	if len(value) > m.config.MaxBytes-len(key) {
+		return ErrTooLarge
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.closed {
+		return ErrClosed
+	}
+	if e := m.items[key]; e != nil {
+		m.remove(e)
+	}
+	for len(m.items) >= m.config.MaxEntries || m.bytes+len(key)+len(value) > m.config.MaxBytes {
+		m.remove(m.lru.Back())
+	}
+	item := &entry{key: key, value: append([]byte(nil), value...)}
+	if ttl > 0 {
+		item.expires = m.now().Add(ttl)
+	}
+	m.items[key] = m.lru.PushFront(item)
+	m.bytes += len(key) + len(value)
+	return nil
+}
+
+func (m *Memory) Delete(ctx context.Context, keys ...string) error {
+	if ctx == nil {
+		return errors.New("cache: nil context")
+	}
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	for _, key := range keys {
+		if err := Check(ctx, key, 0); err != nil {
+			return err
+		}
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.closed {
+		return ErrClosed
+	}
+	for _, key := range keys {
+		if e := m.items[key]; e != nil {
+			m.remove(e)
+		}
+	}
+	return nil
+}
+
+func (m *Memory) remove(e *list.Element) {
+	item := e.Value.(*entry)
+	m.bytes -= len(item.key) + len(item.value)
+	delete(m.items, item.key)
+	m.lru.Remove(e)
+}
+
+func (m *Memory) Close() error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.closed = true
+	clear(m.items)
+	m.lru.Init()
+	m.bytes = 0
+	return nil
+}