init commit

Author: denghejun

.idea/.gitignore

@@ -1 +1,75 @@
-# go-cache
+# Usage
+
+## What
+
+This repo is a wrapper with [go-cache](https://github.com/patrickmn/go-cache). We use `gocache.GetOrSet` to set or get
+cache safely. It means that when multiple threads/go-routing call `gocache.GetOrSet`, the cache will be set only once.
+Usually it means we just call database to retrieve data ONLY one time.
+
+#### Install
+
+```
+go get -u 
+```
+
+#### STEP 1: Register all your cache keys
+
+```go
+package example
+
+import gocache "go-cache/core"
+
+const (
+	KeyOrders  = "KEY_ORDERS"
+	KeyUsers   = "KEY_USERS"
+	KeyBooks   = "KEY_BOOKS"
+	KeyModules = "KEY_MODULES"
+	KeyConfig  = "KEY_CONFIG"
+)
+
+func RegisterAllCacheKeys() {
+	registry := gocache.GetRegistryInstance()
+	registry.Register(&gocache.CacheKey{Key: KeyOrders, Expire: gocache.OneDay})
+	registry.Register(&gocache.CacheKey{Key: KeyUsers, Expire: gocache.OneMinute})
+	registry.Register(&gocache.CacheKey{Key: KeyBooks, Expire: gocache.OneHour})
+	registry.Register(&gocache.CacheKey{Key: KeyModules, Expire: gocache.FiveMinutes})
+	registry.Register(&gocache.CacheKey{Key: KeyConfig, Expire: gocache.OneMinute})
+}
+
+```
+
+#### STEP 2: Use `gocache.GetOrSet` to get or set cache thread safely.
+
+```go
+package example
+
+import (
+	gocache "go-cache/core"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type Book struct {
+	name string
+}
+
+func StartApp() {
+	RegisterAllCacheKeys()
+	books, ok := gocache.GetOrSet(KeyBooks, func(cache *gocache.CacheKey) (interface{}, error) {
+		// you also can call database to retrieve cache here.
+		return []Book{
+			{name: "i love coding"},
+			{name: "coding is great"},
+		}, nil
+	})
+
+	if ok {
+		log.Info("Got books and also set cache.")
+		log.Info(books)
+	} else {
+		log.Info("No books found in cache also in database maybe")
+	}
+}
+```
+
+example refer to `./example`

.idea/go-cache.iml

@@ -0,0 +1,12 @@
+package gocache
+
+import "time"
+
+const (
+	OneDay                      = 24 * time.Hour
+	OneHour                     = 1 * time.Hour
+	OneMinute                   = 1 * time.Minute
+	FiveMinutes                 = 5 * time.Minute
+	defaultCacheExpiration      = OneDay
+	defaultCacheCleanupInterval = OneHour
+)

.idea/modules.xml

@@ -0,0 +1,50 @@
+package gocache
+
+import (
+	"sync"
+
+	"github.com/patrickmn/go-cache"
+	log "github.com/sirupsen/logrus"
+)
+
+var cacheInstance *cache.Cache
+var onceCreateCacheInstance sync.Once
+
+func GetInstance() *cache.Cache {
+	onceCreateCacheInstance.Do(func() {
+		cacheInstance = cache.New(defaultCacheExpiration, defaultCacheCleanupInterval)
+	})
+
+	return cacheInstance
+}
+
+type CallbackIfCacheMissing func(cache *CacheKey) (interface{}, error)
+
+func GetOrSet(key string, callback CallbackIfCacheMissing) (interface{}, bool) {
+	keyRegistry := GetRegistryInstance()
+	cacheInstance := GetInstance()
+	cache := keyRegistry.Get(key)
+	if cache == nil {
+		log.Panicf("Cache key %v not found in registry, you need to Register it first", key)
+		return nil, false
+	}
+
+	_, ok := cacheInstance.Get(cache.Key)
+	if !ok { // if cache missing, set cache thread safely
+		cache.Sync.Lock()
+		defer cache.Sync.Unlock()
+		_, okAgain := cacheInstance.Get(cache.Key)
+		if !okAgain {
+			log.Infof("Cache missing for %s, setting cache with callback ...", cache.Key)
+			value, err := callback(cache)
+			if err == nil {
+				log.Infof("Set cache for %s successfully", cache.Key)
+				cacheInstance.Set(cache.Key, value, cache.Expire)
+			} else {
+				log.Errorf("Set cache for %s failed: %v", cache.Key, err)
+			}
+		}
+	}
+
+	return cacheInstance.Get(cache.Key)
+}

.idea/vcs.xml

@@ -0,0 +1,8 @@
+package gocache_test
+
+import "testing"
+
+func TestInstance_UsageExample(t *testing.T) {
+	t.Parallel()
+
+}

README.md

@@ -0,0 +1,18 @@
+package gocache
+
+import (
+	"sync"
+	"time"
+
+	"github.com/patrickmn/go-cache"
+)
+
+type CacheKey struct {
+	Key    string
+	Sync   sync.Mutex
+	Expire time.Duration
+}
+
+var (
+	Default = &CacheKey{Key: "__DEFAULT_KEY__", Expire: cache.DefaultExpiration}
+)

core/consts.go

@@ -0,0 +1,38 @@
+package gocache
+
+import (
+	"sync"
+)
+
+type Registry interface {
+	Register(key *CacheKey)
+	Get(key string) *CacheKey
+}
+
+type RegistryImpl struct {
+	keymap sync.Map
+}
+
+func (r *RegistryImpl) Get(key string) *CacheKey {
+	value, ok := r.keymap.Load(key)
+	if ok {
+		return value.(*CacheKey)
+	} else {
+		return nil
+	}
+}
+
+func (r *RegistryImpl) Register(cacheKey *CacheKey) {
+	r.keymap.Store(cacheKey.Key, cacheKey)
+}
+
+var onceCreateRegistry sync.Once
+var registryInstance Registry
+
+func GetRegistryInstance() Registry {
+	onceCreateRegistry.Do(func() {
+		registryInstance = &RegistryImpl{}
+	})
+
+	return registryInstance
+}