Add new persistant backend

api/service.go

@@ -20,12 +20,12 @@ type Service interface {
 
 type service struct {
 	l                 log.Logger
-	storageRepository *store.MemRepo
-	pluginRepository  *plugin.MemRepo
+	storageRepository store.StorageRepository
+	pluginRepository  plugin.Repository
 }
 
 // NewService initializes a new API service
-func NewService(l log.Logger, sr *store.MemRepo, pr *plugin.MemRepo) *service {
+func NewService(l log.Logger, sr store.StorageRepository, pr plugin.Repository) *service {
 	return &service{
 		l:                 l,
 		storageRepository: sr,

main.go

@@ -23,13 +23,13 @@ import (
 	"github.com/go-chi/chi"
 	"github.com/go-kit/kit/log"
 	"github.com/go-kit/kit/log/level"
-	cache "github.com/patrickmn/go-cache"
 )
 
 var config struct {
 	RefreshInterval   int    `env:"REFRESH_INTERVAL" envDefault:"15"`
 	CacheExpiration   int    `env:"CACHE_EXPIRATION" envDefault:"30"`
 	CacheExpiredPurge int    `env:"CACHE_EXPIRED_PURGE" envDefault:"60"`
+	StorageBackend    string `env:"STORAGE_BACKEND" envDefault:"memory"`
 	Environment       string `env:"ENVIRONMENT" envDefault:"develop"`
 	Port              int    `env:"PORT" envDefault:"8080"`
 }
@@ -49,10 +49,20 @@ func main() {
 	}
 	l = log.With(l, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller)
 
-	cache := cache.New(time.Duration(config.CacheExpiration)*time.Minute, time.Duration(config.CacheExpiredPurge)*time.Minute)
-	storageRepo, err := store.NewMemRepository(cache)
-	if err != nil {
-		return
+	var storageRepo store.StorageRepository
+	switch config.StorageBackend {
+	case "memory":
+		memory, err := store.NewMemRepository(config.CacheExpiration, config.CacheExpiredPurge)
+		if err != nil {
+			return
+		}
+		storageRepo = memory
+	case "persistant":
+		disk, err := store.NewDiskRepository("feedbridge-cache")
+		if err != nil {
+			return
+		}
+		storageRepo = disk
 	}
 
 	t := &http.Transport{

runner/runner.go

@@ -21,14 +21,14 @@ import (
 type Runner struct {
 	l                    log.Logger
 	Client               *http.Client
-	PluginRepository     *plugin.MemRepo
-	StorageRepository    *store.MemRepo
+	PluginRepository     plugin.Repository
+	StorageRepository    store.StorageRepository
 	CheckIntervalMinutes int
 	ticker               *time.Ticker
 }
 
 // NewRunner initializes a new runner to run plugins
-func NewRunner(l log.Logger, pluginRepo *plugin.MemRepo, storageRepo *store.MemRepo, checkIntervalMinutes int) *Runner {
+func NewRunner(l log.Logger, pluginRepo plugin.Repository, storageRepo store.StorageRepository, checkIntervalMinutes int) *Runner {
 	return &Runner{
 		l:                    l,
 		PluginRepository:     pluginRepo,

store/disk_repository.go

@@ -0,0 +1,41 @@
+package store
+
+import (
+	"fmt"
+
+	"github.com/peterbourgon/diskv"
+)
+
+// DiskRepo holds a representation of a persistant store backend
+type DiskRepo struct {
+	d *diskv.Diskv
+}
+
+// NewDiskRepository returns a newly persistant store repository
+func NewDiskRepository(path string) (*DiskRepo, error) {
+	d := diskv.New(diskv.Options{
+		BasePath:     path,
+		CacheSizeMax: 1024 * 1024,
+	})
+
+	return &DiskRepo{
+		d: d,
+	}, nil
+}
+
+// Save stores a new value for a key in the k/v store
+func (r *DiskRepo) Save(key string, value string) error {
+	if err := r.d.Write(key, []byte(value)); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Get retrieves a value from the k/v store
+func (r *DiskRepo) Get(key string) (string, error) {
+	value, err := r.d.Read(key)
+	if err != nil {
+		return "", fmt.Errorf("no value found for key '%s', err: %s", key, err)
+	}
+	return string(value), nil
+}

store/mem_repository.go

@@ -2,6 +2,7 @@ package store
 
 import (
 	"fmt"
+	"time"
 
 	cache "github.com/patrickmn/go-cache"
 )
@@ -12,15 +13,16 @@ type MemRepo struct {
 }
 
 // NewMemRepository returns a newly initialized in-memory repository
-func NewMemRepository(c *cache.Cache) (*MemRepo, error) {
+func NewMemRepository(expiration, expiredPurge int) (*MemRepo, error) {
 	return &MemRepo{
-		c: c,
+		c: cache.New(time.Duration(expiration)*time.Minute, time.Duration(expiredPurge)*time.Minute),
 	}, nil
 }
 
 // Save stores a new value for a key in the k/v store
-func (r *MemRepo) Save(key string, value string) {
+func (r *MemRepo) Save(key string, value string) error {
 	r.c.Set(key, value, cache.DefaultExpiration)
+	return nil
 }
 
 // Get retrieves a value from the k/v store