feat: BoltDB support

Added boltdb support for caching

Author: faabiosr

Gopkg.lock

@@ -52,3 +52,7 @@
 [prune]
   go-tests = true
   unused-packages = true
+
+[[constraint]]
+  name = "github.com/coreos/bbolt"
+  version = "1.3.0"

Gopkg.toml

@@ -152,6 +152,24 @@ func init() {
 }
 ```
 
+### BoltDB
+
+```go
+package main
+
+import (
+    "github.com/fabiorphp/cachego"
+    bolt "github.com/coreos/bbolt"
+)
+
+var cache cachego.Cache
+
+func init() {
+    db, _ := bolt.Open("cache.db", 0600, nil)
+    cache = NewBolt(db)
+}
+```
+
 ### Chain
 
 ```go

README.md

@@ -0,0 +1,185 @@
+package cachego
+
+import (
+	"encoding/json"
+	bolt "github.com/coreos/bbolt"
+	errors "github.com/pkg/errors"
+	"time"
+)
+
+var (
+	boltBucket = []byte("cachego")
+
+	// ErrBoltBucketNotFound returns an error when bucket not found
+	ErrBoltBucketNotFound = errors.New("Bucket not found")
+
+	// ErrBoltCacheExpired returns an error when the cache key was expired
+	ErrBoltCacheExpired = errors.New("Cache expired")
+
+	// ErrBoltDecodeJSON returns json decoding error message
+	ErrBoltDecodeJSON = "Unable to decode json data"
+
+	// ErrBoltFlush returns flush error message
+	ErrBoltFlush = "Unable to flush"
+
+	// ErrBoltSave returns save error message
+	ErrBoltSave = "Unable to save"
+)
+
+type (
+	// Bolt store for caching data
+	Bolt struct {
+		db *bolt.DB
+	}
+
+	// BoltContent it's a structure of cached value
+	BoltContent struct {
+		Duration int64  `json:"duration"`
+		Data     string `json:"data, omitempty"`
+	}
+)
+
+// NewBolt creates an instance of BoltDB cache
+func NewBolt(db *bolt.DB) *Bolt {
+	return &Bolt{db}
+}
+
+func (b *Bolt) read(key string) (*BoltContent, error) {
+	var value []byte
+
+	err := b.db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(boltBucket)
+
+		if bucket == nil {
+			return ErrBoltBucketNotFound
+		}
+
+		value = bucket.Get([]byte(key))
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	content := &BoltContent{}
+
+	err = json.Unmarshal(value, content)
+
+	if err != nil {
+		return nil, errors.Wrap(err, ErrBoltDecodeJSON)
+	}
+
+	if content.Duration == 0 {
+		return content, nil
+	}
+
+	if content.Duration <= time.Now().Unix() {
+		b.Delete(key)
+		return nil, ErrBoltCacheExpired
+	}
+
+	return content, err
+}
+
+// Contains checks if the cached key exists into the BoltDB storage
+func (b *Bolt) Contains(key string) bool {
+	if _, err := b.read(key); err != nil {
+		return false
+	}
+
+	return true
+}
+
+// Delete the cached key from BoltDB storage
+func (b *Bolt) Delete(key string) error {
+	err := b.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(boltBucket)
+
+		if bucket == nil {
+			return ErrBoltBucketNotFound
+		}
+
+		bucket.Delete([]byte(key))
+
+		return nil
+	})
+
+	return err
+}
+
+// Fetch retrieves the cached value from key of the BoltDB storage
+func (b *Bolt) Fetch(key string) (string, error) {
+	content, err := b.read(key)
+
+	if err != nil {
+		return "", err
+	}
+
+	return content.Data, nil
+}
+
+// FetchMulti retrieve multiple cached values from keys of the BoltDB storage
+func (b *Bolt) FetchMulti(keys []string) map[string]string {
+	result := make(map[string]string)
+
+	for _, key := range keys {
+		if value, err := b.Fetch(key); err == nil {
+			result[key] = value
+		}
+	}
+
+	return result
+}
+
+// Flush removes all cached keys of the BoltDB storage
+func (b *Bolt) Flush() error {
+	err := b.db.Update(func(tx *bolt.Tx) error {
+		err := tx.DeleteBucket(boltBucket)
+
+		if err != nil {
+			return errors.Wrap(err, ErrBoltFlush)
+		}
+
+		return err
+	})
+
+	return err
+}
+
+// Save a value in BoltDB storage by key
+func (b *Bolt) Save(key string, value string, lifeTime time.Duration) error {
+	duration := int64(0)
+
+	if lifeTime > 0 {
+		duration = time.Now().Unix() + int64(lifeTime.Seconds())
+	}
+
+	content := &BoltContent{
+		duration,
+		value,
+	}
+
+	data, err := json.Marshal(content)
+
+	if err != nil {
+		return errors.Wrap(err, ErrBoltDecodeJSON)
+	}
+
+	err = b.db.Update(func(tx *bolt.Tx) error {
+		bucket, err := tx.CreateBucketIfNotExists(boltBucket)
+
+		if err != nil {
+			return err
+		}
+
+		return bucket.Put([]byte(key), data)
+	})
+
+	if err != nil {
+		return errors.Wrap(err, ErrBoltSave)
+	}
+
+	return nil
+}

bolt.go

@@ -0,0 +1,173 @@
+package cachego
+
+import (
+	"fmt"
+	bolt "github.com/coreos/bbolt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"os"
+	"testing"
+	"time"
+)
+
+type BoltTestSuite struct {
+	suite.Suite
+
+	assert    *assert.Assertions
+	cache     Cache
+	db        *bolt.DB
+	directory string
+}
+
+func (s *BoltTestSuite) SetupTest() {
+	s.directory = "./cache-dir/"
+
+	os.Mkdir(s.directory, 0777)
+
+	db, err := bolt.Open(s.directory+"cachego.db", 0600, nil)
+
+	if err != nil {
+		s.T().Skip()
+	}
+
+	s.db = db
+	s.cache = NewBolt(s.db)
+	s.assert = assert.New(s.T())
+}
+
+func (s *BoltTestSuite) TearDownTest() {
+	s.db.Close()
+}
+
+func (s *BoltTestSuite) TestSave() {
+	s.assert.Nil(s.cache.Save("foo", "bar", 0))
+}
+
+func (s *BoltTestSuite) TestSaveThrowError() {
+	s.db.Close()
+
+	opts := &bolt.Options{ReadOnly: true}
+	db, err := bolt.Open(s.directory+"cachego.db", 0666, opts)
+
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	defer db.Close()
+
+	cache := NewBolt(db)
+	err = cache.Save("foo", "bar", 0)
+
+	s.assert.Error(err)
+	s.assert.Contains(err.Error(), ErrBoltSave)
+}
+
+func (s *BoltTestSuite) TestFetchThrowErrorWhenBucketNotFound() {
+	s.cache.Flush()
+
+	result, err := s.cache.Fetch("foo")
+
+	s.assert.Empty(result)
+	s.assert.EqualError(err, ErrBoltBucketNotFound.Error())
+}
+
+func (s *BoltTestSuite) TestFetchThrowErrorWhenExpired() {
+	key := "foo"
+	value := "bar"
+
+	s.cache.Save(key, value, 1*time.Second)
+
+	time.Sleep(1 * time.Second)
+
+	result, err := s.cache.Fetch(key)
+
+	s.assert.Empty(result)
+	s.assert.EqualError(err, ErrBoltCacheExpired.Error())
+}
+
+func (s *BoltTestSuite) TestFetch() {
+	key := "foo"
+	value := "bar"
+
+	s.cache.Save(key, value, 0)
+	result, err := s.cache.Fetch(key)
+
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
+}
+
+func (s *BoltTestSuite) TestFetchLongCacheDuration() {
+	key := "foo"
+	value := "bar"
+
+	s.cache.Save(key, value, 10*time.Second)
+	result, err := s.cache.Fetch(key)
+
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
+}
+
+func (s *BoltTestSuite) TestContains() {
+	s.cache.Save("foo", "bar", 0)
+
+	s.assert.True(s.cache.Contains("foo"))
+	s.assert.False(s.cache.Contains("bar"))
+}
+
+func (s *BoltTestSuite) TestDeleteThrowErrorWhenBucketNotFound() {
+	s.cache.Flush()
+
+	err := s.cache.Delete("foo")
+
+	s.assert.EqualError(err, ErrBoltBucketNotFound.Error())
+}
+
+func (s *BoltTestSuite) TestDelete() {
+	s.cache.Save("foo", "bar", 0)
+
+	s.assert.Nil(s.cache.Delete("foo"))
+	s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Delete("bar"))
+}
+
+func (s *BoltTestSuite) TestFlushThrowErrorWhenBucketNotFound() {
+	err := s.cache.Flush()
+
+	s.assert.Error(err)
+	s.assert.Contains(err.Error(), ErrBoltFlush)
+}
+
+func (s *BoltTestSuite) TestFlush() {
+	s.cache.Save("foo", "bar", 0)
+
+	s.assert.Nil(s.cache.Flush())
+	s.assert.False(s.cache.Contains("foo"))
+}
+
+func (s *BoltTestSuite) TestFetchMultiReturnNoItemsWhenThrowError() {
+	s.cache.Flush()
+	result := s.cache.FetchMulti([]string{"foo"})
+
+	s.assert.Len(result, 0)
+}
+
+func (s *BoltTestSuite) TestFetchMulti() {
+	s.cache.Save("foo", "bar", 0)
+	s.cache.Save("john", "doe", 0)
+
+	result := s.cache.FetchMulti([]string{"foo", "john"})
+
+	s.assert.Len(result, 2)
+}
+
+func (s *BoltTestSuite) TestFetchMultiWhenOnlyOneOfKeysExists() {
+	s.cache.Save("foo", "bar", 0)
+
+	result := s.cache.FetchMulti([]string{"foo", "alice"})
+
+	s.assert.Len(result, 1)
+}
+
+func TestBoltRunSuite(t *testing.T) {
+	suite.Run(t, new(BoltTestSuite))
+}