Files
marqdo/plugins/web/internal/cache/cache.go
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- CHANGELOG.md:v2.8.0 条目(中英双语);
- README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明);
- doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制);
- skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/
  require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过);
- 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
2026-11-18 10:29:26 +08:00

261 lines
6.1 KiB
Go
Executable File

// Package cache ports memory and Redis cache backends from the Rust web plugin (W-G9).
package cache
import (
"context"
"fmt"
"strings"
"sync"
"time"
"github.com/redis/go-redis/v9"
)
type entry struct {
value string
exp *uint64 // absolute expiry unix secs; nil = no TTL
}
type memStore struct {
data map[string]entry
}
type backend struct {
mem *memStore
redisURL string
}
var (
handlesMu sync.Mutex
handles = map[string]*backend{}
)
func now() uint64 {
return uint64(time.Now().Unix())
}
func isMemory(url string) bool {
u := strings.ToLower(strings.TrimSpace(url))
return u == "" || u == "memory:" || u == "memory://" || strings.HasPrefix(u, "memory:")
}
func isRedis(url string) bool {
u := strings.ToLower(strings.TrimSpace(url))
return strings.HasPrefix(u, "redis://") || strings.HasPrefix(u, "rediss://")
}
// Open creates or reuses a cache handle. Returns {_type, url}.
func Open(url string) (map[string]any, error) {
url = strings.TrimSpace(url)
if url == "" {
url = "memory:"
}
if !isMemory(url) && !isRedis(url) {
return nil, fmt.Errorf("cache url must be `memory:` or `redis://…`, got `%s`", url)
}
handlesMu.Lock()
defer handlesMu.Unlock()
if _, ok := handles[url]; !ok {
var b backend
if isMemory(url) {
b.mem = &memStore{data: map[string]entry{}}
} else {
b.redisURL = url
}
handles[url] = &b
}
return map[string]any{"_type": "cache", "url": url}, nil
}
func pruneMem(store *memStore) {
t := now()
for k, e := range store.data {
if e.exp != nil && *e.exp <= t {
delete(store.data, k)
}
}
}
func withBackend(url string, f func(*backend) (map[string]any, error)) (map[string]any, error) {
handlesMu.Lock()
defer handlesMu.Unlock()
b, ok := handles[url]
if !ok {
return nil, fmt.Errorf("cache `%s` not opened — call cache.new first", url)
}
return f(b)
}
// Get returns {ok:true,value} on hit or {ok:false} on miss.
func Get(url, key string) (map[string]any, error) {
return withBackend(url, func(b *backend) (map[string]any, error) {
if b.mem != nil {
pruneMem(b.mem)
if e, ok := b.mem.data[key]; ok {
return map[string]any{"ok": true, "value": e.value}, nil
}
return map[string]any{"ok": false}, nil
}
return redisGet(b.redisURL, key)
})
}
// Set stores a value with optional TTL seconds (0/nil = no expiry).
func Set(url, key, value string, ttlSec *uint64) (map[string]any, error) {
return withBackend(url, func(b *backend) (map[string]any, error) {
if b.mem != nil {
pruneMem(b.mem)
var exp *uint64
if ttlSec != nil && *ttlSec > 0 {
t := now() + *ttlSec
exp = &t
}
b.mem.data[key] = entry{value: value, exp: exp}
return map[string]any{"ok": true}, nil
}
return redisSet(b.redisURL, key, value, ttlSec)
})
}
// Del removes a key. Returns {ok:bool} (true if key existed).
func Del(url, key string) (map[string]any, error) {
return withBackend(url, func(b *backend) (map[string]any, error) {
if b.mem != nil {
ok := false
if _, exists := b.mem.data[key]; exists {
delete(b.mem.data, key)
ok = true
}
return map[string]any{"ok": ok}, nil
}
return redisDel(b.redisURL, key)
})
}
// Exists returns {ok:bool} — ok is true when the key is present.
func Exists(url, key string) (map[string]any, error) {
return withBackend(url, func(b *backend) (map[string]any, error) {
if b.mem != nil {
pruneMem(b.mem)
_, ok := b.mem.data[key]
return map[string]any{"ok": ok}, nil
}
return redisExists(b.redisURL, key)
})
}
// TTL returns remaining seconds: -1 no expiry, -2 missing key.
func TTL(url, key string) (map[string]any, error) {
return withBackend(url, func(b *backend) (map[string]any, error) {
if b.mem != nil {
pruneMem(b.mem)
if e, ok := b.mem.data[key]; ok {
var left int64 = -1
if e.exp != nil {
left = int64(*e.exp - now())
if left < 0 {
left = 0
}
}
return map[string]any{"ok": true, "ttl": left}, nil
}
return map[string]any{"ok": false, "ttl": -2}, nil
}
return redisTTL(b.redisURL, key)
})
}
// Reset clears all handles (tests).
func Reset() {
handlesMu.Lock()
defer handlesMu.Unlock()
handles = map[string]*backend{}
}
func redisClient(url string) (*redis.Client, error) {
opts, err := redis.ParseURL(url)
if err != nil {
return nil, err
}
return redis.NewClient(opts), nil
}
func redisGet(url, key string) (map[string]any, error) {
client, err := redisClient(url)
if err != nil {
return nil, err
}
defer client.Close()
ctx := context.Background()
v, err := client.Get(ctx, key).Result()
if err == redis.Nil {
return map[string]any{"ok": false}, nil
}
if err != nil {
return nil, err
}
return map[string]any{"ok": true, "value": v}, nil
}
func redisSet(url, key, value string, ttlSec *uint64) (map[string]any, error) {
client, err := redisClient(url)
if err != nil {
return nil, err
}
defer client.Close()
ctx := context.Background()
if ttlSec != nil && *ttlSec > 0 {
if err := client.SetEx(ctx, key, value, time.Duration(*ttlSec)*time.Second).Err(); err != nil {
return nil, err
}
} else {
if err := client.Set(ctx, key, value, 0).Err(); err != nil {
return nil, err
}
}
return map[string]any{"ok": true}, nil
}
func redisDel(url, key string) (map[string]any, error) {
client, err := redisClient(url)
if err != nil {
return nil, err
}
defer client.Close()
ctx := context.Background()
n, err := client.Del(ctx, key).Result()
if err != nil {
return nil, err
}
return map[string]any{"ok": n > 0}, nil
}
func redisExists(url, key string) (map[string]any, error) {
client, err := redisClient(url)
if err != nil {
return nil, err
}
defer client.Close()
ctx := context.Background()
n, err := client.Exists(ctx, key).Result()
if err != nil {
return nil, err
}
return map[string]any{"ok": n > 0}, nil
}
func redisTTL(url, key string) (map[string]any, error) {
client, err := redisClient(url)
if err != nil {
return nil, err
}
defer client.Close()
ctx := context.Background()
t, err := client.TTL(ctx, key).Result()
if err != nil {
return nil, err
}
secs := int64(t.Seconds())
return map[string]any{"ok": secs >= -1, "ttl": secs}, nil
}