Merge pull request #958 from owncloud/basic-auth-cache

implement basic auth cache

ocis-pkg/cache/cache.go

@@ -0,0 +1,78 @@
+package cache
+
+import (
+	"sync"
+	"time"
+)
+
+// Entry represents an entry on the cache. You can type assert on V.
+type Entry struct {
+	V          interface{}
+	expiration time.Time
+}
+
+// Cache is a barebones cache implementation.
+type Cache struct {
+	entries map[string]*Entry
+	size    int
+	m       sync.Mutex
+}
+
+// NewCache returns a new instance of Cache.
+func NewCache(o ...Option) Cache {
+	opts := newOptions(o...)
+
+	return Cache{
+		size:    opts.size,
+		entries: map[string]*Entry{},
+	}
+}
+
+// Get gets a role-bundle by a given `roleID`.
+func (c *Cache) Get(k string) *Entry {
+	c.m.Lock()
+	defer c.m.Unlock()
+
+	if _, ok := c.entries[k]; ok {
+		if c.expired(c.entries[k]) {
+			delete(c.entries, k)
+			return nil
+		}
+		return c.entries[k]
+	}
+	return nil
+}
+
+// Set sets a roleID / role-bundle.
+func (c *Cache) Set(k string, val interface{}, expiration time.Time) {
+	c.m.Lock()
+	defer c.m.Unlock()
+
+	if !c.fits() {
+		c.evict()
+	}
+
+	c.entries[k] = &Entry{
+		val,
+		expiration,
+	}
+}
+
+// evict frees memory from the cache by removing entries that exceeded the cache TTL.
+func (c *Cache) evict() {
+	for i := range c.entries {
+		if c.expired(c.entries[i]) {
+			delete(c.entries, i)
+		}
+	}
+}
+
+// expired checks if an entry is expired
+func (c *Cache) expired(e *Entry) bool {
+	return e.expiration.Before(time.Now())
+}
+
+// fits returns whether the cache fits more entries.
+func (c *Cache) fits() bool {
+	return c.size > len(c.entries)
+}

ocis-pkg/cache/option.go

@@ -0,0 +1,36 @@
+package cache
+
+import "time"
+
+// Options are all the possible options.
+type Options struct {
+	size int
+	ttl  time.Duration
+}
+
+// Option mutates option
+type Option func(*Options)
+
+// Size configures the size of the cache in items.
+func Size(s int) Option {
+	return func(o *Options) {
+		o.size = s
+	}
+}
+
+// TTL rebuilds the cache after the configured duration.
+func TTL(ttl time.Duration) Option {
+	return func(o *Options) {
+		o.ttl = ttl
+	}
+}
+
+func newOptions(opts ...Option) Options {
+	o := Options{}
+
+	for _, v := range opts {
+		v(&o)
+	}
+
+	return o
+}