mirror of
https://github.com/hanzoai/porto.git
synced 2026-11-03 18:08:27 +00:00
110 lines
3.0 KiB
Go
110 lines
3.0 KiB
Go
package cache
|
|
|
|
import (
|
|
"context"
|
|
"path"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type proxyProv struct {
|
|
ns namespace
|
|
prov Provider
|
|
}
|
|
|
|
// NewProxyProvider returns a Provider that stores every key under prefix in
|
|
// prov, which cleans the combined key again; like a key, prefix cannot
|
|
// leave prov's namespace. ListKeys and Keys strip prefix again. Its Close
|
|
// is a no-op (the parent owns the connection) and Publish/Subscribe pass
|
|
// channels through unprefixed.
|
|
func NewProxyProvider(prefix string, prov Provider) Provider {
|
|
p := &proxyProv{
|
|
// prov lists its keys without a leading slash, so the proxy
|
|
// prefix is kept in that form: "/a/" and "../a" become "a"
|
|
ns: newNamespace(strings.TrimPrefix(path.Clean("/"+prefix), "/")),
|
|
prov: prov,
|
|
}
|
|
|
|
return p
|
|
}
|
|
|
|
func (p *proxyProv) keyName(key string) string {
|
|
return p.ns.key(key)
|
|
}
|
|
|
|
// Close closes the client, releasing any open resources.
|
|
// It is rare to Close a Client, as the Client is meant to be long-lived and shared between many goroutines.
|
|
func (p *proxyProv) Close() error {
|
|
// this method does nothing as the parent must be closed safely
|
|
return nil
|
|
}
|
|
|
|
// IsLocal returns true, if cache is local
|
|
func (p *proxyProv) IsLocal() bool {
|
|
return p.prov.IsLocal()
|
|
}
|
|
|
|
// Set data
|
|
func (p *proxyProv) Set(ctx context.Context, key string, v any, ttl time.Duration) error {
|
|
return p.prov.Set(ctx, p.keyName(key), v, ttl)
|
|
}
|
|
|
|
// Get data
|
|
func (p *proxyProv) Get(ctx context.Context, key string, v any) error {
|
|
return p.prov.Get(ctx, p.keyName(key), v)
|
|
}
|
|
|
|
// Delete data
|
|
func (p *proxyProv) Delete(ctx context.Context, keys ...string) error {
|
|
if len(keys) == 0 {
|
|
return nil
|
|
}
|
|
pkeys := make([]string, 0, len(keys))
|
|
for _, key := range keys {
|
|
pkeys = append(pkeys, p.keyName(key))
|
|
}
|
|
return p.prov.Delete(ctx, pkeys...)
|
|
}
|
|
|
|
// CleanExpired data
|
|
func (p *proxyProv) CleanExpired(ctx context.Context) {
|
|
p.prov.CleanExpired(ctx)
|
|
}
|
|
|
|
// Keys returns the keys, relative to the proxy, that match the Redis glob
|
|
// pattern in prov.
|
|
// This method should be used mostly for testing, as in prod many keys maybe returned
|
|
func (p *proxyProv) Keys(ctx context.Context, pattern string) ([]string, error) {
|
|
list, err := p.prov.Keys(ctx, p.ns.pattern(pattern))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for i, key := range list {
|
|
list[i] = p.ns.rel(key)
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
// ListKeys returns one page of the keys, relative to the proxy, that match
|
|
// the Redis glob pattern in prov; the cursor is prov's.
|
|
func (p *proxyProv) ListKeys(ctx context.Context, pattern, cursor string, count int) ([]string, string, error) {
|
|
list, next, err := p.prov.ListKeys(ctx, p.ns.pattern(pattern), cursor, count)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
for i, key := range list {
|
|
list[i] = p.ns.rel(key)
|
|
}
|
|
return list, next, nil
|
|
}
|
|
|
|
// Subscribe subscribes to channel
|
|
func (p *proxyProv) Subscribe(ctx context.Context, channel string) Subscription {
|
|
return p.prov.Subscribe(ctx, channel)
|
|
}
|
|
|
|
// Publish publishes message to channel
|
|
func (p *proxyProv) Publish(ctx context.Context, channel, message string) error {
|
|
return p.prov.Publish(ctx, channel, message)
|
|
}
|