bolt

README

encrypted-bolt

Wrapper around go.etcd.io/bbolt enabling encryption with 32-bytes long key.

Documentation

Index

• Constants
• Variables
• type Bucket
  • func (eb *Bucket) Bucket(name []byte) *Bucket
  • func (eb *Bucket) CreateBucket(name []byte) (*Bucket, error)
  • func (eb *Bucket) CreateBucketIfNotExists(name []byte) (*Bucket, error)
  • func (eb *Bucket) Cursor() *Cursor
  • func (eb *Bucket) ForEach(fn func(k, v []byte) error) error
  • func (eb *Bucket) Get(key []byte) []byte
  • func (eb *Bucket) Put(key, value []byte) error
• type Cursor
  • func (c *Cursor) Bucket() *Bucket
  • func (c *Cursor) First() (key, value []byte)
  • func (c *Cursor) Last() (key, value []byte)
  • func (c *Cursor) Next() (key, value []byte)
  • func (c *Cursor) Prev() (key, value []byte)
  • func (c *Cursor) Seek(seek []byte) (key, value []byte)
• type DB
  • func Open(key []byte, path string, mode os.FileMode, options *Options) (*DB, error)
  • func (db *DB) Batch(fn func(*Tx) error) error
  • func (db *DB) Begin(writable bool) (*Tx, error)
  • func (db *DB) Update(fn func(*Tx) error) error
  • func (db *DB) View(fn func(*Tx) error) error
• type Info
• type Options
• type PageInfo
• type Stats
• type Tx
  • func (tx *Tx) Bucket(name []byte) *Bucket
  • func (tx *Tx) CreateBucket(name []byte) (*Bucket, error)
  • func (tx *Tx) CreateBucketIfNotExists(name []byte) (*Bucket, error)
  • func (tx *Tx) Cursor() *Cursor
  • func (tx *Tx) DB() *DB
  • func (tx *Tx) ForEach(fn func(name []byte, b *Bucket) error) error

Examples

• Bucket.ForEach
• Bucket.Put
• Cursor
• Cursor (Reverse)
• DB.Update
• DB.View

Constants

const (
	MaxKeySize   = bolt.MaxKeySize
	MaxValueSize = bolt.MaxValueSize

	DefaultMaxBatchSize  = bolt.DefaultMaxBatchSize
	DefaultMaxBatchDelay = bolt.DefaultMaxBatchDelay
	DefaultAllocSize     = bolt.DefaultAllocSize

	DefaultFillPercent = bolt.DefaultFillPercent
	IgnoreNoSync       = bolt.IgnoreNoSync
)

Variables

var (
	ErrDatabaseNotOpen = bolt.ErrDatabaseNotOpen
	ErrDatabaseOpen    = bolt.ErrDatabaseOpen
	ErrInvalid         = bolt.ErrInvalid
	ErrVersionMismatch = bolt.ErrVersionMismatch
	ErrChecksum        = bolt.ErrChecksum
	ErrTimeout         = bolt.ErrTimeout

	ErrTxNotWritable    = bolt.ErrTxNotWritable
	ErrTxClosed         = bolt.ErrTxClosed
	ErrDatabaseReadOnly = bolt.ErrDatabaseReadOnly

	ErrBucketNotFound     = bolt.ErrBucketNotFound
	ErrBucketExists       = bolt.ErrBucketExists
	ErrBucketNameRequired = bolt.ErrBucketNameRequired
	ErrKeyRequired        = bolt.ErrKeyRequired
	ErrKeyTooLarge        = bolt.ErrKeyTooLarge
	ErrValueTooLarge      = bolt.ErrValueTooLarge
	ErrIncompatibleValue  = bolt.ErrIncompatibleValue

	ErrDecrypt = errors.New("could not decrypt data")
)

Types

type Bucket

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

func (*Bucket) Bucket

func (eb *Bucket) Bucket(name []byte) *Bucket

func (*Bucket) CreateBucket

func (eb *Bucket) CreateBucket(name []byte) (*Bucket, error)

func (*Bucket) CreateBucketIfNotExists

func (eb *Bucket) CreateBucketIfNotExists(name []byte) (*Bucket, error)

func (*Bucket) Cursor

func (eb *Bucket) Cursor() *Cursor

func (*Bucket) ForEach

func (eb *Bucket) ForEach(fn func(k, v []byte) error) error

Example

// Open the database.
db, err := bolt.Open(testKey, tempfile(), 0666, nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

// Insert data into a bucket.
if err := db.Update(func(tx *bolt.Tx) error {
	b, err := tx.CreateBucket([]byte("animals"))
	if err != nil {
		return err
	}

	if err := b.Put([]byte("dog"), []byte("fun")); err != nil {
		return err
	}
	if err := b.Put([]byte("cat"), []byte("lame")); err != nil {
		return err
	}
	if err := b.Put([]byte("liger"), []byte("awesome")); err != nil {
		return err
	}

	// Iterate over items in sorted key order.
	if err := b.ForEach(func(k, v []byte) error {
		fmt.Printf("A %s is %s.\n", k, v)
		return nil
	}); err != nil {
		return err
	}

	return nil
}); err != nil {
	log.Fatal(err)
}

// Close database to release file lock.
if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:

A cat is lame.
A dog is fun.
A liger is awesome.

func (*Bucket) Get

func (eb *Bucket) Get(key []byte) []byte

func (*Bucket) Put

func (eb *Bucket) Put(key, value []byte) error

Example

// Open the database.
db, err := bolt.Open(testKey, tempfile(), 0666, nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

// Start a write transaction.
if err := db.Update(func(tx *bolt.Tx) error {
	// Create a bucket.
	b, err := tx.CreateBucket([]byte("widgets"))
	if err != nil {
		return err
	}

	// Set the value "bar" for the key "foo".
	if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
		return err
	}
	return nil
}); err != nil {
	log.Fatal(err)
}

// Read value back in a different read-only transaction.
if err := db.View(func(tx *bolt.Tx) error {
	value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
	fmt.Printf("The value of 'foo' is: %s\n", value)
	return nil
}); err != nil {
	log.Fatal(err)
}

// Close database to release file lock.
if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:

The value of 'foo' is: bar

type Cursor

type Cursor struct {
	*bolt.Cursor
	// contains filtered or unexported fields
}

Example

// Open the database.
db, err := bolt.Open(testKey, tempfile(), 0666, nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

// Start a read-write transaction.
if err := db.Update(func(tx *bolt.Tx) error {
	// Create a new bucket.
	b, err := tx.CreateBucket([]byte("animals"))
	if err != nil {
		return err
	}

	// Insert data into a bucket.
	if err := b.Put([]byte("dog"), []byte("fun")); err != nil {
		log.Fatal(err)
	}
	if err := b.Put([]byte("cat"), []byte("lame")); err != nil {
		log.Fatal(err)
	}
	if err := b.Put([]byte("liger"), []byte("awesome")); err != nil {
		log.Fatal(err)
	}

	// Create a cursor for iteration.
	c := b.Cursor()

	// Iterate over items in sorted key order. This starts from the
	// first key/value pair and updates the k/v variables to the
	// next key/value on each iteration.
	//
	// The loop finishes at the end of the cursor when a nil key is returned.
	for k, v := c.First(); k != nil; k, v = c.Next() {
		fmt.Printf("A %s is %s.\n", k, v)
	}

	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:

A cat is lame.
A dog is fun.
A liger is awesome.

Example (Reverse)

// Open the database.
db, err := bolt.Open(testKey, tempfile(), 0666, nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

// Start a read-write transaction.
if err := db.Update(func(tx *bolt.Tx) error {
	// Create a new bucket.
	b, err := tx.CreateBucket([]byte("animals"))
	if err != nil {
		return err
	}

	// Insert data into a bucket.
	if err := b.Put([]byte("dog"), []byte("fun")); err != nil {
		log.Fatal(err)
	}
	if err := b.Put([]byte("cat"), []byte("lame")); err != nil {
		log.Fatal(err)
	}
	if err := b.Put([]byte("liger"), []byte("awesome")); err != nil {
		log.Fatal(err)
	}

	// Create a cursor for iteration.
	c := b.Cursor()

	// Iterate over items in reverse sorted key order. This starts
	// from the last key/value pair and updates the k/v variables to
	// the previous key/value on each iteration.
	//
	// The loop finishes at the beginning of the cursor when a nil key
	// is returned.
	for k, v := c.Last(); k != nil; k, v = c.Prev() {
		fmt.Printf("A %s is %s.\n", k, v)
	}

	return nil
}); err != nil {
	log.Fatal(err)
}

// Close the database to release the file lock.
if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:

A liger is awesome.
A dog is fun.
A cat is lame.

func (*Cursor) Bucket

func (c *Cursor) Bucket() *Bucket

func (*Cursor) First

func (c *Cursor) First() (key, value []byte)

func (*Cursor) Last

func (c *Cursor) Last() (key, value []byte)

func (*Cursor) Next

func (c *Cursor) Next() (key, value []byte)

func (*Cursor) Prev

func (c *Cursor) Prev() (key, value []byte)

func (*Cursor) Seek

func (c *Cursor) Seek(seek []byte) (key, value []byte)

type DB

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

func Open

func Open(key []byte, path string, mode os.FileMode, options *Options) (*DB, error)

func (*DB) Batch

func (db *DB) Batch(fn func(*Tx) error) error

func (*DB) Begin

func (db *DB) Begin(writable bool) (*Tx, error)

func (*DB) Update

func (db *DB) Update(fn func(*Tx) error) error

Example

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"

	bolt "github.com/iryonetwork/encrypted-bolt"
)

var testKey []byte = []byte{0x47, 0x41, 0xf2, 0xd6, 0xa5, 0xa0, 0x46, 0x33, 0x87, 0xa8, 0x2, 0xa2, 0x52, 0xd0, 0x20, 0xed, 0x8c, 0x65, 0x76, 0x50, 0x77, 0x79, 0x4c, 0x7c, 0x76, 0x49, 0xbf, 0x85, 0x18, 0x27, 0x4f, 0xa0}

func main() {
	// Open the database.
	db, err := bolt.Open(testKey, tempfile(), 0666, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer os.Remove(db.Path())

	// Execute several commands within a read-write transaction.
	if err := db.Update(func(tx *bolt.Tx) error {
		b, err := tx.CreateBucket([]byte("widgets"))
		if err != nil {
			return err
		}
		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
			return err
		}
		return nil
	}); err != nil {
		log.Fatal(err)
	}

	// Read the value back from a separate read-only transaction.
	if err := db.View(func(tx *bolt.Tx) error {
		value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
		fmt.Printf("The value of 'foo' is: %s\n", value)
		return nil
	}); err != nil {
		log.Fatal(err)
	}

	// Close database to release the file lock.
	if err := db.Close(); err != nil {
		log.Fatal(err)
	}

}

// tempfile returns a temporary file path.
func tempfile() string {
	f, err := ioutil.TempFile("", "bolt-")
	if err != nil {
		panic(err)
	}
	if err := f.Close(); err != nil {
		panic(err)
	}
	if err := os.Remove(f.Name()); err != nil {
		panic(err)
	}
	return f.Name()
}

Output:

The value of 'foo' is: bar

func (*DB) View

func (db *DB) View(fn func(*Tx) error) error

Example

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"

	bolt "github.com/iryonetwork/encrypted-bolt"
)

var testKey []byte = []byte{0x47, 0x41, 0xf2, 0xd6, 0xa5, 0xa0, 0x46, 0x33, 0x87, 0xa8, 0x2, 0xa2, 0x52, 0xd0, 0x20, 0xed, 0x8c, 0x65, 0x76, 0x50, 0x77, 0x79, 0x4c, 0x7c, 0x76, 0x49, 0xbf, 0x85, 0x18, 0x27, 0x4f, 0xa0}

func main() {
	// Open the database.
	db, err := bolt.Open(testKey, tempfile(), 0666, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer os.Remove(db.Path())

	// Insert data into a bucket.
	if err := db.Update(func(tx *bolt.Tx) error {
		b, err := tx.CreateBucket([]byte("people"))
		if err != nil {
			return err
		}
		if err := b.Put([]byte("john"), []byte("doe")); err != nil {
			return err
		}
		if err := b.Put([]byte("susy"), []byte("que")); err != nil {
			return err
		}
		return nil
	}); err != nil {
		log.Fatal(err)
	}

	// Access data from within a read-only transactional block.
	if err := db.View(func(tx *bolt.Tx) error {
		v := tx.Bucket([]byte("people")).Get([]byte("john"))
		fmt.Printf("John's last name is %s.\n", v)
		return nil
	}); err != nil {
		log.Fatal(err)
	}

	// Close database to release the file lock.
	if err := db.Close(); err != nil {
		log.Fatal(err)
	}

}

// tempfile returns a temporary file path.
func tempfile() string {
	f, err := ioutil.TempFile("", "bolt-")
	if err != nil {
		panic(err)
	}
	if err := f.Close(); err != nil {
		panic(err)
	}
	if err := os.Remove(f.Name()); err != nil {
		panic(err)
	}
	return f.Name()
}

Output:

John's last name is doe.

type Info

type Info = bolt.Info

type Options

type Options = bolt.Options

type PageInfo

type PageInfo = bolt.PageInfo

type Stats

type Stats = bolt.Stats

type Tx

type Tx struct {
	*bolt.Tx
	// contains filtered or unexported fields
}

func (*Tx) Bucket

func (tx *Tx) Bucket(name []byte) *Bucket

func (*Tx) CreateBucket

func (tx *Tx) CreateBucket(name []byte) (*Bucket, error)

func (*Tx) CreateBucketIfNotExists

func (tx *Tx) CreateBucketIfNotExists(name []byte) (*Bucket, error)

func (*Tx) Cursor

func (tx *Tx) Cursor() *Cursor

func (*Tx) DB

func (tx *Tx) DB() *DB

func (*Tx) ForEach

func (tx *Tx) ForEach(fn func(name []byte, b *Bucket) error) error