Add docs for bitcask

.drone.yml

@@ -12,11 +12,3 @@ steps:
     settings:
       token:
         from_secret: codecov-token
-
-  - name: notify
-    image: plugins/webhook
-    urls: https://msgbus.mills.io/ci.mills.io
-    when:
-      status:
-        - success
-        - failure

.goreleaser.yml

@@ -3,14 +3,14 @@ builds:
     binary: bitcask
     main: ./cmd/bitcask
     flags: -tags "static_build"
-    ldflags: -w -X .Version={{.Version}} -X .Commit={{.Commit}}
+    ldflags: -w -X github.com/prologic/bitcask/internal.Version={{.Version}} -X github.com/prologic/bitcask/internal.Commit={{.Commit}}
     env:
       - CGO_ENABLED=0
   - 
     binary: bitcaskd
     main: ./cmd/bitcaskd
     flags: -tags "static_build"
-    ldflags: -w -X .Version={{.Version}} -X .Commit={{.Commit}}
+    ldflags: -w -X github.com/prologic/bitcask/internal.Version={{.Version}} -X github.com/prologic/bitcask/internal.Commit={{.Commit}}
     env:
       - CGO_ENABLED=0
 sign:

Makefile

@@ -25,6 +25,7 @@ generate:
 
 install: build
 	@go install ./cmd/bitcask/...
+	@go install ./cmd/bitcaskd/...
 
 image:
 	@docker build -t prologic/bitcask .

README.md

@@ -6,13 +6,13 @@
 [![GoDoc](https://godoc.org/github.com/prologic/bitcask?status.svg)](https://godoc.org/github.com/prologic/bitcask) 
 [![Sourcegraph](https://sourcegraph.com/github.com/prologic/bitcask/-/badge.svg)](https://sourcegraph.com/github.com/prologic/bitcask?badge)
 
-A Bitcask (LSM+WAL) Key/Value Store written in Go.
+A high performance Key/Value store written in [Go](https://golang.org) with a predictable read/write performance and high throughput. Uses a [Bitcask](https://en.wikipedia.org/wiki/Bitcask) on-disk layout (LSM+WAL) similar to [Riak](https://riak.com/).
 
 ## Features
 
-* Embeddable
+* Embeddable (`import "github.com/prologic/bitcask"`)
-* Builtin CLI
+* Builtin CLI (`bitcask`)
-* Builtin Redis-compatible server
+* Builtin Redis-compatible server (`bitcaskd`)
 * Predictable read/write performance
 * Low latecny
 * High throughput (See: [Performance](README.md#Performance)
@@ -34,16 +34,13 @@ $ go get github.com/prologic/bitcask
 ```#!go
 package main
 
-import (
+import "github.com/prologic/bitcask"
-    "log"
-
-    "github.com/prologic/bitcask"
-)
 
 func main() {
     db, _ := bitcask.Open("/tmp/db")
+    defer db.Close()
     db.Set("Hello", []byte("World"))
-    db.Close()
+    val, _ := db.Get("hello")
 }
 ```
 

bitcask.go

@@ -1,7 +1,7 @@
 package bitcask
 
 import (
-	"fmt"
+	"errors"
 	"hash/crc32"
 	"io"
 	"io/ioutil"
@@ -15,6 +15,30 @@ import (
 	"github.com/prologic/bitcask/internal"
 )
 
+var (
+	// ErrKeyNotFound is the error returned when a key is not found
+	ErrKeyNotFound = errors.New("error: key not found")
+
+	// ErrKeyTooLarge is the error returned for a key that exceeds the
+	// maximum allowed key size (configured with WithMaxKeySize).
+	ErrKeyTooLarge = errors.New("error: key too large")
+
+	// ErrValueTooLarge is the error returned for a value that exceeds the
+	// maximum allowed value size (configured with WithMaxValueSize).
+	ErrValueTooLarge = errors.New("error: value too large")
+
+	// ErrChecksumFailed is the error returned if a key/valie retrieved does
+	// not match its CRC checksum
+	ErrChecksumFailed = errors.New("error: checksum failed")
+
+	// ErrDatabaseLocked is the error returned if the database is locked
+	// (typically opened by another process)
+	ErrDatabaseLocked = errors.New("error: database locked")
+)
+
+// Bitcask is a struct that represents a on-disk LSM and WAL data structure
+// and in-memory hash of key/value pairs as per the Bitcask paper and seen
+// in the Riak database.
 type Bitcask struct {
 	*flock.Flock
 
@@ -24,10 +48,11 @@ type Bitcask struct {
 	keydir    *internal.Keydir
 	datafiles []*internal.Datafile
 	trie      *trie.Trie
-
-	maxDatafileSize int64
 }
 
+// Close closes the database and removes the lock. It is important to call
+// Close() as this is the only wat to cleanup the lock held by the open
+// database.
 func (b *Bitcask) Close() error {
 	defer func() {
 		b.Flock.Unlock()
@@ -40,16 +65,19 @@ func (b *Bitcask) Close() error {
 	return b.curr.Close()
 }
 
+// Sync flushes all buffers to disk ensuring all data is written
 func (b *Bitcask) Sync() error {
 	return b.curr.Sync()
 }
 
+// Get retrieves the value of the given key. If the key is not found or an/I/O
+// error occurs a null byte slice is returend along with the error.
 func (b *Bitcask) Get(key string) ([]byte, error) {
 	var df *internal.Datafile
 
 	item, ok := b.keydir.Get(key)
 	if !ok {
-		return nil, fmt.Errorf("error: key not found %s", key)
+		return nil, ErrKeyNotFound
 	}
 
 	if item.FileID == b.curr.FileID() {
@@ -65,18 +93,25 @@ func (b *Bitcask) Get(key string) ([]byte, error) {
 
 	checksum := crc32.ChecksumIEEE(e.Value)
 	if checksum != e.Checksum {
-		return nil, fmt.Errorf("error: checksum falied %s %d != %d", key, e.Checksum, checksum)
+		return nil, ErrChecksumFailed
 	}
 
 	return e.Value, nil
 }
 
+// Has returns true if the key exists in the database, false otherwise.
+func (b *Bitcask) Has(key string) bool {
+	_, ok := b.keydir.Get(key)
+	return ok
+}
+
+// Put stores the key and value in the database.
 func (b *Bitcask) Put(key string, value []byte) error {
-	if len(key) > b.config.MaxKeySize {
+	if len(key) > b.config.maxKeySize {
-		return fmt.Errorf("error: key too large %d > %d", len(key), b.config.MaxKeySize)
+		return ErrKeyTooLarge
 	}
-	if len(value) > b.config.MaxValueSize {
+	if len(value) > b.config.maxValueSize {
-		return fmt.Errorf("error: value too large %d > %d", len(value), b.config.MaxValueSize)
+		return ErrValueTooLarge
 	}
 
 	offset, err := b.put(key, value)
@@ -90,6 +125,8 @@ func (b *Bitcask) Put(key string, value []byte) error {
 	return nil
 }
 
+// Delete deletes the named key. If the key doesn't exist or an I/O error
+// occurs the error is returned.
 func (b *Bitcask) Delete(key string) error {
 	_, err := b.put(key, []byte{})
 	if err != nil {
@@ -102,6 +139,9 @@ func (b *Bitcask) Delete(key string) error {
 	return nil
 }
 
+// Scan performa a prefix scan of keys matching the given prefix and calling
+// the function `f` with the keys found. If the function returns an error
+// no further keys are processed and the first error returned.
 func (b *Bitcask) Scan(prefix string, f func(key string) error) error {
 	keys := b.trie.PrefixSearch(prefix)
 	for _, key := range keys {
@@ -112,6 +152,19 @@ func (b *Bitcask) Scan(prefix string, f func(key string) error) error {
 	return nil
 }
 
+// Len returns the total number of keys in the database
+func (b *Bitcask) Len() int {
+	return b.keydir.Len()
+}
+
+// Keys returns all keys in the database as a channel of string(s)
+func (b *Bitcask) Keys() chan string {
+	return b.keydir.Keys()
+}
+
+// Fold iterates over all keys in the database calling the function `f` for
+// each key. If the function returns an error, no further keys are processed
+// and the error returned.
 func (b *Bitcask) Fold(f func(key string) error) error {
 	for key := range b.keydir.Keys() {
 		if err := f(key); err != nil {
@@ -127,7 +180,7 @@ func (b *Bitcask) put(key string, value []byte) (int64, error) {
 		return -1, err
 	}
 
-	if size >= b.maxDatafileSize {
+	if size >= int64(b.config.maxDatafileSize) {
 		err := b.curr.Close()
 		if err != nil {
 			return -1, err
@@ -152,11 +205,9 @@ func (b *Bitcask) put(key string, value []byte) (int64, error) {
 	return b.curr.Write(e)
 }
 
-func (b *Bitcask) setMaxDatafileSize(size int64) error {
+// Merge merges all datafiles in the database creating hint files for faster
-	b.maxDatafileSize = size
+// startup. Old keys are squashed and deleted keys removes. Call this function
-	return nil
+// periodically to reclaim disk space.
-}
-
 func Merge(path string, force bool) error {
 	fns, err := internal.GetDatafiles(path)
 	if err != nil {
@@ -263,7 +314,10 @@ func Merge(path string, force bool) error {
 	return nil
 }
 
-func Open(path string, options ...option) (*Bitcask, error) {
+// Open opens the database at the given path with optional options.
+// Options can be provided with the `WithXXX` functions that provide
+// configuration options as functions.
+func Open(path string, options ...Option) (*Bitcask, error) {
 	if err := os.MkdirAll(path, 0755); err != nil {
 		return nil, err
 	}
@@ -346,14 +400,12 @@ func Open(path string, options ...option) (*Bitcask, error) {
 
 	bitcask := &Bitcask{
 		Flock:     flock.New(filepath.Join(path, "lock")),
-		config:    NewDefaultConfig(),
+		config:    newDefaultConfig(),
 		path:      path,
 		curr:      curr,
 		keydir:    keydir,
 		datafiles: datafiles,
 		trie:      trie,
-
-		maxDatafileSize: DefaultMaxDatafileSize,
 	}
 
 	for _, opt := range options {
@@ -369,7 +421,7 @@ func Open(path string, options ...option) (*Bitcask, error) {
 	}
 
 	if !locked {
-		return nil, fmt.Errorf("error: database locked %s", path)
+		return nil, ErrDatabaseLocked
 	}
 
 	return bitcask, nil

bitcask_test.go

@@ -40,12 +40,48 @@ func TestAll(t *testing.T) {
 		assert.Equal([]byte("bar"), val)
 	})
 
+	t.Run("Len", func(t *testing.T) {
+		assert.Equal(1, db.Len())
+	})
+
+	t.Run("Has", func(t *testing.T) {
+		assert.True(db.Has("foo"))
+	})
+
+	t.Run("Keys", func(t *testing.T) {
+		keys := make([]string, 0)
+		for key := range db.Keys() {
+			keys = append(keys, key)
+		}
+		assert.Equal([]string{"foo"}, keys)
+	})
+
+	t.Run("Fold", func(t *testing.T) {
+		var (
+			keys   []string
+			values [][]byte
+		)
+
+		err := db.Fold(func(key string) error {
+			value, err := db.Get(key)
+			if err != nil {
+				return err
+			}
+			keys = append(keys, key)
+			values = append(values, value)
+			return nil
+		})
+		assert.NoError(err)
+		assert.Equal([]string{"foo"}, keys)
+		assert.Equal([][]byte{[]byte("bar")}, values)
+	})
+
 	t.Run("Delete", func(t *testing.T) {
 		err := db.Delete("foo")
 		assert.NoError(err)
 		_, err = db.Get("foo")
 		assert.Error(err)
-		assert.Equal("error: key not found foo", err.Error())
+		assert.Equal(ErrKeyNotFound, err)
 	})
 
 	t.Run("Sync", func(t *testing.T) {
@@ -92,7 +128,7 @@ func TestDeletedKeys(t *testing.T) {
 			assert.NoError(err)
 			_, err = db.Get("foo")
 			assert.Error(err)
-			assert.Equal("error: key not found foo", err.Error())
+			assert.Equal(ErrKeyNotFound, err)
 		})
 
 		t.Run("Sync", func(t *testing.T) {
@@ -120,7 +156,7 @@ func TestDeletedKeys(t *testing.T) {
 		t.Run("Get", func(t *testing.T) {
 			_, err = db.Get("foo")
 			assert.Error(err)
-			assert.Equal("error: key not found foo", err.Error())
+			assert.Equal(ErrKeyNotFound, err)
 		})
 
 		t.Run("Close", func(t *testing.T) {
@@ -148,7 +184,7 @@ func TestMaxKeySize(t *testing.T) {
 		value := []byte("foobar")
 		err = db.Put(key, value)
 		assert.Error(err)
-		assert.Equal("error: key too large 17 > 16", err.Error())
+		assert.Equal(ErrKeyTooLarge, err)
 	})
 }
 
@@ -170,11 +206,11 @@ func TestMaxValueSize(t *testing.T) {
 		value := []byte(strings.Repeat(" ", 17))
 		err = db.Put(key, value)
 		assert.Error(err)
-		assert.Equal("error: value too large 17 > 16", err.Error())
+		assert.Equal(ErrValueTooLarge, err)
 	})
 }
 
-func TestMerge(t *testing.T) {
+func TestOpenMerge(t *testing.T) {
 	assert := assert.New(t)
 
 	testdir, err := ioutil.TempDir("", "bitcask")
@@ -187,7 +223,7 @@ func TestMerge(t *testing.T) {
 		)
 
 		t.Run("Open", func(t *testing.T) {
-			db, err = Open(testdir, WithMaxDatafileSize(1024))
+			db, err = Open(testdir, WithMaxDatafileSize(32))
 			assert.NoError(err)
 		})
 
@@ -245,6 +281,77 @@ func TestMerge(t *testing.T) {
 	})
 }
 
+func TestMergeOpen(t *testing.T) {
+	var (
+		db  *Bitcask
+		err error
+	)
+
+	assert := assert.New(t)
+
+	testdir, err := ioutil.TempDir("", "bitcask")
+	assert.NoError(err)
+
+	t.Run("Setup", func(t *testing.T) {
+		t.Run("Open", func(t *testing.T) {
+			db, err = Open(testdir, WithMaxDatafileSize(32))
+			assert.NoError(err)
+		})
+
+		t.Run("Put", func(t *testing.T) {
+			for i := 0; i < 1024; i++ {
+				err = db.Put(string(i), []byte(strings.Repeat(" ", 1024)))
+				assert.NoError(err)
+			}
+		})
+
+		t.Run("Get", func(t *testing.T) {
+			for i := 0; i < 32; i++ {
+				err = db.Put(string(i), []byte(strings.Repeat(" ", 1024)))
+				assert.NoError(err)
+				val, err := db.Get(string(i))
+				assert.NoError(err)
+				assert.Equal([]byte(strings.Repeat(" ", 1024)), val)
+			}
+		})
+
+		t.Run("Sync", func(t *testing.T) {
+			err = db.Sync()
+			assert.NoError(err)
+		})
+
+		t.Run("Close", func(t *testing.T) {
+			err = db.Close()
+			assert.NoError(err)
+		})
+	})
+
+	t.Run("Merge", func(t *testing.T) {
+		t.Run("Merge", func(t *testing.T) {
+			err = Merge(testdir, true)
+			assert.NoError(err)
+		})
+
+		t.Run("Open", func(t *testing.T) {
+			db, err = Open(testdir)
+			assert.NoError(err)
+		})
+
+		t.Run("Get", func(t *testing.T) {
+			for i := 0; i < 32; i++ {
+				val, err := db.Get(string(i))
+				assert.NoError(err)
+				assert.Equal([]byte(strings.Repeat(" ", 1024)), val)
+			}
+		})
+
+		t.Run("Close", func(t *testing.T) {
+			err = db.Close()
+			assert.NoError(err)
+		})
+	})
+}
+
 func TestConcurrent(t *testing.T) {
 	var (
 		db  *Bitcask
@@ -387,7 +494,7 @@ func TestLocking(t *testing.T) {
 
 	_, err = Open(testdir)
 	assert.Error(err)
-	assert.Equal(fmt.Sprintf("error: database locked %s", testdir), err.Error())
+	assert.Equal(ErrDatabaseLocked, err)
 }
 
 type benchmarkTestCase struct {

cmd/bitcaskd/main.go

@@ -96,6 +96,22 @@ func main() {
 				} else {
 					conn.WriteBulk(value)
 				}
+			case "keys":
+				conn.WriteArray(db.Len())
+				for key := range db.Keys() {
+					conn.WriteBulk([]byte(key))
+				}
+			case "exists":
+				if len(cmd.Args) != 2 {
+					conn.WriteError("ERR wrong number of arguments for '" + string(cmd.Args[0]) + "' command")
+					return
+				}
+				key := string(cmd.Args[1])
+				if db.Has(key) {
+					conn.WriteInt(1)
+				} else {
+					conn.WriteInt(0)
+				}
 			case "del":
 				if len(cmd.Args) != 2 {
 					conn.WriteError("ERR wrong number of arguments for '" + string(cmd.Args[0]) + "' command")

internal/keydir.go

@@ -52,11 +52,17 @@ func (k *Keydir) Delete(key string) {
 	delete(k.kv, key)
 }
 
+func (k *Keydir) Len() int {
+	return len(k.kv)
+}
+
 func (k *Keydir) Keys() chan string {
 	ch := make(chan string)
 	go func() {
-		for k := range k.kv {
+		k.RLock()
-			ch <- k
+		defer k.RUnlock()
+		for key := range k.kv {
+			ch <- key
 		}
 		close(ch)
 	}()

options.go

@@ -1,47 +1,53 @@
 package bitcask
 
 const (
+	// DefaultMaxDatafileSize is the default maximum datafile size in bytes
 	DefaultMaxDatafileSize = 1 << 20 // 1MB
-	DefaultMaxKeySize      = 64      // 64 bytes
+
-	DefaultMaxValueSize    = 1 << 16 // 65KB
+	// DefaultMaxKeySize is the default maximum key size in bytes
+	DefaultMaxKeySize = 64 // 64 bytes
+
+	// DefaultMaxValueSize is the default value size in bytes
+	DefaultMaxValueSize = 1 << 16 // 65KB
 )
 
-// Option ...
+// Option is a function that takes a config struct and modifies it
-type Option option
+type Option func(*config) error
-
-type option func(*config) error
 
 type config struct {
-	MaxDatafileSize int
+	maxDatafileSize int
-	MaxKeySize      int
+	maxKeySize      int
-	MaxValueSize    int
+	maxValueSize    int
 }
 
-func NewDefaultConfig() *config {
+func newDefaultConfig() *config {
 	return &config{
-		MaxDatafileSize: DefaultMaxDatafileSize,
+		maxDatafileSize: DefaultMaxDatafileSize,
-		MaxKeySize:      DefaultMaxKeySize,
+		maxKeySize:      DefaultMaxKeySize,
-		MaxValueSize:    DefaultMaxValueSize,
+		maxValueSize:    DefaultMaxValueSize,
 	}
 }
 
-func WithMaxDatafileSize(size int) option {
+// WithMaxDatafileSize sets the maximum datafile size option
+func WithMaxDatafileSize(size int) Option {
 	return func(cfg *config) error {
-		cfg.MaxDatafileSize = size
+		cfg.maxDatafileSize = size
 		return nil
 	}
 }
 
-func WithMaxKeySize(size int) option {
+// WithMaxKeySize sets the maximum key size option
+func WithMaxKeySize(size int) Option {
 	return func(cfg *config) error {
-		cfg.MaxKeySize = size
+		cfg.maxKeySize = size
 		return nil
 	}
 }
 
-func WithMaxValueSize(size int) option {
+// WithMaxValueSize sets the maximum value size option
+func WithMaxValueSize(size int) Option {
 	return func(cfg *config) error {
-		cfg.MaxValueSize = size
+		cfg.maxValueSize = size
 		return nil
 	}
 }