Call Close() at end of sub-commands

README.md

@@ -106,6 +106,7 @@ BenchmarkGet/4K-4           	  200000	      7673 ns/op	    9072 B/op	       5 al
 BenchmarkGet/8K-4           	  200000	     10373 ns/op	   17776 B/op	       5 allocs/op
 BenchmarkGet/16K-4          	  100000	     14227 ns/op	   34928 B/op	       5 allocs/op
 BenchmarkGet/32K-4          	  100000	     25953 ns/op	   73840 B/op	       5 allocs/op
+
 BenchmarkPut/128B-4         	  100000	     17353 ns/op	     680 B/op	       5 allocs/op
 BenchmarkPut/256B-4         	  100000	     18620 ns/op	     808 B/op	       5 allocs/op
 BenchmarkPut/512B-4         	  100000	     19068 ns/op	    1096 B/op	       5 allocs/op

bitcask.go

@@ -2,31 +2,27 @@ package bitcask
 
 import (
 	"errors"
-	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"sort"
-	"strconv"
 	"strings"
 	"time"
 
 	"github.com/gofrs/flock"
 )
 
-const (
-	DefaultMaxDatafileSize = 1 << 20 // 1MB
-)
-
 var (
-	ErrKeyNotFound       = errors.New("error: key not found")
-	ErrCannotAcquireLock = errors.New("error: cannot acquire lock")
+	ErrKeyNotFound    = errors.New("error: key not found")
+	ErrKeyTooLarge    = errors.New("error: key too large")
+	ErrValueTooLarge  = errors.New("error: value too large")
+	ErrDatabaseLocked = errors.New("error: database locked")
 )
 
 type Bitcask struct {
 	*flock.Flock
 
+	opts      Options
 	path      string
 	curr      *Datafile
 	keydir    *Keydir
@@ -38,6 +34,7 @@ type Bitcask struct {
 func (b *Bitcask) Close() error {
 	defer func() {
 		b.Flock.Unlock()
+		os.Remove(b.Flock.Path())
 	}()
 
 	for _, df := range b.datafiles {
@@ -73,6 +70,13 @@ func (b *Bitcask) Get(key string) ([]byte, error) {
 }
 
 func (b *Bitcask) Put(key string, value []byte) error {
+	if len(key) > b.opts.MaxKeySize {
+		return ErrKeyTooLarge
+	}
+	if len(value) > b.opts.MaxValueSize {
+		return ErrValueTooLarge
+	}
+
 	index, err := b.put(key, value)
 	if err != nil {
 		return err
@@ -135,39 +139,6 @@ func (b *Bitcask) setMaxDatafileSize(size int64) error {
 	return nil
 }
 
-func WithMaxDatafileSize(size int64) func(*Bitcask) error {
-	return func(b *Bitcask) error {
-		return b.setMaxDatafileSize(size)
-	}
-}
-
-func getDatafiles(path string) ([]string, error) {
-	fns, err := filepath.Glob(fmt.Sprintf("%s/*.data", path))
-	if err != nil {
-		return nil, err
-	}
-	sort.Strings(fns)
-	return fns, nil
-}
-
-func parseIds(fns []string) ([]int, error) {
-	var ids []int
-	for _, fn := range fns {
-		fn = filepath.Base(fn)
-		ext := filepath.Ext(fn)
-		if ext != ".data" {
-			continue
-		}
-		id, err := strconv.ParseInt(strings.TrimSuffix(fn, ext), 10, 32)
-		if err != nil {
-			return nil, err
-		}
-		ids = append(ids, int(id))
-	}
-	sort.Ints(ids)
-	return ids, nil
-}
-
 func Merge(path string, force bool) error {
 	fns, err := getDatafiles(path)
 	if err != nil {
@@ -353,6 +324,7 @@ func Open(path string, options ...func(*Bitcask) error) (*Bitcask, error) {
 
 	bitcask := &Bitcask{
 		Flock:     flock.New(filepath.Join(path, "lock")),
+		opts:      NewDefaultOptions(),
 		path:      path,
 		curr:      curr,
 		keydir:    keydir,
@@ -374,7 +346,7 @@ func Open(path string, options ...func(*Bitcask) error) (*Bitcask, error) {
 	}
 
 	if !locked {
-		return nil, ErrCannotAcquireLock
+		return nil, ErrDatabaseLocked
 	}
 
 	return bitcask, nil

bitcask_test.go

@@ -128,6 +128,54 @@ func TestDeletedKeys(t *testing.T) {
 	})
 }
 
+func TestMaxKeySize(t *testing.T) {
+	assert := assert.New(t)
+
+	testdir, err := ioutil.TempDir("", "bitcask")
+	assert.NoError(err)
+
+	var db *Bitcask
+
+	size := 16
+
+	t.Run("Open", func(t *testing.T) {
+		db, err = Open(testdir, WithMaxKeySize(size))
+		assert.NoError(err)
+	})
+
+	t.Run("Put", func(t *testing.T) {
+		key := strings.Repeat(" ", size+1)
+		value := []byte("foobar")
+		err = db.Put(key, value)
+		assert.Error(err)
+		assert.Equal("error: key too large", err.Error())
+	})
+}
+
+func TestMaxValueSize(t *testing.T) {
+	assert := assert.New(t)
+
+	testdir, err := ioutil.TempDir("", "bitcask")
+	assert.NoError(err)
+
+	var db *Bitcask
+
+	size := 16
+
+	t.Run("Open", func(t *testing.T) {
+		db, err = Open(testdir, WithMaxValueSize(size))
+		assert.NoError(err)
+	})
+
+	t.Run("Put", func(t *testing.T) {
+		key := "foo"
+		value := []byte(strings.Repeat(" ", size+1))
+		err = db.Put(key, value)
+		assert.Error(err)
+		assert.Equal("error: value too large", err.Error())
+	})
+}
+
 func TestMerge(t *testing.T) {
 	assert := assert.New(t)
 
@@ -291,7 +339,7 @@ func TestLocking(t *testing.T) {
 
 	_, err = Open(testdir)
 	assert.Error(err)
-	assert.Equal("error: cannot acquire lock", err.Error())
+	assert.Equal("error: database locked", err.Error())
 }
 
 type benchmarkTestCase struct {

cmd/bitcask/del.go

@@ -35,6 +35,7 @@ func del(path, key string) int {
 		log.WithError(err).Error("error opening database")
 		return 1
 	}
+	defer db.Close()
 
 	err = db.Delete(key)
 	if err != nil {

cmd/bitcask/get.go

@@ -36,6 +36,7 @@ func get(path, key string) int {
 		log.WithError(err).Error("error opening database")
 		return 1
 	}
+	defer db.Close()
 
 	value, err := db.Get(key)
 	if err != nil {

cmd/bitcask/keys.go

@@ -34,6 +34,7 @@ func keys(path string) int {
 		log.WithError(err).Error("error opening database")
 		return 1
 	}
+	defer db.Close()
 
 	err = db.Fold(func(key string) error {
 		fmt.Printf("%s\n", key)

cmd/bitcask/set.go

@@ -47,6 +47,7 @@ func set(path, key string, value io.Reader) int {
 		log.WithError(err).Error("error opening database")
 		return 1
 	}
+	defer db.Close()
 
 	data, err := ioutil.ReadAll(value)
 	if err != nil {

cmd/bitcaskd/main.go

@@ -16,7 +16,7 @@ var (
 	bind            string
 	debug           bool
 	version         bool
-	maxDatafileSize int64
+	maxDatafileSize int
 )
 
 func init() {
@@ -30,7 +30,7 @@ func init() {
 
 	flag.StringVarP(&bind, "bind", "b", ":6379", "interface and port to bind to")
 
-	flag.Int64Var(&maxDatafileSize, "max-datafile-size", 1<<20, "maximum datafile size in bytes")
+	flag.IntVar(&maxDatafileSize, "max-datafile-size", 1<<20, "maximum datafile size in bytes")
 }
 
 func main() {

options.go

@@ -0,0 +1,42 @@
+package bitcask
+
+const (
+	DefaultMaxDatafileSize = 1 << 20 // 1MB
+	DefaultMaxKeySize      = 64      // 64 bytes
+	DefaultMaxValueSize    = 1 << 16 // 65KB
+)
+
+type Options struct {
+	MaxDatafileSize int
+	MaxKeySize      int
+	MaxValueSize    int
+}
+
+func NewDefaultOptions() Options {
+	return Options{
+		MaxDatafileSize: DefaultMaxDatafileSize,
+		MaxKeySize:      DefaultMaxKeySize,
+		MaxValueSize:    DefaultMaxValueSize,
+	}
+}
+
+func WithMaxDatafileSize(size int) func(*Bitcask) error {
+	return func(b *Bitcask) error {
+		b.opts.MaxDatafileSize = size
+		return nil
+	}
+}
+
+func WithMaxKeySize(size int) func(*Bitcask) error {
+	return func(b *Bitcask) error {
+		b.opts.MaxKeySize = size
+		return nil
+	}
+}
+
+func WithMaxValueSize(size int) func(*Bitcask) error {
+	return func(b *Bitcask) error {
+		b.opts.MaxValueSize = size
+		return nil
+	}
+}

utils.go

@@ -0,0 +1,36 @@
+package bitcask
+
+import (
+	"fmt"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+func getDatafiles(path string) ([]string, error) {
+	fns, err := filepath.Glob(fmt.Sprintf("%s/*.data", path))
+	if err != nil {
+		return nil, err
+	}
+	sort.Strings(fns)
+	return fns, nil
+}
+
+func parseIds(fns []string) ([]int, error) {
+	var ids []int
+	for _, fn := range fns {
+		fn = filepath.Base(fn)
+		ext := filepath.Ext(fn)
+		if ext != ".data" {
+			continue
+		}
+		id, err := strconv.ParseInt(strings.TrimSuffix(fn, ext), 10, 32)
+		if err != nil {
+			return nil, err
+		}
+		ids = append(ids, int(id))
+	}
+	sort.Ints(ids)
+	return ids, nil
+}