Merge pull request #2 from enverbisevac/main

Code refactored to use linters, sec, vet and other go tools

Author: rushabh-harness

.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI workflow
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.16.2
+
+    - name: Check
+      run: make check
+
+    - name: Test
+      run: make test

.gitignore

@@ -0,0 +1 @@
+.idea

Makefile

@@ -32,6 +32,8 @@ format:
 	@echo "Checking that go fmt does not make any changes..."
 	@test -z $$(go fmt $(go list ./...)) || (echo "go fmt would make a change. Please verify and commit the proposed changes"; exit 1)
 	@echo "Checking go fmt complete"
+	@echo "Running goimports"
+	@test -z $$(goimports -w ./..) || (echo "goimports would make a change. Please verify and commit the proposed changes"; exit 1)
 
 PHONY+= lint
 lint: $(GOPATH)/bin/golangci-lint $(GOPATH)/bin/golint
@@ -43,10 +45,8 @@ lint: $(GOPATH)/bin/golangci-lint $(GOPATH)/bin/golint
 		-E bodyclose \
 		-E exhaustive \
 		-E exportloopref \
-		-E gci \
 		-E gofmt \
 		-E goimports \
-		-E goimports \
 		-E gosec \
 		-E noctx \
 		-E nolintlint \
@@ -75,21 +75,27 @@ $(GOPATH)/bin/golint:
 	@echo "🔘 Installing golint ... (`date '+%H:%M:%S'`)"
 	@GO111MODULE=off go get -u golang.org/x/lint/golint
 
+$(GOPATH)/bin/goimports:
+	@echo "🔘 Installing goimports ... (`date '+%H:%M:%S'`)"
+	@GO111MODULE=off go get -u golang.org/x/tools/cmd/goimports
+
 $(GOPATH)/bin/gosec:
 	@echo "🔘 Installing gosec ... (`date '+%H:%M:%S'`)"
 	@curl -sfL https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh -s -- -b $(GOPATH)/bin
 
 
 PHONY+= tools
-tools: $(GOPATH)/bin/golangci-lint $(GOPATH)/bin/golint $(GOPATH)/bin/gosec
+tools: $(GOPATH)/bin/golangci-lint $(GOPATH)/bin/golint $(GOPATH)/bin/gosec $(GOPATH)/bin/goimports
 
 PHONY+= update-tools
-update-tools: delete-tools $(GOPATH)/bin/golangci-lint $(GOPATH)/bin/golint $(GOPATH)/bin/gosec
+update-tools: delete-tools $(GOPATH)/bin/golangci-lint $(GOPATH)/bin/golint $(GOPATH)/bin/gosec $(GOPATH)/bin/goimports
 
 PHONY+= delete-tools
 delete-tools:
 	@rm $(GOPATH)/bin/golangci-lint
 	@rm $(GOPATH)/bin/gosec
 	@rm $(GOPATH)/bin/golint
+	@rm $(GOPATH)/bin/goimports
+
 
 .PHONY: all tidy generate build clean test lint

cache/cache.go

@@ -1,23 +1,20 @@
 package cache
 
 import (
-	"github.com/drone/ff-golang-server-sdk/logger"
+	"github.com/drone/ff-golang-server-sdk.v1/logger"
+
 	"time"
 )
 
+// Cache wrapper to integrate any 3rd party implementation
 type Cache interface {
 	Set(key, value interface{}) (evicted bool)
 	Contains(key interface{}) bool
-	ContainsOrAdd(key, value interface{}) (ok, evicted bool)
 	Get(key interface{}) (value interface{}, ok bool)
-	GetOldest() (key, value interface{}, ok bool)
 	Keys() []interface{}
 	Len() int
-	Peek(key interface{}) (value interface{}, ok bool)
-	PeekOrAdd(key, value interface{}) (previous interface{}, ok, evicted bool)
 	Purge()
 	Remove(key interface{}) (present bool)
-	RemoveOldest() (key, value interface{}, ok bool)
 	Resize(size int) (evicted int)
 	Updated() time.Time
 	SetLogger(logger logger.Logger)

cache/lru.go

@@ -1,113 +1,98 @@
 package cache
 
 import (
-	"github.com/drone/ff-golang-server-sdk/logger"
+	"github.com/drone/ff-golang-server-sdk.v1/logger"
 	lru "github.com/hashicorp/golang-lru"
+
 	"reflect"
 	"time"
 )
 
-type lruCache struct {
+// LRUCache is thread-safe LAST READ USED Cache
+type LRUCache struct {
 	*lru.Cache
 	logger     logger.Logger
 	lastUpdate time.Time
 }
 
-func NewLruCache(size int, logger logger.Logger) (*lruCache, error) {
+//NewLruCache creates a new LRU instance
+func NewLruCache(size int, logger logger.Logger) (*LRUCache, error) {
 	cache, err := lru.New(size)
 	if err != nil {
 		logger.Errorf("Error initializing LRU cache, err: %v", err)
 		return nil, err
 	}
 	logger.Infof("Cache successfully initialized with size: %d", size)
-	return &lruCache{
+	return &LRUCache{
 		Cache:  cache,
 		logger: logger,
 	}, nil
 }
 
-func (lru *lruCache) getTime() time.Time {
+func (lru *LRUCache) getTime() time.Time {
 	return time.Now()
 }
 
-func (lru *lruCache) Set(key interface{}, value interface{}) (evicted bool) {
+// Set a new value if it is different from the previous one.
+// Returns true if an eviction occurred.
+func (lru *LRUCache) Set(key interface{}, value interface{}) (evicted bool) {
 	prev, _ := lru.Get(key)
 	if !reflect.DeepEqual(prev, value) {
 		add := lru.Cache.Add(key, value)
 		lru.lastUpdate = lru.getTime()
-		lru.logger.Infof("cache value changed for key %s with value %v", key, value)
+		lru.logger.Debugf("cache value changed for key %s with value %v", key, value)
 		return add
 	}
 	return false
 }
 
-func (lru *lruCache) Contains(key interface{}) bool {
+// Contains checks if a key is in the cache
+func (lru *LRUCache) Contains(key interface{}) bool {
 	return lru.Cache.Contains(key)
 }
 
-func (lru *lruCache) ContainsOrAdd(key interface{}, value interface{}) (ok bool, evicted bool) {
-	ok, evicted = lru.Cache.ContainsOrAdd(key, value)
-	lru.lastUpdate = lru.getTime()
-	return
-}
-
-func (lru *lruCache) Get(key interface{}) (value interface{}, ok bool) {
+// Get looks up a key's value from the cache.
+func (lru *LRUCache) Get(key interface{}) (value interface{}, ok bool) {
 	return lru.Cache.Get(key)
 }
 
-func (lru *lruCache) GetOldest() (key interface{}, value interface{}, ok bool) {
-	return lru.Cache.GetOldest()
-}
-
-func (lru *lruCache) Keys() []interface{} {
+// Keys returns a slice of the keys in the cache, from oldest to newest.
+func (lru *LRUCache) Keys() []interface{} {
 	return lru.Cache.Keys()
 }
 
-func (lru *lruCache) Len() int {
+// Len returns the number of items in the cache.
+func (lru *LRUCache) Len() int {
 	return lru.Cache.Len()
 }
 
-func (lru *lruCache) Peek(key interface{}) (value interface{}, ok bool) {
-	return lru.Cache.Peek(key)
-}
-
-func (lru *lruCache) PeekOrAdd(key interface{}, value interface{}) (previous interface{}, ok bool, evicted bool) {
-	previous, ok, evicted = lru.Cache.PeekOrAdd(key, value)
-	lru.lastUpdate = lru.getTime()
-	return
-}
-
-func (lru *lruCache) Purge() {
+// Purge is used to completely clear the cache.
+func (lru *LRUCache) Purge() {
 	lru.Cache.Purge()
 	lru.lastUpdate = lru.getTime()
 }
 
-func (lru *lruCache) Remove(key interface{}) (present bool) {
+// Remove removes the provided key from the cache.
+func (lru *LRUCache) Remove(key interface{}) (present bool) {
 	present = lru.Cache.Remove(key)
 	lru.lastUpdate = lru.getTime()
 	if present {
-		lru.logger.Infof("Cache item successfully removed %v", key)
-	}
-	return
-}
-
-func (lru *lruCache) RemoveOldest() (key interface{}, value interface{}, ok bool) {
-	key, value, ok = lru.Cache.RemoveOldest()
-	lru.lastUpdate = lru.getTime()
-	if ok {
-		lru.logger.Infof("Cache oldest item successfully removed %v with value %v", key, value)
+		lru.logger.Debugf("Cache item successfully removed %v", key)
 	}
 	return
 }
 
-func (lru *lruCache) Resize(size int) (evicted int) {
+// Resize changes the cache size.
+func (lru *LRUCache) Resize(size int) (evicted int) {
 	return lru.Cache.Resize(size)
 }
 
-func (lru *lruCache) Updated() time.Time {
+// Updated lastUpdate information
+func (lru *LRUCache) Updated() time.Time {
 	return lru.lastUpdate
 }
 
-func (lru lruCache) SetLogger(logger logger.Logger) {
+// SetLogger set logger
+func (lru LRUCache) SetLogger(logger logger.Logger) {
 	lru.logger = logger
 }

cache/persist.go

@@ -1,23 +1,27 @@
 package cache
 
 import (
-	"github.com/drone/ff-golang-server-sdk/dto"
-	"github.com/drone/ff-golang-server-sdk/evaluation"
-	"github.com/drone/ff-golang-server-sdk/logger"
-	"github.com/drone/ff-golang-server-sdk/storage"
+	"github.com/drone/ff-golang-server-sdk.v1/dto"
+	"github.com/drone/ff-golang-server-sdk.v1/evaluation"
+	"github.com/drone/ff-golang-server-sdk.v1/logger"
+	"github.com/drone/ff-golang-server-sdk.v1/storage"
 	"github.com/mitchellh/mapstructure"
 )
 
+// Persistence persist cache data to a storage
 type Persistence struct {
 	store  storage.Storage
 	cache  Cache
 	logger logger.Logger
 }
 
+// NewPersistence creates a new instance for persisting data
 func NewPersistence(store storage.Storage, cache Cache, logger logger.Logger) Persistence {
 	return Persistence{store: store, cache: cache, logger: logger}
 }
 
+// SaveToStore saves data to declared storage only if last update
+// is greater than persisted time
 func (p Persistence) SaveToStore() error {
 	if p.cache.Updated().Before(p.store.PersistedAt()) {
 		return nil
@@ -39,7 +43,9 @@ func (p Persistence) SaveToStore() error {
 	}
 
 	for key, val := range temp {
-		p.store.Set(key, val)
+		if err := p.store.Set(key, val); err != nil {
+			p.logger.Debugf("error while storing data, err: %v", err)
+		}
 	}
 	err := p.store.Persist()
 	if err != nil {
@@ -48,6 +54,7 @@ func (p Persistence) SaveToStore() error {
 	return nil
 }
 
+// LoadFromStore loads all stored data into specified cache
 func (p *Persistence) LoadFromStore() error {
 	p.logger.Info("Loading cache data from store")
 	err := p.store.Load()