durable

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

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

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

type JournalOptions struct {
	// Magic is the journal file's magic number, and is written at the start of
	// each sector to detect partial writes. NewJournal panics if Magic is zero.
	Magic MagicNumber

	// Size is the size of volume files in bytes. NewJournal panics if
	// Size > 2^32.
	Size int64

	// Blanks is the number of blank volume files.
	Blanks uint8

	// Alloc specifies the behavior of the maker of blank volume files.
	//   * WriteBlanks means to allocate such files by sequentially writing zeros
	//     until Size bytes are written.
	//   * FallocateBlanks means to use syscall.Fallocate to allocate blank
	//     volumes, but not to overwrite with zeros.
	//   * FallocateAndWriteBlanks means to use syscall.Fallocate, and then to
	//     overwrite with zeros.
	// Recommendations about which strategy to use are as follows:
	//   * If the fallocate system call is not available on your system/s, use
	//     WriteBlanks.
	//   * Otherwise, if using flash storage, use FallocateBlanks, because of
	//     endurance concerns.
	//   * Otherwise, use FallocateAndWriteBlanks.
	Alloc VolumeAllocOption

	// TOCLength is the maximum length of table of contents (TOC) data.
	// If TOCLength is smaller than 1, then TOC data will not be written.
	// NewJournal panics if TOCLength > 0 and TOCCallbacks == nil.
	TOCLength int

	// NextVolume is called when a volume is closed, if non-nil and TOCLength is
	// greater than 0. It provides the content of tables of content (TOCs);
	// the returned slice is the table of contents of the volume being closed.
	//
	// Journal.Append will return an error if the returned slice has length
	// greater than the table of contents length. volumeN is the number of the
	// volume being closed. The spill parameter indicates whether the most recent
	// journal entry will also be written to the next volume.
	//
	// Given the sequence of calls:
	//   callbacks.Next(volumeN, spill)
	//   journal.Append(entry0, _)
	// where Append(entry0, _) is the first Append call after the Next call,
	// the following conditions hold:
	//   * volumeN+1 is guaranteed to contain all or part of entry0.
	//   * volumeN is guaranteed not to contain any of entry0.
	//
	// Also, given the sequence of calls:
	//   journal.Append(entry1, _)
	//   journal.Append(entry2, _)
	//   callbacks.Next(volumeM, spill)
	// where Append(entry1, _) and Append(entry2, _) are the Append calls
	// preceding the Next call, the following conditions hold:
	//   * volumeM will contain all or part of entry2.
	//   * volumeM+1 will not contain entry1.
	//   * volumeM+1 will contain part of entry2 if and only if spill is true.
	NextVolume func(volumeN int, spill bool) (tableOfContents []byte)

	// SectorSize should be the length L of the storage device's unit of atomic
	// writes. Smaller values than L are acceptable (e.g., if a disk's sector
	// size is 4096, then SectorSize==512 is acceptable). SectorSize must be less
	// than or equal to 2^16. For proper partial write detection, SectorSize must
	// be less than or equal to L.
	SectorSize int

	// Logger is a logger for use by the journal. The durable package's log levels
	// are Error, Warning, Info, and Debug. See those constants or the function
	// StandardJournalOptions for an example of how to configure Logger.
	// NewJournal panics if Logger.Logger is nil.
	Logger loglvl.Logger
}

type JournalScannerCallbacks interface {
	// Meta is invoked when metadata is read. A return value of true indicates
	// that the data portion should also be read, and false indicates the data
	// portion should be skipped. This allows application code to skip irrelevant
	// journal entries (e.g., if a sequence number contained in the metadata is
	// no greater than the sequence number of a snapshot).
	Meta(meta []byte) (readData bool)

	// Data is invoked when metadata and data have been read.
	Data(meta, data []byte)

	// NextVolume is invoked when a volume is opened.
	// The volume parameter is the volume number.
	NextVolume(volume int)

	// If Stop returns true, then the journal scanner stops scanning; no further
	// metadata or data will be read. If it returns false, then the journal
	// continues scanning as long as there are more journal entries.
	Stop() bool
}

type MagicNumber [magicNumberLen]byte

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

type VolumeAllocOption int

type VolumeScanner struct {
	Dir       string
	Volume    int
	DataSize  int
	Callbacks VolumeScannerCallbacks
	Log       loglvl.Logger
	// contains filtered or unexported fields
}

type VolumeScannerCallbacks interface {
	// Entry is invoked when an entry header is read.
	// metaLen is the length of the entry's metadata,
	// and dataLen is the length of the entry's data.
	Entry(metaLen, dataLen uint32, offset int64)

	// Segment is invoked when a segment is read.
	// kind is the type of segment, either "meta" or "data".
	// contents is the contents of the segment.
	Segment(kind string, contents []byte, offset int64)

	// NextVolume is invoked when a next volume record is read.
	NextVolume(offset int64)

	// TOC is invoked when the table of contents is read.
	// data is the contents of the table of contents.
	TOC(data []byte, offset int64)
}