Files

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)
}