ref: 87203139c38e0b992c96d7b8a23c7730649c68e5
parent: a91c2705c7ddf587f359e4470b256a0d64b95e4f
author: Bjørn Erik Pedersen <[email protected]>
date: Thu May 25 13:14:23 EDT 2017
cache: Add a simple partitioned lazy cache
--- /dev/null
+++ b/cache/partitioned_lazy_cache.go
@@ -1,0 +1,80 @@
+// Copyright 2017-present 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 cache
+
+import (
+ "sync"
+)
+
+// Partition represents a cache partition where Load is the callback
+// for when the partition is needed.
+type Partition struct {+ Key string
+ Load func() (map[string]interface{}, error)+}
+
+type lazyPartition struct {+ initSync sync.Once
+ cache map[string]interface{}+ load func() (map[string]interface{}, error)+}
+
+func (l *lazyPartition) init() error {+ var err error
+ l.initSync.Do(func() {+ var c map[string]interface{}+ c, err = l.load()
+ l.cache = c
+ })
+
+ return err
+}
+
+// PartitionedLazyCache is a lazily loaded cache paritioned by a supplied string key.
+type PartitionedLazyCache struct {+ partitions map[string]*lazyPartition
+}
+
+// NewPartitionedLazyCache creates a new NewPartitionedLazyCache with the supplied
+// partitions.
+func NewPartitionedLazyCache(partitions ...Partition) *PartitionedLazyCache {+ lazyPartitions := make(map[string]*lazyPartition, len(partitions))
+ for _, partition := range partitions {+ lazyPartitions[partition.Key] = &lazyPartition{load: partition.Load}+ }
+ cache := &PartitionedLazyCache{partitions: lazyPartitions}+
+ return cache
+}
+
+// Get initializes the partition if not already done so, then looks up the given
+// key in the given partition, returns nil if no value found.
+func (c *PartitionedLazyCache) Get(partition, key string) (interface{}, error) {+ p, found := c.partitions[partition]
+
+ if !found {+ return nil, nil
+ }
+
+ if err := p.init(); err != nil {+ return nil, err
+ }
+
+ if v, found := p.cache[key]; found {+ return v, nil
+ }
+
+ return nil, nil
+
+}
--- /dev/null
+++ b/cache/partitioned_lazy_cache_test.go
@@ -1,0 +1,92 @@
+// Copyright 2017-present 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 cache
+
+import (
+ "errors"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestNewPartitionedLazyCache(t *testing.T) {+ t.Parallel()
+
+ assert := require.New(t)
+
+ p1 := Partition{+ Key: "p1",
+ Load: func() (map[string]interface{}, error) {+ return map[string]interface{}{+ "p1_1": "p1v1",
+ "p1_2": "p1v2",
+ "p1_nil": nil,
+ }, nil
+ },
+ }
+
+ p2 := Partition{+ Key: "p2",
+ Load: func() (map[string]interface{}, error) {+ return map[string]interface{}{+ "p2_1": "p2v1",
+ "p2_2": "p2v2",
+ "p2_3": "p2v3",
+ }, nil
+ },
+ }
+
+ cache := NewPartitionedLazyCache(p1, p2)
+
+ v, err := cache.Get("p1", "p1_1")+ assert.NoError(err)
+ assert.Equal("p1v1", v)+
+ v, err = cache.Get("p1", "p2_1")+ assert.NoError(err)
+ assert.Nil(v)
+
+ v, err = cache.Get("p1", "p1_nil")+ assert.NoError(err)
+ assert.Nil(v)
+
+ v, err = cache.Get("p2", "p2_3")+ assert.NoError(err)
+ assert.Equal("p2v3", v)+
+ v, err = cache.Get("doesnotexist", "p1_1")+ assert.NoError(err)
+ assert.Nil(v)
+
+ v, err = cache.Get("p1", "doesnotexist")+ assert.NoError(err)
+ assert.Nil(v)
+
+ errorP := Partition{+ Key: "p3",
+ Load: func() (map[string]interface{}, error) {+ return nil, errors.New("Failed")+ },
+ }
+
+ cache = NewPartitionedLazyCache(errorP)
+
+ v, err = cache.Get("p1", "doesnotexist")+ assert.NoError(err)
+ assert.Nil(v)
+
+ _, err = cache.Get("p3", "doesnotexist")+ assert.Error(err)
+
+}