feat: Support memory store

Author: zenghur

.gitignore

@@ -0,0 +1 @@
+vendor

Gopkg.lock

@@ -0,0 +1,33 @@
+# Gopkg.toml example
+#
+# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  name = "github.com/xiaojiaoyu100/curlew"
+  version = "0.0.1"
+
+[prune]
+  unused-packages = true

Gopkg.toml

@@ -0,0 +1,12 @@
+# Roc
+
+Roc is a key-value memory cache.
+
+## Feature
+
+* Volatile LRU
+* Quick GC
+
+## Usage
+
+

README.md

@@ -0,0 +1,89 @@
+package roc
+
+import (
+	"container/list"
+	"sync"
+	"time"
+)
+
+type Bucket struct {
+	guard sync.Mutex
+	objs  *list.List
+	coll  map[string]*list.Element
+}
+
+func NewBucket() (*Bucket, error) {
+	b := new(Bucket)
+	return b, nil
+}
+
+func (b *Bucket) Get(key string) ([]byte, error) {
+	b.guard.Lock()
+	defer b.guard.Unlock()
+	element, hit := b.coll[key]
+	if !hit {
+		return nil, ErrMiss
+	}
+	u, ok := element.Value.(*Unit)
+	if !ok {
+		return nil, ErrMiss
+	}
+
+	if u.Expire() {
+		return nil, ErrMiss
+	}
+	b.objs.MoveToFront(element)
+	return u.Data, nil
+}
+
+func (b *Bucket) Set(key string, data []byte, d time.Duration) error {
+	b.guard.Lock()
+	defer b.guard.Unlock()
+	element, hit := b.coll[key]
+	if !hit {
+		unit := new(Unit)
+		unit.Key = key
+		unit.Data = data
+		unit.ExpirationTime = time.Now().UTC().Add(d)
+		e := b.objs.PushFront(unit)
+		b.coll[key] = e
+		return nil
+	}
+	b.objs.MoveToFront(element)
+	unit, ok := element.Value.(*Unit)
+	if !ok {
+		return nil
+	}
+	unit.Data = data
+	unit.ExpirationTime = time.Now().UTC().Add(d)
+	return nil
+}
+
+func (b *Bucket) Del(key string) {
+	b.guard.Lock()
+	defer b.guard.Unlock()
+	element, hit := b.coll[key]
+	if !hit {
+		return
+	}
+	b.del(key, element)
+}
+
+func (b *Bucket) del(key string, e *list.Element) {
+	b.objs.Remove(e)
+	delete(b.coll, key)
+}
+
+func (b *Bucket) gc() {
+	b.guard.Lock()
+	defer b.guard.Unlock()
+
+	e := b.objs.Back()
+	for e != nil {
+		unit := e.Value.(*Unit)
+		if unit.Expire() {
+			b.del(unit.Key, e)
+		}
+		e = e.Prev()
+	}
+}

bucket.go

@@ -0,0 +1,101 @@
+package roc
+
+import (
+	"container/list"
+	"context"
+	"github.com/xiaojiaoyu100/curlew"
+	"time"
+)
+
+type Cache struct {
+	GCInterval time.Duration
+	BucketNum  int
+	buckets    []*Bucket
+	dispatcher *curlew.Dispatcher
+	close      chan struct{}
+}
+
+func New(setters ...Setter) (*Cache, error) {
+	var err error
+	c := new(Cache)
+	c.GCInterval = 60 * time.Second
+	c.BucketNum = 128
+
+	for _, setter := range setters {
+		if err := setter(c); err != nil {
+			return nil, err
+		}
+	}
+
+	if !isPowerOfTwo(c.BucketNum) {
+		return nil, ErrorBucketNum
+	}
+	c.buckets = make([]*Bucket, 0, c.BucketNum)
+	for idx := 0; idx < c.BucketNum; idx++ {
+		bucket, err := NewBucket()
+		if err != nil {
+			return nil, err
+		}
+		bucket.coll = make(map[string]*list.Element)
+		bucket.objs = list.New()
+		c.buckets = append(c.buckets, bucket)
+	}
+
+	c.dispatcher, err = curlew.New()
+	if err != nil {
+		return nil, err
+	}
+
+	c.close = make(chan struct{})
+	c.gc()
+	return c, nil
+}
+
+func (c *Cache) gc() {
+	go func() {
+		ticker := time.NewTicker(c.GCInterval)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				{
+					for _, bucket := range c.buckets {
+						j := curlew.NewJob()
+						j.Fn = func(_ context.Context, _ interface{}) error {
+							bucket.gc()
+							return nil
+						}
+						c.dispatcher.SubmitAsync(j)
+					}
+				}
+			case <-c.close:
+				return
+			}
+		}
+	}()
+}
+
+func (c *Cache) Get(key string) ([]byte, error) {
+	idx, err := c.hashIndex(key)
+	if err != nil {
+		return nil, err
+	}
+	return c.buckets[idx].Get(key)
+}
+
+func (c *Cache) Set(key string, value []byte, duration time.Duration) error {
+	idx, err := c.hashIndex(key)
+	if err != nil {
+		return err
+	}
+	return c.buckets[idx].Set(key, value, duration)
+}
+
+func (c *Cache) Del(key string) error {
+	idx, err := c.hashIndex(key)
+	if err != nil {
+		return err
+	}
+	c.buckets[idx].Del(key)
+	return nil
+}

cache.go

@@ -0,0 +1,12 @@
+package roc
+
+type Error string
+
+func (e Error) Error() string {
+	return string(e)
+}
+
+const (
+	ErrMiss        = Error("cache miss")
+	ErrorBucketNum = Error("bucket num must be the power of two")
+)

error.go

@@ -0,0 +1,5 @@
+module github.com/xiaojiaoyu100/roc
+
+go 1.12
+
+require github.com/xiaojiaoyu100/curlew v0.0.1

go.mod

@@ -0,0 +1,2 @@
+github.com/xiaojiaoyu100/curlew v0.0.1 h1:Jk7j+Hx+ZZn+dIy8hUlcoiahr8ni0JIxRD1n7R/N4tE=
+github.com/xiaojiaoyu100/curlew v0.0.1/go.mod h1:LL7ujI8S+sxh1ihoP6Z86o3OSwWLtW943vtc4hF1A9k=

go.sum

@@ -0,0 +1,12 @@
+package roc
+
+import "hash/fnv"
+
+func (c *Cache) hashIndex(key string) (int, error) {
+	hash := fnv.New64a()
+	_, err := hash.Write([]byte(key))
+	if err != nil {
+		return 0, err
+	}
+	return int(hash.Sum64() & uint64((c.BucketNum - 1))), nil
+}

hash.go

@@ -0,0 +1,25 @@
+package roc
+
+import (
+	"time"
+)
+
+type Setter func(c *Cache) error
+
+func isPowerOfTwo(num int) bool {
+	return (num != 0) && ((num & (num - 1)) == 0)
+}
+
+func WithBucketNum(num int) Setter {
+	return func(c *Cache) error {
+		c.BucketNum = num
+		return nil
+	}
+}
+
+func WithGCInterval(interval time.Duration) Setter {
+	return func(c *Cache) error {
+		c.GCInterval = interval
+		return nil
+	}
+}

setter.go

@@ -0,0 +1,13 @@
+package roc
+
+import "time"
+
+type Unit struct {
+	Key            string
+	Data           []byte
+	ExpirationTime time.Time
+}
+
+func (u *Unit) Expire() bool {
+	return u.ExpirationTime.Before(time.Now().UTC())
+}