From 0b94ee1d89efcbc4179345886b51a83ef5088370 Mon Sep 17 00:00:00 2001 From: Umputun Date: Thu, 31 May 2018 21:28:40 -0500 Subject: [PATCH] remove legacy duration param --- app/rest/api/rest.go | 12 ++++++------ app/rest/api/rest_test.go | 2 +- app/rest/api/rss.go | 4 ++-- app/rest/cache/cache.go | 5 ++--- app/rest/cache/cache_test.go | 36 ++++++++++++++++++------------------ 5 files changed, 29 insertions(+), 30 deletions(-) diff --git a/app/rest/api/rest.go b/app/rest/api/rest.go index cbc878ad..fae7a95f 100644 --- a/app/rest/api/rest.go +++ b/app/rest/api/rest.go @@ -262,7 +262,7 @@ func (s *Rest) previewCommentCtrl(w http.ResponseWriter, r *http.Request) { func (s *Rest) infoCtrl(w http.ResponseWriter, r *http.Request) { locator := store.Locator{SiteID: r.URL.Query().Get("site"), URL: r.URL.Query().Get("url")} - data, err := s.Cache.Get(cache.Key(cache.URLKey(r), locator.SiteID, locator.URL), 4*time.Hour, func() ([]byte, error) { + data, err := s.Cache.Get(cache.Key(cache.URLKey(r), locator.SiteID, locator.URL), func() ([]byte, error) { info, e := s.DataService.Info(locator, s.ReadOnlyAge) if e != nil { return nil, e @@ -340,7 +340,7 @@ func (s *Rest) findCommentsCtrl(w http.ResponseWriter, r *http.Request) { } log.Printf("[DEBUG] get comments for %+v, sort %s, format %s", locator, sort, r.URL.Query().Get("format")) - data, err := s.Cache.Get(cache.Key(cache.URLKey(r), locator.SiteID, locator.URL), 4*time.Hour, func() ([]byte, error) { + data, err := s.Cache.Get(cache.Key(cache.URLKey(r), locator.SiteID, locator.URL), func() ([]byte, error) { comments, e := s.DataService.Find(locator, sort) if e != nil { return nil, e @@ -377,7 +377,7 @@ func (s *Rest) lastCommentsCtrl(w http.ResponseWriter, r *http.Request) { limit = 0 } - data, err := s.Cache.Get(cache.Key(cache.URLKey(r), "last", siteID), 4*time.Hour, func() ([]byte, error) { + data, err := s.Cache.Get(cache.Key(cache.URLKey(r), "last", siteID), func() ([]byte, error) { comments, e := s.DataService.Last(siteID, limit) if e != nil { return nil, e @@ -440,7 +440,7 @@ func (s *Rest) findUserCommentsCtrl(w http.ResponseWriter, r *http.Request) { log.Printf("[DEBUG] get comments for userID %s, %s", userID, siteID) - data, err := s.Cache.Get(cache.Key(cache.URLKey(r), userID, siteID), 4*time.Hour, func() ([]byte, error) { + data, err := s.Cache.Get(cache.Key(cache.URLKey(r), userID, siteID), func() ([]byte, error) { comments, count, e := s.DataService.User(siteID, userID, limit) if e != nil { return nil, e @@ -531,7 +531,7 @@ func (s *Rest) countMultiCtrl(w http.ResponseWriter, r *http.Request) { } sha := base64.URLEncoding.EncodeToString(hasher.Sum(nil)) - data, err := s.Cache.Get(cache.Key(sha, siteID), 8*time.Hour, func() ([]byte, error) { + data, err := s.Cache.Get(cache.Key(sha, siteID), func() ([]byte, error) { counts, e := s.DataService.Counts(siteID, posts) if e != nil { return nil, e @@ -559,7 +559,7 @@ func (s *Rest) listCtrl(w http.ResponseWriter, r *http.Request) { skip = v } - data, err := s.Cache.Get(cache.Key(cache.URLKey(r), siteID), 8*time.Hour, func() ([]byte, error) { + data, err := s.Cache.Get(cache.Key(cache.URLKey(r), siteID), func() ([]byte, error) { posts, e := s.DataService.List(siteID, limit, skip) if e != nil { return nil, e diff --git a/app/rest/api/rest_test.go b/app/rest/api/rest_test.go index 224f1c16..34ec3ce5 100644 --- a/app/rest/api/rest_test.go +++ b/app/rest/api/rest_test.go @@ -772,7 +772,7 @@ func cleanup(ts *httptest.Server) { type mockCache struct{} -func (mc *mockCache) Get(key string, ttl time.Duration, fn func() ([]byte, error)) (data []byte, err error) { +func (mc *mockCache) Get(key string, fn func() ([]byte, error)) (data []byte, err error) { return fn() } diff --git a/app/rest/api/rss.go b/app/rest/api/rss.go index 71c594aa..7ea5fd77 100644 --- a/app/rest/api/rss.go +++ b/app/rest/api/rss.go @@ -32,7 +32,7 @@ func (s *Rest) rssPostCommentsCtrl(w http.ResponseWriter, r *http.Request) { sort := "-time" log.Printf("[DEBUG] get rss for post %+v", locator) - data, err := s.Cache.Get(cache.Key(cache.URLKey(r), locator.SiteID, locator.URL), 4*time.Hour, func() ([]byte, error) { + data, err := s.Cache.Get(cache.Key(cache.URLKey(r), locator.SiteID, locator.URL), func() ([]byte, error) { comments, e := s.DataService.Find(locator, sort) if e != nil { return nil, e @@ -63,7 +63,7 @@ func (s *Rest) rssSiteCommentsCtrl(w http.ResponseWriter, r *http.Request) { siteID := r.URL.Query().Get("site") log.Printf("[DEBUG] get rss for site %s", siteID) - data, err := s.Cache.Get(cache.Key(cache.URLKey(r), siteID, "last"), 4*time.Hour, func() ([]byte, error) { + data, err := s.Cache.Get(cache.Key(cache.URLKey(r), siteID, "last"), func() ([]byte, error) { comments, e := s.DataService.Last(siteID, maxRssItems) if e != nil { return nil, e diff --git a/app/rest/cache/cache.go b/app/rest/cache/cache.go index 73bb43c5..82cf2412 100644 --- a/app/rest/cache/cache.go +++ b/app/rest/cache/cache.go @@ -3,7 +3,6 @@ package cache import ( "log" "strings" - "time" "github.com/hashicorp/golang-lru" "github.com/pkg/errors" @@ -11,7 +10,7 @@ import ( // LoadingCache defines interface for caching type LoadingCache interface { - Get(key string, ttl time.Duration, fn func() ([]byte, error)) (data []byte, err error) + Get(key string, fn func() ([]byte, error)) (data []byte, err error) Flush(scopes ...string) } @@ -62,7 +61,7 @@ func NewLoadingCache(options ...Option) LoadingCache { } // Get is loading cache method to get value by key or load via fn if not found -func (lc *loadingCache) Get(key string, ttl time.Duration, fn func() ([]byte, error)) (data []byte, err error) { +func (lc *loadingCache) Get(key string, fn func() ([]byte, error)) (data []byte, err error) { if b, ok := lc.bytesCache.Get(key); ok { return b.([]byte), nil } diff --git a/app/rest/cache/cache_test.go b/app/rest/cache/cache_test.go index 14a7c2a3..f87b239c 100644 --- a/app/rest/cache/cache_test.go +++ b/app/rest/cache/cache_test.go @@ -19,7 +19,7 @@ func TestLoadingCache_Get(t *testing.T) { var postFnCall, coldCalls int32 lc := NewLoadingCache(PostFlushFn(func() { atomic.AddInt32(&postFnCall, 1) })) - res, err := lc.Get("key", time.Minute, func() ([]byte, error) { + res, err := lc.Get("key", func() ([]byte, error) { atomic.AddInt32(&coldCalls, 1) return []byte("result"), nil }) @@ -28,7 +28,7 @@ func TestLoadingCache_Get(t *testing.T) { assert.Equal(t, int32(1), atomic.LoadInt32(&coldCalls)) assert.Equal(t, int32(0), atomic.LoadInt32(&postFnCall)) - res, err = lc.Get("key", time.Minute, func() ([]byte, error) { + res, err = lc.Get("key", func() ([]byte, error) { atomic.AddInt32(&coldCalls, 1) return []byte("result"), nil }) @@ -49,7 +49,7 @@ func TestLoadingCache_MaxKeys(t *testing.T) { // put 5 keys to cache for i := 0; i < 5; i++ { - res, err := lc.Get(fmt.Sprintf("key-%d", i), 500*time.Millisecond, func() ([]byte, error) { + res, err := lc.Get(fmt.Sprintf("key-%d", i), func() ([]byte, error) { atomic.AddInt32(&coldCalls, 1) return []byte(fmt.Sprintf("result-%d", i)), nil }) @@ -60,14 +60,14 @@ func TestLoadingCache_MaxKeys(t *testing.T) { } // check if really cached - res, err := lc.Get("key-3", time.Minute, func() ([]byte, error) { + res, err := lc.Get("key-3", func() ([]byte, error) { return []byte("result-blah"), nil }) assert.Nil(t, err) assert.Equal(t, "result-3", string(res), "should be cached") // try to cache after maxKeys reached - res, err = lc.Get("key-X", time.Minute, func() ([]byte, error) { + res, err = lc.Get("key-X", func() ([]byte, error) { return []byte("result-X"), nil }) assert.Nil(t, err) @@ -76,13 +76,13 @@ func TestLoadingCache_MaxKeys(t *testing.T) { assert.Equal(t, 5, lc.(*loadingCache).bytesCache.Len()) // put to cache and make sure it cached - res, err = lc.Get("key-Z", time.Minute, func() ([]byte, error) { + res, err = lc.Get("key-Z", func() ([]byte, error) { return []byte("result-Z"), nil }) assert.Nil(t, err) assert.Equal(t, "result-Z", string(res)) - res, err = lc.Get("key-Z", time.Minute, func() ([]byte, error) { + res, err = lc.Get("key-Z", func() ([]byte, error) { return []byte("result-Zzzz"), nil }) assert.Nil(t, err) @@ -94,26 +94,26 @@ func TestLoadingCache_MaxSize(t *testing.T) { lc := NewLoadingCache(MaxKeys(5), MaxValSize(10)) // put good size value to cache and make sure it cached - res, err := lc.Get("key-Z", time.Minute, func() ([]byte, error) { + res, err := lc.Get("key-Z", func() ([]byte, error) { return []byte("result-Z"), nil }) assert.Nil(t, err) assert.Equal(t, "result-Z", string(res)) - res, err = lc.Get("key-Z", time.Minute, func() ([]byte, error) { + res, err = lc.Get("key-Z", func() ([]byte, error) { return []byte("result-Zzzz"), nil }) assert.Nil(t, err) assert.Equal(t, "result-Z", string(res), "got cached value") // put too big value to cache and make sure it is not cached - res, err = lc.Get("key-Big", time.Minute, func() ([]byte, error) { + res, err = lc.Get("key-Big", func() ([]byte, error) { return []byte("1234567890"), nil }) assert.Nil(t, err) assert.Equal(t, "1234567890", string(res)) - res, err = lc.Get("key-Big", time.Minute, func() ([]byte, error) { + res, err = lc.Get("key-Big", func() ([]byte, error) { return []byte("result-big"), nil }) assert.Nil(t, err) @@ -142,7 +142,7 @@ func TestLoadingCache_Parallel(t *testing.T) { var coldCalls int32 lc := NewLoadingCache() - res, err := lc.Get("key", time.Minute, func() ([]byte, error) { + res, err := lc.Get("key", func() ([]byte, error) { return []byte("value"), nil }) assert.Nil(t, err) @@ -154,7 +154,7 @@ func TestLoadingCache_Parallel(t *testing.T) { i := i go func() { defer wg.Done() - res, err := lc.Get("key", time.Minute, func() ([]byte, error) { + res, err := lc.Get("key", func() ([]byte, error) { atomic.AddInt32(&coldCalls, 1) return []byte(fmt.Sprintf("result-%d", i)), nil }) @@ -169,13 +169,13 @@ func TestLoadingCache_Parallel(t *testing.T) { func TestLoadingCache_Scopes(t *testing.T) { lc := NewLoadingCache() - res, err := lc.Get(Key("key", "s1", "s2"), time.Minute, func() ([]byte, error) { + res, err := lc.Get(Key("key", "s1", "s2"), func() ([]byte, error) { return []byte("value"), nil }) assert.Nil(t, err) assert.Equal(t, "value", string(res)) - res, err = lc.Get(Key("key2", "s2"), time.Minute, func() ([]byte, error) { + res, err = lc.Get(Key("key2", "s2"), func() ([]byte, error) { return []byte("value2"), nil }) assert.Nil(t, err) @@ -185,12 +185,12 @@ func TestLoadingCache_Scopes(t *testing.T) { lc.Flush("s1") assert.Equal(t, 1, lc.(*loadingCache).bytesCache.Len()) - lc.Get(Key("key2", "s2"), time.Minute, func() ([]byte, error) { + lc.Get(Key("key2", "s2"), func() ([]byte, error) { assert.Fail(t, "should stay") return nil, nil }) - res, err = lc.Get(Key("key", "s1", "s2"), time.Minute, func() ([]byte, error) { + res, err = lc.Get(Key("key", "s1", "s2"), func() ([]byte, error) { return []byte("value-upd"), nil }) assert.Equal(t, "value-upd", string(res), "was deleted, update") @@ -200,7 +200,7 @@ func TestLoadingCache_Flush(t *testing.T) { lc := NewLoadingCache() addToCache := func(key string, scopes ...string) { - res, err := lc.Get(key, time.Minute, func() ([]byte, error) { + res, err := lc.Get(key, func() ([]byte, error) { return []byte("value" + key), nil }) require.Nil(t, err)