feat(cache): add inmemory cache (#10)

* add lru

* add LRU

* remove lfu

* re-order the cached mechanism

* add cache control header

* refactor cache packeg

* add implemetantaion inmem cache

Author: bxcodec

.gitignore

@@ -10,3 +10,4 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+.vscode

cache/cache.go

@@ -0,0 +1,57 @@
+package cache
+
+import (
+	"errors"
+	"time"
+)
+
+var (
+	// ErrInvalidCachedResponse will throw if the cached response is invalid
+	ErrInvalidCachedResponse = errors.New("Cached Response is Invalid")
+	// ErrFailedToSaveToCache will throw if the item can't be saved to cache
+	ErrFailedToSaveToCache = errors.New("Failed to save item")
+	// ErrCacheMissed will throw if an item can't be retrieved (due to invalid, or missing)
+	ErrCacheMissed = errors.New("Cache is missing")
+)
+
+// Interactor ...
+type Interactor interface {
+	Set(key string, value CachedResponse) error
+	Get(key string) (CachedResponse, error)
+	Delete(key string) error
+}
+
+// CachedResponse represent the cacher struct item
+type CachedResponse struct {
+	StatusCode     int       `json:"statusCode"`
+	DumpedResponse []byte    `json:"response"`
+	DumpedBody     []byte    `json:"body"`
+	RequestURI     string    `json:"requestUri"`
+	RequestMethod  string    `json:"requestMethod"`
+	CachedTime     time.Time `json:"cachedTime"`
+}
+
+// Validate will validate the cached response
+func (c *CachedResponse) Validate() (err error) {
+	if c.StatusCode == 0 {
+		return ErrInvalidCachedResponse
+	}
+
+	if c.RequestMethod == "" {
+		return ErrInvalidCachedResponse
+	}
+
+	if c.RequestURI == "" {
+		return ErrInvalidCachedResponse
+	}
+
+	if len(c.DumpedResponse) == 0 {
+		return ErrInvalidCachedResponse
+	}
+
+	if c.CachedTime.IsZero() {
+		return ErrInvalidCachedResponse
+	}
+
+	return
+}

cache/inmem/inmem.go

@@ -0,0 +1,34 @@
+package inmem
+
+import (
+	memcache "github.com/bxcodec/gotcha/cache"
+	"github.com/bxcodec/hache/cache"
+)
+
+type inmemCache struct {
+	cache memcache.Cache
+}
+
+// NewCache ...
+func NewCache(c memcache.Cache) cache.Interactor {
+	return &inmemCache{
+		cache: c,
+	}
+}
+
+func (i *inmemCache) Set(key string, value cache.CachedResponse) (err error) {
+	return i.cache.Set(key, value)
+}
+
+func (i *inmemCache) Get(key string) (res cache.CachedResponse, err error) {
+	item, err := i.cache.Get(key)
+	if err != nil {
+		return
+	}
+	res = item.(cache.CachedResponse)
+	return
+}
+
+func (i *inmemCache) Delete(key string) (err error) {
+	return i.cache.Delete(key)
+}

cacher.go

@@ -1 +1,6 @@
 module github.com/bxcodec/hache
+
+require (
+	github.com/bxcodec/gotcha v1.0.0-beta.2
+	github.com/hashicorp/golang-lru v0.5.1
+)

go.mod

@@ -0,0 +1,4 @@
+github.com/bxcodec/gotcha v1.0.0-beta.2 h1:0jY/Mx6O5jzM2fkcz84zzyy67hLu/bKGJEFTtcRmw5I=
+github.com/bxcodec/gotcha v1.0.0-beta.2/go.mod h1:MEL9PRYL9Squu1zxreMIzJU6xtMouPmQybWEtXrL1nk=
+github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=

go.sum

@@ -1,18 +1,22 @@
 package hache
 
 import (
-	"errors"
 	"net/http"
 	"time"
-)
 
-var (
-	// ErrInvalidCachedResponse will throw if the cached response is invalid
-	ErrInvalidCachedResponse = errors.New("Cached Response is Invalid")
+	"github.com/bxcodec/gotcha"
+	inmemcache "github.com/bxcodec/gotcha/cache"
+	"github.com/bxcodec/hache/cache"
+	"github.com/bxcodec/hache/cache/inmem"
 )
 
 // New ...
-func New(client *http.Client, cacheInteractor CacheInteractor) (err error) {
+func New(client *http.Client, cacheInteractor cache.Interactor) (err error) {
+	newClient(client, cacheInteractor)
+	return
+}
+
+func newClient(client *http.Client, cacheInteractor cache.Interactor) (err error) {
 	roundtrip := &RoundTrip{
 		DefaultRoundTripper: client.Transport,
 		CacheInteractor:     cacheInteractor,
@@ -24,40 +28,15 @@ func New(client *http.Client, cacheInteractor CacheInteractor) (err error) {
 // NewWithInmemoryCache will create a complete cache-support of HTTP client with using inmemory cache.
 // If the duration not set, the cache will use LFU algorithm
 func NewWithInmemoryCache(client *http.Client, duration ...time.Duration) (err error) {
-	panic("TODO: (bxcodec)")
-	return
-}
-
-// CachedResponse represent the cacher struct item
-type CachedResponse struct {
-	StatusCode     int       `json:"statusCode"`
-	DumpedResponse []byte    `json:"body"`
-	RequestURI     string    `json:"requestUri"`
-	RequestMethod  string    `json:"requestMethod"`
-	CachedTime     time.Time `json:"cachedTime"`
-}
-
-// Validate will validate the cached response
-func (c *CachedResponse) Validate() (err error) {
-	if c.StatusCode == 0 {
-		return ErrInvalidCachedResponse
-	}
-
-	if c.RequestMethod == "" {
-		return ErrInvalidCachedResponse
-	}
-
-	if c.RequestURI == "" {
-		return ErrInvalidCachedResponse
-	}
-
-	if len(c.DumpedResponse) == 0 {
-		return ErrInvalidCachedResponse
-	}
-
-	if c.CachedTime.IsZero() {
-		return ErrInvalidCachedResponse
+	var expiryTime time.Duration
+	if len(duration) > 0 {
+		expiryTime = duration[0]
 	}
+	c := gotcha.New(
+		gotcha.NewOption().SetAlgorithm(inmemcache.LRUAlgorithm).
+			SetExpiryTime(expiryTime).SetMaxSizeItem(100),
+	)
 
+	newClient(client, inmem.NewCache(c))
 	return
 }