From 822dc627a1cfdf1f97882f27761675ac6ace7669 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?=
 <bjorn.erik.pedersen@gmail.com>
Date: Fri, 21 Dec 2018 16:21:13 +0100
Subject: tpl/transform: Add transform.Unmarshal func

Fixes #5428
---
 cache/namedmemcache/named_cache.go      | 84 +++++++++++++++++++++++++++++++++
 cache/namedmemcache/named_cache_test.go | 80 +++++++++++++++++++++++++++++++
 2 files changed, 164 insertions(+)
 create mode 100644 cache/namedmemcache/named_cache.go
 create mode 100644 cache/namedmemcache/named_cache_test.go

(limited to 'cache/namedmemcache')

diff --git a/cache/namedmemcache/named_cache.go b/cache/namedmemcache/named_cache.go
new file mode 100644
index 000000000..18fbea391
--- /dev/null
+++ b/cache/namedmemcache/named_cache.go
@@ -0,0 +1,84 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package namedmemcache provides a memory cache with a named lock. This is suitable
+// for situations where creating the cached resource can be time consuming or otherwise
+// resource hungry, or in situations where a "once only per key" is a requirement.
+package namedmemcache
+
+import (
+	"sync"
+
+	"github.com/BurntSushi/locker"
+)
+
+// Cache holds the cached values.
+type Cache struct {
+	nlocker *locker.Locker
+	cache   map[string]cacheEntry
+	mu      sync.RWMutex
+}
+
+type cacheEntry struct {
+	value interface{}
+	err   error
+}
+
+// New creates a new cache.
+func New() *Cache {
+	return &Cache{
+		nlocker: locker.NewLocker(),
+		cache:   make(map[string]cacheEntry),
+	}
+}
+
+// Clear clears the cache state.
+func (c *Cache) Clear() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.cache = make(map[string]cacheEntry)
+	c.nlocker = locker.NewLocker()
+
+}
+
+// GetOrCreate tries to get the value with the given cache key, if not found
+// create will be called and cached.
+// This method is thread safe. It also guarantees that the create func for a given
+// key is invoced only once for this cache.
+func (c *Cache) GetOrCreate(key string, create func() (interface{}, error)) (interface{}, error) {
+	c.mu.RLock()
+	entry, found := c.cache[key]
+	c.mu.RUnlock()
+
+	if found {
+		return entry.value, entry.err
+	}
+
+	c.nlocker.Lock(key)
+	defer c.nlocker.Unlock(key)
+
+	// Double check
+	if entry, found := c.cache[key]; found {
+		return entry.value, entry.err
+	}
+
+	// Create it.
+	value, err := create()
+
+	c.mu.Lock()
+	c.cache[key] = cacheEntry{value: value, err: err}
+	c.mu.Unlock()
+
+	return value, err
+}
diff --git a/cache/namedmemcache/named_cache_test.go b/cache/namedmemcache/named_cache_test.go
new file mode 100644
index 000000000..cf64aa210
--- /dev/null
+++ b/cache/namedmemcache/named_cache_test.go
@@ -0,0 +1,80 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package namedmemcache
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNamedCache(t *testing.T) {
+	t.Parallel()
+	assert := require.New(t)
+
+	cache := New()
+
+	counter := 0
+	create := func() (interface{}, error) {
+		counter++
+		return counter, nil
+	}
+
+	for i := 0; i < 5; i++ {
+		v1, err := cache.GetOrCreate("a1", create)
+		assert.NoError(err)
+		assert.Equal(1, v1)
+		v2, err := cache.GetOrCreate("a2", create)
+		assert.NoError(err)
+		assert.Equal(2, v2)
+	}
+
+	cache.Clear()
+
+	v3, err := cache.GetOrCreate("a2", create)
+	assert.NoError(err)
+	assert.Equal(3, v3)
+}
+
+func TestNamedCacheConcurrent(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	var wg sync.WaitGroup
+
+	cache := New()
+
+	create := func(i int) func() (interface{}, error) {
+		return func() (interface{}, error) {
+			return i, nil
+		}
+	}
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 100; j++ {
+				id := fmt.Sprintf("id%d", j)
+				v, err := cache.GetOrCreate(id, create(j))
+				assert.NoError(err)
+				assert.Equal(j, v)
+			}
+		}()
+	}
+	wg.Wait()
+}
-- 
cgit v1.2.3