caching

type BlobCache ¶

type BlobCache interface {
	// Get returns a cached item or ErrCacheMiss if it's not in the cache.
	Get(c context.Context, key string) ([]byte, error)

	// Set unconditionally overwrites an item in the cache.
	//
	// If 'exp' is zero, the item will have no expiration time.
	Set(c context.Context, key string, value []byte, exp time.Duration) error
}

BlobCache is a minimal interface for a cross-process memcache-like cache.

It exists to support low-level server libraries that target all sorts of environments that may have different memcache implementations (or none at all).

This interface provides the smallest sufficient API to support needs of low-level libraries. If you need anything fancier, consider using the concrete memcache implementation directly (e.g. use luci/gae's memcache library when running on GAE Standard).

BlobCache has the following properties:

• All service processes share this cache (thus 'global').
• The global cache is namespaced (see GlobalCache function below).
• It is strongly consistent.
• Items can be evicted at random times.
• Key size is <250 bytes.
• Item size is <1 Mb.

func GlobalCache(c context.Context, namespace string) BlobCache

type BlobCacheProvider ¶

type BlobCacheProvider func(namespace string) BlobCache

BlobCacheProvider returns a BlobCache instance targeting a namespace.

type FetchCallback ¶

type FetchCallback func(prev any) (updated any, exp time.Duration, err error)

FetchCallback knows how to grab a new value for the cache slot (if prev is nil) or refresh the known one (if prev is not nil).

If the returned expiration time is 0, the value is considered non-expirable. If the returned expiration time is <0, the value will be refetched on the next access. This is sometimes useful in tests that "freeze" time.

type LRUHandle ¶

type LRUHandle[K comparable, V any] struct {
	// contains filtered or unexported fields
}

LRUHandle is indirect pointer to a registered LRU process cache.

Grab it via RegisterLRUCache during module init time, and use its LRU() method to access an actual LRU cache associated with this handle.

The cache itself lives inside a context. See WithProcessCacheData.

func RegisterLRUCache[K comparable, V any](capacity int) LRUHandle[K, V]

func (h LRUHandle[K, V]) LRU(ctx context.Context) *lru.Cache[K, V]

func (h LRUHandle[K, V]) Valid() bool

type ProcessCacheData ¶

type ProcessCacheData struct {
	// contains filtered or unexported fields
}

ProcessCacheData holds all process-cached data (internally).

It is opaque to the API users. Use NewProcessCacheData in your main() or below (i.e. any other place _other_ than init()) to allocate it, then inject it into the context via WithProcessCacheData, and finally access it through handles registered during init() time via RegisterLRUCache to get a reference to an actual lru.Cache.

Each instance of ProcessCacheData is its own universe of global data. This is useful in unit tests as replacement for global variables.

func NewProcessCacheData() *ProcessCacheData

type SlotHandle ¶

type SlotHandle struct {
	// contains filtered or unexported fields
}

SlotHandle is indirect pointer to a registered process cache slot.

Such slot holds one arbitrary value, alongside its expiration time. Useful for representing global singletons that occasionally need to be refreshed.

Grab it via RegisterCacheSlot during module init time, and use its Fetch() method to access the value, potentially refreshing it, if necessary.

The value itself lives inside a context. See WithProcessCacheData.

func RegisterCacheSlot() SlotHandle

func (h SlotHandle) Fetch(ctx context.Context, cb FetchCallback) (any, error)

func (h SlotHandle) Valid() bool