kubernetes/vendor/go.etcd.io/bbolt/db.go

const maxMmapStep

const version

const magic

const pgidNoFreelist

const IgnoreNoSync

const DefaultMaxBatchSize

const DefaultMaxBatchDelay

const DefaultAllocSize

var defaultPageSize

const flockRetryTimeout

type FreelistType

const FreelistArrayType

const FreelistMapType

type DB

// Path returns the path to currently open database file.
func (db *DB) Path() string {}

// GoString returns the Go string representation of the database.
func (db *DB) GoString() string {}

// String returns the string representation of the database.
func (db *DB) String() string {}

// Open creates and opens a database at the given path.
// If the file does not exist then it will be created automatically.
// Passing in nil options will cause Bolt to open the database with the default options.
func Open(path string, mode os.FileMode, options *Options) (*DB, error) {}

// getPageSize reads the pageSize from the meta pages. It tries
// to read the first meta page firstly. If the first page is invalid,
// then it tries to read the second page using the default page size.
func (db *DB) getPageSize() (int, error) {}

// getPageSizeFromFirstMeta reads the pageSize from the first meta page
func (db *DB) getPageSizeFromFirstMeta() (int, bool, error) {}

// getPageSizeFromSecondMeta reads the pageSize from the second meta page
func (db *DB) getPageSizeFromSecondMeta() (int, bool, error) {}

// loadFreelist reads the freelist if it is synced, or reconstructs it
// by scanning the DB if it is not synced. It assumes there are no
// concurrent accesses being made to the freelist.
func (db *DB) loadFreelist() {}

func (db *DB) hasSyncedFreelist() bool {}

// mmap opens the underlying memory-mapped file and initializes the meta references.
// minsz is the minimum size that the new mmap can be.
func (db *DB) mmap(minsz int) (err error) {}

func (db *DB) invalidate() {}

// munmap unmaps the data file from memory.
func (db *DB) munmap() error {}

// mmapSize determines the appropriate size for the mmap given the current size
// of the database. The minimum size is 32KB and doubles until it reaches 1GB.
// Returns an error if the new mmap size is greater than the max allowed.
func (db *DB) mmapSize(size int) (int, error) {}

func (db *DB) munlock(fileSize int) error {}

func (db *DB) mlock(fileSize int) error {}

func (db *DB) mrelock(fileSizeFrom, fileSizeTo int) error {}

// init creates a new database file and initializes its meta pages.
func (db *DB) init() error {}

// Close releases all database resources.
// It will block waiting for any open transactions to finish
// before closing the database and returning.
func (db *DB) Close() error {}

func (db *DB) close() error {}

// Begin starts a new transaction.
// Multiple read-only transactions can be used concurrently but only one
// write transaction can be used at a time. Starting multiple write transactions
// will cause the calls to block and be serialized until the current write
// transaction finishes.
//
// Transactions should not be dependent on one another. Opening a read
// transaction and a write transaction in the same goroutine can cause the
// writer to deadlock because the database periodically needs to re-mmap itself
// as it grows and it cannot do that while a read transaction is open.
//
// If a long running read transaction (for example, a snapshot transaction) is
// needed, you might want to set DB.InitialMmapSize to a large enough value
// to avoid potential blocking of write transaction.
//
// IMPORTANT: You must close read-only transactions after you are finished or
// else the database will not reclaim old pages.
func (db *DB) Begin(writable bool) (*Tx, error) {}

func (db *DB) beginTx() (*Tx, error) {}

func (db *DB) beginRWTx() (*Tx, error) {}

// freePages releases any pages associated with closed read-only transactions.
func (db *DB) freePages() {}

type txsById

func (t txsById) Len() int           {}

func (t txsById) Swap(i, j int)      {}

func (t txsById) Less(i, j int) bool {}

// removeTx removes a transaction from the database.
func (db *DB) removeTx(tx *Tx) {}

// Update executes a function within the context of a read-write managed transaction.
// If no error is returned from the function then the transaction is committed.
// If an error is returned then the entire transaction is rolled back.
// Any error that is returned from the function or returned from the commit is
// returned from the Update() method.
//
// Attempting to manually commit or rollback within the function will cause a panic.
func (db *DB) Update(fn func(*Tx) error) error {}

// View executes a function within the context of a managed read-only transaction.
// Any error that is returned from the function is returned from the View() method.
//
// Attempting to manually rollback within the function will cause a panic.
func (db *DB) View(fn func(*Tx) error) error {}

// Batch calls fn as part of a batch. It behaves similar to Update,
// except:
//
// 1. concurrent Batch calls can be combined into a single Bolt
// transaction.
//
// 2. the function passed to Batch may be called multiple times,
// regardless of whether it returns error or not.
//
// This means that Batch function side effects must be idempotent and
// take permanent effect only after a successful return is seen in
// caller.
//
// The maximum batch size and delay can be adjusted with DB.MaxBatchSize
// and DB.MaxBatchDelay, respectively.
//
// Batch is only useful when there are multiple goroutines calling it.
func (db *DB) Batch(fn func(*Tx) error) error {}

type call

type batch

// trigger runs the batch if it hasn't already been run.
func (b *batch) trigger() {}

// run performs the transactions in the batch and communicates results
// back to DB.Batch.
func (b *batch) run() {}

var trySolo

type panicked

func (p panicked) Error() string {}

func safelyCall(fn func(*Tx) error, tx *Tx) (err error) {}

// Sync executes fdatasync() against the database file handle.
//
// This is not necessary under normal operation, however, if you use NoSync
// then it allows you to force the database file to sync against the disk.
func (db *DB) Sync() error {}

// Stats retrieves ongoing performance stats for the database.
// This is only updated when a transaction closes.
func (db *DB) Stats() Stats {}

// This is for internal access to the raw data bytes from the C cursor, use
// carefully, or not at all.
func (db *DB) Info() *Info {}

// page retrieves a page reference from the mmap based on the current page size.
func (db *DB) page(id pgid) *page {}

// pageInBuffer retrieves a page reference from a given byte array based on the current page size.
func (db *DB) pageInBuffer(b []byte, id pgid) *page {}

// meta retrieves the current meta page reference.
func (db *DB) meta() *meta {}

// allocate returns a contiguous block of memory starting at a given page.
func (db *DB) allocate(txid txid, count int) (*page, error) {}

// grow grows the size of the database to the given sz.
func (db *DB) grow(sz int) error {}

func (db *DB) IsReadOnly() bool {}

func (db *DB) freepages() []pgid {}

type Options

var DefaultOptions

type Stats

// Sub calculates and returns the difference between two sets of database stats.
// This is useful when obtaining stats at two different points and time and
// you need the performance counters that occurred within that time span.
func (s *Stats) Sub(other *Stats) Stats {}

type Info

type meta

// validate checks the marker bytes and version of the meta page to ensure it matches this binary.
func (m *meta) validate() error {}

// copy copies one meta object to another.
func (m *meta) copy(dest *meta) {}

// write writes the meta onto a page.
func (m *meta) write(p *page) {}

// generates the checksum for the meta.
func (m *meta) sum64() uint64 {}

// _assert will panic with a given formatted message if the given condition is false.
func _assert(condition bool, msg string, v ...interface{}