errors.go

package wal

import "errors"

var (
	// ErrClosed reports use after a terminal storage state.
	ErrClosed = errors.New(
		"wal: closed; open or create another WAL instance before continuing",
	)
	// ErrCapacity reports a configured byte or item limit.
	ErrCapacity = errors.New(
		"wal: capacity exceeded; truncate, compact, or provision more configured capacity",
	)
	// ErrTooLarge reports one value larger than its configured maximum.
	ErrTooLarge = errors.New(
		"wal: item too large; reduce it or raise the relevant configured limit",
	)
	// ErrCorrupt reports invalid durable storage content.
	ErrCorrupt = errors.New(
		"wal: corrupt; preserve the WAL and inspect it offline before reopening",
	)
	// ErrUnsupportedDurability reports a persistence level an implementation
	// cannot provide. Implementations must never silently downgrade.
	ErrUnsupportedDurability = errors.New(
		"wal: unsupported durability; choose a supported level or implementation",
	)
	// ErrUnsupportedFormat reports a durable format version this build cannot
	// interpret without guessing or mutation.
	ErrUnsupportedFormat = errors.New(
		"wal: unsupported format; use a compatible build or migrate the WAL offline",
	)
	// ErrBusy reports an exclusively owned filesystem directory.
	ErrBusy = errors.New(
		"wal: busy; retry after the current directory owner closes the WAL",
	)
	// ErrCapability reports a required filesystem primitive that is unavailable
	// or cannot satisfy its documented contract.
	ErrCapability = errors.New(
		"wal: filesystem capability unavailable; use a supported filesystem or relax only the explicit policy",
	)
	// ErrBackpressure reports a bounded queue or concurrent-operation limit.
	// The operation was not admitted and may be retried with bounded backoff.
	ErrBackpressure = errors.New(
		"wal: backpressure; retry the unadmitted operation with bounded backoff",
	)
	// ErrUncertain reports an earlier unresolved mutation. Only its
	// documented operation-specific exact retry may be admitted.
	ErrUncertain = errors.New(
		"wal: WAL mutation unresolved; perform its documented exact resolution or reopen",
	)
	// ErrSyncFailed reports a failed durability barrier. The filesystem WAL
	// instance becomes terminal for mutation.
	ErrSyncFailed = errors.New(
		"wal: WAL synchronization failed; preserve or quarantine this WAL epoch and reopen healthy storage",
	)
	// ErrCompactionUnknown reports that a replacement state may be
	// authoritative. Reopen before another mutation.
	ErrCompactionUnknown = errors.New(
		"wal: WAL compaction outcome unknown; reopen before further maintenance",
	)
	// ErrCompactionCleanup reports incomplete cleanup of an unselected
	// replacement or of obsolete files after a committed compaction. Inspect
	// CompactionReport.Committed to determine which side is authoritative,
	// then reopen to finish cleanup or safely reuse an empty candidate.
	ErrCompactionCleanup = errors.New(
		"wal: WAL compaction cleanup incomplete; inspect the report and reopen to finish cleanup",
	)
)

func internalError(reason string) error {
	return errors.New(
		"wal: internal invariant failed (" + reason +
			"); stop using the instance and report the failure",
	)
}