Ext cache (#236)

* remove cache, switch to go-pkgz/rest/cache * remove mongo cache from server test * remove old caching code * test tricky disqus inputs * fix migrator test * stacktrace dump test
2018-12-19 21:57:33 -06:00
parent bf716ac01f
commit 2ecc08fb3e
30 changed files with 313 additions and 931 deletions
@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
@@ -0,0 +1,20 @@
+Copyright (c) 2015-present Peter Kieltyka (https://github.com/pkieltyka), Google Inc.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,20 @@
+Copyright (c) 2016-Present https://github.com/go-chi authors
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,23 @@
+Copyright (c) 2015, Dave Cheney <dave@cheney.net>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -0,0 +1,27 @@
+Copyright (c) 2013, Patrick Mezard
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+    Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+    The names of its contributors may not be used to endorse or promote
+products derived from this software without specific prior written
+permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -0,0 +1,22 @@
+Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
+
+Please consider promoting this project if you find it useful.
+
+Permission is hereby granted, free of charge, to any person 
+obtaining a copy of this software and associated documentation 
+files (the "Software"), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, 
+publish, distribute, sublicense, and/or sell copies of the Software, 
+and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT 
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Umputun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -0,0 +1,43 @@
+
+## Cache wrapper for web applications. 
+
+The primary goal is to simplify caching of responses. 
+
+Adds guava-style loading cache and support of scopes for partial flushes. 
+Provides in-memory `NewMemoryCache` on top of [hashicorp/golang-lru]("https://github.com/hashicorp/golang-lru") and 
+defines basic interface for other implementations.
+
+In addition to `Get` and `Flush` methods, memory cache also support limits for a single value size, number of keys and total memory utilization. `PostFlushFn` adds ability to call a function on flush completion.
+
+## Install and update
+
+`go get -u github.com/go-pkgz/rest/cache`
+
+## Technical details
+
+- Cache keeps data in a simple key:value format. 
+- Key is a type, created with `Key(site_id)` where `site_id` represents independent bucket in the cache. For simple cases can be set to an empty string.
+- Particular key set by `Key.ID(string)`
+- Key may contain optional scopes (list of string). They not affect retrieval and used for partial (scoped) invalidation only.
+- Cache is safe for concurrent use.
+- Value is []byte.
+- `Get` method returns from the cache if the key already in. Overwise executes passed function and saves results.
+- Special fake implementation `cache.Nop` satisfies `LoadingCache` interface and can be used to disable any caching
+
+## Usage
+
+```golang
+    // create in-memory cache with max keys=50, total (max) size=2000 and max cached size of a record = 200
+    lc, err := cache.NewMemoryCache(cache.MaxKeys(50), cacheMaxCacheSize(2000), cache.MaxValSize(200)) 
+    if err != nil {
+        panic(err)
+    }
+    ...
+
+    // load cached value for key1. Call func if not cached yet or evicted
+    res, err = lc.Get(cache.NewKey("site1").ID("key1").Scopes("scope1"), func() ([]byte, error) {
+		return []byte("1234567890"), nil
+    }) 
+    
+    lc.Flush("scope1") // invalidate cache for scope1
+```
@@ -0,0 +1,98 @@
+package cache
+
+import (
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+// LoadingCache defines interface for caching
+type LoadingCache interface {
+	Get(key Key, fn func() ([]byte, error)) (data []byte, err error)
+	Flush(req FlusherRequest)
+}
+
+type cacheWithOpts interface {
+	LoadingCache
+	setMaxValSize(max int) error
+	setMaxKeys(max int) error
+	setMaxCacheSize(max int64) error
+	setPostFlushFn(postFlushFn func()) error
+}
+
+// Key for cache
+type Key struct {
+	id     string
+	siteID string
+	scopes []string
+}
+
+// NewKey makes keys for site
+func NewKey(site string) Key {
+	res := Key{siteID: site}
+	return res
+}
+
+// ID sets key id
+func (k Key) ID(id string) Key {
+	k.id = id
+	return k
+}
+
+// Scopes of the key
+func (k Key) Scopes(scopes ...string) Key {
+	k.scopes = scopes
+	return k
+}
+
+// Merge makes full string key from primary key and scopes
+func (k Key) Merge() string {
+	return strings.Join(k.scopes, "$$") + "@@" + k.id + "@@" + k.siteID
+}
+
+// ParseKey gets compound key created by Key func and split it to the actual key and scopes
+func ParseKey(fullKey string) (Key, error) {
+	elems := strings.Split(fullKey, "@@")
+	if len(elems) != 3 {
+		return Key{}, errors.Errorf("can't parse cache key %s", fullKey)
+	}
+	scopes := strings.Split(elems[0], "$$")
+	if len(scopes) == 1 && scopes[0] == "" {
+		scopes = []string{}
+	}
+	key := Key{
+		scopes: scopes,
+		id:     elems[1],
+		siteID: elems[2],
+	}
+	return key, nil
+}
+
+// FlusherRequest used as input for cache.Flush
+type FlusherRequest struct {
+	siteID string
+	scopes []string
+}
+
+// Flusher makes new FlusherRequest with empty scopes
+func Flusher(siteID string) FlusherRequest {
+	res := FlusherRequest{siteID: siteID}
+	return res
+}
+
+// Scopes adds scopes to FlusherRequest
+func (f FlusherRequest) Scopes(scopes ...string) FlusherRequest {
+	f.scopes = scopes
+	return f
+}
+
+// Nop does nothing for caching, passing fn call only
+type Nop struct{}
+
+// Get calls fn, no actual caching
+func (n *Nop) Get(key Key, fn func() ([]byte, error)) (data []byte, err error) {
+	return fn()
+}
+
+// Flush does nothing for NoopCache
+func (n *Nop) Flush(req FlusherRequest) {}
@@ -0,0 +1,146 @@
+package cache
+
+import (
+	"log"
+	"sync/atomic"
+
+	"github.com/hashicorp/golang-lru"
+	"github.com/pkg/errors"
+)
+
+// memoryCache implements LoadingCache interface on top of cache.Cache (go-cache)
+type memoryCache struct {
+	bytesCache   *lru.Cache
+	postFlushFn  func()
+	maxKeys      int
+	maxValueSize int
+	maxCacheSize int64
+	currentSize  int64
+}
+
+// NewMemoryCache makes memoryCache implementation
+func NewMemoryCache(options ...Option) (LoadingCache, error) {
+	log.Print("[INFO] make memory cache")
+
+	res := memoryCache{
+		postFlushFn:  func() {},
+		maxKeys:      1000,
+		maxValueSize: 0,
+	}
+	for _, opt := range options {
+		if err := opt(&res); err != nil {
+			return nil, errors.Wrap(err, "failed to set cache option")
+		}
+	}
+
+	onEvicted := func(key interface{}, value interface{}) {
+		size := len(value.([]byte))
+		atomic.AddInt64(&res.currentSize, -1*int64(size))
+	}
+
+	var err error
+	// OnEvicted called automatically for expired and manually deleted
+	if res.bytesCache, err = lru.NewWithEvict(res.maxKeys, onEvicted); err != nil {
+		return nil, errors.Wrap(err, "failed to make cache")
+	}
+
+	log.Printf("[DEBUG] create lru cache, maxKeys=%d, maxValueSize=%d, maxCacheSize=%d",
+		res.maxKeys, res.maxValueSize, res.maxCacheSize)
+	return &res, nil
+}
+
+// Get is loading cache method to get value by key or load via fn if not found
+func (m *memoryCache) Get(key Key, fn func() ([]byte, error)) (data []byte, err error) {
+	mkey := key.Merge()
+	if b, ok := m.bytesCache.Get(mkey); ok {
+		return b.([]byte), nil
+	}
+
+	if data, err = fn(); err != nil {
+		return data, err
+	}
+	if m.allowed(data) {
+		m.bytesCache.Add(mkey, data)
+		atomic.AddInt64(&m.currentSize, int64(len(data)))
+
+		if m.maxCacheSize > 0 && atomic.LoadInt64(&m.currentSize) > m.maxCacheSize {
+			for atomic.LoadInt64(&m.currentSize) > m.maxCacheSize {
+				m.bytesCache.RemoveOldest()
+			}
+		}
+	}
+	return data, nil
+}
+
+// Flush clears cache and calls postFlushFn async
+func (m *memoryCache) Flush(req FlusherRequest) {
+
+	if len(req.scopes) == 0 {
+		m.bytesCache.Purge()
+		go m.postFlushFn()
+		return
+	}
+
+	// check if fullKey has matching scopes
+	inScope := func(fullKey string) bool {
+		key, err := ParseKey(fullKey)
+		if err != nil {
+			return false
+		}
+		for _, s := range req.scopes {
+			for _, ks := range key.scopes {
+				if ks == s {
+					return true
+				}
+			}
+		}
+		return false
+	}
+
+	for _, k := range m.bytesCache.Keys() {
+		key := k.(string)
+		if inScope(key) {
+			m.bytesCache.Remove(key) // Keys() returns copy of cache's key, safe to remove directly
+		}
+	}
+
+	if m.postFlushFn != nil {
+		go m.postFlushFn()
+	}
+}
+
+func (m *memoryCache) allowed(data []byte) bool {
+	if m.maxValueSize > 0 && len(data) >= m.maxValueSize {
+		return false
+	}
+	return true
+}
+
+func (m *memoryCache) setMaxValSize(max int) error {
+	m.maxValueSize = max
+	if max <= 0 {
+		return errors.Errorf("negative size for MaxValSize, %d", max)
+	}
+	return nil
+}
+
+func (m *memoryCache) setMaxKeys(max int) error {
+	m.maxKeys = max
+	if max <= 0 {
+		return errors.Errorf("negative size for MaxKeys, %d", max)
+	}
+	return nil
+}
+
+func (m *memoryCache) setMaxCacheSize(max int64) error {
+	m.maxCacheSize = max
+	if max <= 0 {
+		return errors.Errorf("negative size or MaxCacheSize, %d", max)
+	}
+	return nil
+}
+
+func (m *memoryCache) setPostFlushFn(postFlushFn func()) error {
+	m.postFlushFn = postFlushFn
+	return nil
+}
@@ -0,0 +1,35 @@
+package cache
+
+// Option func type
+type Option func(lc cacheWithOpts) error
+
+// MaxValSize functional option defines the largest value's size allowed to be cached
+// By default it is 0, which means unlimited.
+func MaxValSize(max int) Option {
+	return func(lc cacheWithOpts) error {
+		return lc.setMaxValSize(max)
+	}
+}
+
+// MaxKeys functional option defines how many keys to keep.
+// By default it is 0, which means unlimited.
+func MaxKeys(max int) Option {
+	return func(lc cacheWithOpts) error {
+		return lc.setMaxKeys(max)
+	}
+}
+
+// MaxCacheSize functional option defines the total size of cached data.
+// By default it is 0, which means unlimited.
+func MaxCacheSize(max int64) Option {
+	return func(lc cacheWithOpts) error {
+		return lc.setMaxCacheSize(max)
+	}
+}
+
+// PostFlushFn functional option defines how callback function called after each Flush.
+func PostFlushFn(postFlushFn func()) Option {
+	return func(lc cacheWithOpts) error {
+		return lc.setPostFlushFn(postFlushFn)
+	}
+}