quasar

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

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

type CleanerConfig struct {
	// The amount of entries to keep available in the ledger.
	Retention int

	// The maximum amount of entries to keep in the ledger.
	Threshold int

	// The interval of cleanings.
	Interval time.Duration

	// The tables to check for positions.
	Tables []*Table

	// The callback used to yield errors.
	Errors func(error)
}

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

type ConsumerConfig struct {
	// The name of the persistent consumer. If empty, the consumer will not
	// persist its positions.
	Name string

	// The start position of the consumer if not recovered from the table.
	Start uint64

	// The channel on which available entries are sent.
	Entries chan<- Entry

	// The callback that is called with errors before the consumer dies.
	Errors func(error)

	// The amount of entries to fetch from the ledger at once.
	Batch int

	// The maximal size of the unmarked sequence range.
	Window int

	// The number of acks to skip before sequences are written to the table.
	Skip int

	// The time after skipped marks are persisted to the table.
	Timeout time.Duration

	// The time after which the consumer crashes if it cannot make progress.
	Deadline time.Duration
}

type DB struct {
	*pebble.DB
	// contains filtered or unexported fields
}

type DBConfig struct {
	// Whether all writes should be synced.
	SyncWrites bool

	// The sink used for logging.
	Logger func(format string, args ...interface{})
}

type Entry struct {
	// The entries sequence (must be greater than zero).
	Sequence uint64

	// The entries payload that is written to disk.
	Payload []byte

	// The reference to a shared object. This can be used with cached ledgers
	// to retain a reference to a decoded object of the entry.
	Object interface{}
}

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

type LedgerConfig struct {
	// The prefix for all ledger keys.
	Prefix string

	// The amount of entries to cache in memory.
	Cache int

	// The maximum length of the ledger. Write() will return ErrLimitReached if
	// the ledger is longer than this value.
	Limit int
}

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

type ProducerConfig struct {
	// The maximum size of the written entry batches.
	Batch int

	// The timeout after an unfinished batch is written in any case.
	Timeout time.Duration

	// The number of times a failed write due to ErrLimitReached is retried.
	Retry int

	// The time after which a failed write due to ErrLimitReached is retried.
	Delay time.Duration

	// If enabled, the producer will filter out entries that have a lower
	// sequence than the current ledger head.
	Filter bool
}

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

type QueueConfig struct {
	// The prefix for all keys.
	Prefix string

	// The amount of ledger entries to cache in memory.
	LedgerCache int

	// The maximum length of the ledger.
	LedgerLimit int

	// Whether the table should be fully cached in memory.
	TableCache bool

	// The amount of entries to keep around.
	CleanRetention int

	// The point after which entries are dropped no matter what.
	CleanThreshold int

	// The interval of periodic cleanings.
	CleanInterval time.Duration

	// The callback used to yield cleaner errors.
	CleanErrors func(error)
}

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

type TableConfig struct {
	// The prefix for all table keys.
	Prefix string

	// Enable to keep all positions in memory.
	Cache bool
}