cacheatomic

type Backend ¶

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

func New(driver Driver, maxValue int) (*Backend, error)

func (b *Backend) Add(ctx context.Context, key cache.EntryKey, data []byte, ttl cache.TTL) (bool, error)

func (b *Backend) Exists(ctx context.Context, key cache.EntryKey) (bool, error)

func (b *Backend) Expire(ctx context.Context, key cache.EntryKey, ttl cache.TTL) (bool, error)

func (b *Backend) Forget(ctx context.Context, key cache.EntryKey) (bool, error)

func (b *Backend) Get(ctx context.Context, key cache.EntryKey) ([]byte, bool, error)

func (b *Backend) Increment(ctx context.Context, key cache.EntryKey, delta int64, ttl cache.TTL) (int64, error)

func (b *Backend) Put(ctx context.Context, key cache.EntryKey, data []byte, ttl cache.TTL) error

type Change ¶

type Change func(now time.Time, previous *Record) (next *Record, update bool, err error)

Change runs while the driver owns the key's atomic lock. now is the storage authority's time, read after the lock was acquired. previous is nil when the entry is absent or unusable (corrupt, or larger than the current bound); such an entry is still replaced or removed by a write. update=false retains bytes; update=true with nil next deletes. Errors preserve the previous entry. Drivers may run a Change more than once before one attempt succeeds.

type Driver ¶

type Driver interface {
	Read(ctx context.Context, key cache.EntryKey, data bool) (*Record, time.Time, error)
	Access(ctx context.Context, key cache.EntryKey, mode Mode, change Change) error
	Inspect(ctx context.Context, key cache.EntryKey, inspection Inspection) (bool, error)
}

Driver owns storage, locking and the authority clock. Read observes one record without the mutation lock and returns the authority time of that observation; unusable records read as nil. data=false validates the stored record without returning its bytes.

type Inspection ¶

type Inspection func(now, expires time.Time) (replacement *time.Time, live bool, err error)

Inspection runs after the driver acquires its lock and reads the record. It checks current liveness at now and optionally returns a replacement expiry. A nil replacement preserves metadata; false never revives an expired entry.

type Limits ¶

type Limits struct {
	MaxEntries    int
	MaxBytes      int64
	MaxValueBytes int
}

Limits shares the persistent adapter ceilings and defaults. Byte accounting follows each storage representation; both reject before replacing live data.

func DefaultLimits() Limits

func (l Limits) Validate() error

type Mode ¶

type Mode uint8

Mode selects how much of an existing record a mutation needs.

const (
	// Metadata supplies only the previous record's expiry. Replacement needs
	// nothing else, so drivers skip reading and verifying the old payload.
	Metadata Mode = iota
	// Payload supplies the previous record's verified bytes.
	Payload
)

type PruneResult ¶

type PruneResult struct {
	// Removed counts expired records (and file orphans) deleted by this pass.
	Removed int
	// Corrupt counts unreadable records that were skipped. Reads treat them as
	// misses and writes replace them; they still occupy capacity until then.
	Corrupt int
	// Unrecognized counts foreign files skipped in an owned file-cache root.
	Unrecognized int
	// Entries and Bytes are the stored records counted after removal.
	Entries int64
	Bytes   int64
	// Complete reports that the pass counted all storage. Every pass replaces
	// the adapter's usage estimate; an incomplete one with a lower bound.
	Complete bool
}

PruneResult reports one bounded prune pass.

type Record ¶

type Record struct {
	Data    []byte
	Expires time.Time
}

func (r *Record) Live(now time.Time) bool

type Usage ¶

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

Usage is a backend-owned estimate of stored records and bytes. Writers apply their own deltas without scanning storage; Reconcile replaces the estimate with a counted snapshot. Other processes' writes become visible only at the next reconciliation, so capacity is approximate between prune passes.

func (u *Usage) Add(entries, bytes int64)

func (u *Usage) Counted() bool

func (u *Usage) Fits(limits Limits, replaced, size int64) bool

func (u *Usage) Reclaimed(result PruneResult)

func (u *Usage) Reconcile(entries, bytes int64)

func (u *Usage) ReconcileDue() bool

func (u *Usage) Snapshot() (entries, bytes int64)