move cacher in separate dir

staging/src/k8s.io/apiserver/pkg/registry/generic/registry/storage_factory.go

@@ -24,6 +24,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/storage"
+	cacherstorage "k8s.io/apiserver/pkg/storage/cacher"
 	etcdstorage "k8s.io/apiserver/pkg/storage/etcd"
 	"k8s.io/apiserver/pkg/storage/storagebackend"
 	"k8s.io/apiserver/pkg/storage/storagebackend/factory"
@@ -49,7 +50,7 @@ func StorageWithCacher(capacity int) generic.StorageDecorator {
 
 		// TODO: we would change this later to make storage always have cacher and hide low level KV layer inside.
 		// Currently it has two layers of same storage interface -- cacher and low level kv.
-		cacherConfig := storage.CacherConfig{
+		cacherConfig := cacherstorage.Config{
 			CacheCapacity:        capacity,
 			Storage:              s,
 			Versioner:            etcdstorage.APIObjectVersioner{},
@@ -61,7 +62,7 @@ func StorageWithCacher(capacity int) generic.StorageDecorator {
 			TriggerPublisherFunc: triggerFunc,
 			Codec:                storageConfig.Codec,
 		}
-		cacher := storage.NewCacherFromConfig(cacherConfig)
+		cacher := cacherstorage.NewCacherFromConfig(cacherConfig)
 		destroyFunc := func() {
 			cacher.Stop()
 			d()

staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store_test.go

@@ -49,6 +49,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/registry/rest"
 	"k8s.io/apiserver/pkg/storage"
+	cacherstorage "k8s.io/apiserver/pkg/storage/cacher"
 	etcdstorage "k8s.io/apiserver/pkg/storage/etcd"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
 	"k8s.io/apiserver/pkg/storage/names"
@@ -1849,7 +1850,7 @@ func newTestGenericStoreRegistry(t *testing.T, scheme *runtime.Scheme, hasCacheE
 		server.Terminate(t)
 	}
 	if hasCacheEnabled {
-		config := storage.CacherConfig{
+		config := cacherstorage.Config{
 			CacheCapacity:  10,
 			Storage:        s,
 			Versioner:      etcdstorage.APIObjectVersioner{},
@@ -1860,7 +1861,7 @@ func newTestGenericStoreRegistry(t *testing.T, scheme *runtime.Scheme, hasCacheE
 			NewListFunc:    func() runtime.Object { return &example.PodList{} },
 			Codec:          sc.Codec,
 		}
-		cacher := storage.NewCacherFromConfig(config)
+		cacher := cacherstorage.NewCacherFromConfig(config)
 		d := destroyFunc
 		s = cacher
 		destroyFunc = func() {

staging/src/k8s.io/apiserver/pkg/storage/cacher_whitebox_test.go → staging/src/k8s.io/apiserver/pkg/storage/cacher/cacher_whitebox_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package storage
+package cacher
 
 import (
 	"fmt"

staging/src/k8s.io/apiserver/pkg/storage/time_budget.go → staging/src/k8s.io/apiserver/pkg/storage/cacher/time_budget.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package storage
+package cacher
 
 import (
 	"sync"

staging/src/k8s.io/apiserver/pkg/storage/time_budget_test.go → staging/src/k8s.io/apiserver/pkg/storage/cacher/time_budget_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package storage
+package cacher
 
 import (
 	"testing"

staging/src/k8s.io/apiserver/pkg/storage/cacher/util.go

+/*
+Copyright 2015 The Kubernetes Authors.
+
+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 cacher
+
+import (
+	"strings"
+)
+
+// hasPathPrefix returns true if the string matches pathPrefix exactly, or if is prefixed with pathPrefix at a path segment boundary
+func hasPathPrefix(s, pathPrefix string) bool {
+	// Short circuit if s doesn't contain the prefix at all
+	if !strings.HasPrefix(s, pathPrefix) {
+		return false
+	}
+
+	pathPrefixLength := len(pathPrefix)
+
+	if len(s) == pathPrefixLength {
+		// Exact match
+		return true
+	}
+	if strings.HasSuffix(pathPrefix, "/") {
+		// pathPrefix already ensured a path segment boundary
+		return true
+	}
+	if s[pathPrefixLength:pathPrefixLength+1] == "/" {
+		// The next character in s is a path segment boundary
+		// Check this instead of normalizing pathPrefix to avoid allocating on every call
+		return true
+	}
+	return false
+}

staging/src/k8s.io/apiserver/pkg/storage/cacher/util_test.go

+/*
+Copyright 2015 The Kubernetes Authors.
+
+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 cacher
+
+import (
+	"testing"
+)
+
+func TestHasPathPrefix(t *testing.T) {
+	validTestcases := []struct {
+		s      string
+		prefix string
+	}{
+		// Exact matches
+		{"", ""},
+		{"a", "a"},
+		{"a/", "a/"},
+		{"a/../", "a/../"},
+
+		// Path prefix matches
+		{"a/b", "a"},
+		{"a/b", "a/"},
+		{"中文/", "中文"},
+	}
+	for i, tc := range validTestcases {
+		if !hasPathPrefix(tc.s, tc.prefix) {
+			t.Errorf(`%d: Expected hasPathPrefix("%s","%s") to be true`, i, tc.s, tc.prefix)
+		}
+	}
+
+	invalidTestcases := []struct {
+		s      string
+		prefix string
+	}{
+		// Mismatch
+		{"a", "b"},
+
+		// Dir requirement
+		{"a", "a/"},
+
+		// Prefix mismatch
+		{"ns2", "ns"},
+		{"ns2", "ns/"},
+		{"中文文", "中文"},
+
+		// Ensure no normalization is applied
+		{"a/c/../b/", "a/b/"},
+		{"a/", "a/b/.."},
+	}
+	for i, tc := range invalidTestcases {
+		if hasPathPrefix(tc.s, tc.prefix) {
+			t.Errorf(`%d: Expected hasPathPrefix("%s","%s") to be false`, i, tc.s, tc.prefix)
+		}
+	}
+}

staging/src/k8s.io/apiserver/pkg/storage/watch_cache.go → staging/src/k8s.io/apiserver/pkg/storage/cacher/watch_cache.go

@@ -14,12 +14,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package storage
+package cacher
 
 import (
 	"fmt"
 	"sort"
-	"strconv"
 	"sync"
 	"time"
 
@@ -29,6 +28,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/clock"
 	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/apiserver/pkg/storage"
 	utiltrace "k8s.io/apiserver/pkg/util/trace"
 	"k8s.io/client-go/tools/cache"
 )
@@ -138,14 +138,14 @@ type watchCache struct {
 	clock clock.Clock
 
 	// An underlying storage.Versioner.
-	versioner Versioner
+	versioner storage.Versioner
 }
 
 func newWatchCache(
 	capacity int,
 	keyFunc func(runtime.Object) (string, error),
 	getAttrsFunc func(runtime.Object) (labels.Set, fields.Set, bool, error),
-	versioner Versioner) *watchCache {
+	versioner storage.Versioner) *watchCache {
 	wc := &watchCache{
 		capacity:        capacity,
 		keyFunc:         keyFunc,

staging/src/k8s.io/apiserver/pkg/storage/watch_cache_test.go → staging/src/k8s.io/apiserver/pkg/storage/cacher/watch_cache_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package storage
+package cacher
 
 import (
 	"fmt"
@@ -32,7 +32,8 @@ import (
 	"k8s.io/apimachinery/pkg/util/clock"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/apimachinery/pkg/watch"
-	etcdstorage "k8s.io/apiserver/pkg/storage/etcd"
+	"k8s.io/apiserver/pkg/storage"
+	"k8s.io/apiserver/pkg/storage/etcd"
 	"k8s.io/client-go/tools/cache"
 )
 
@@ -65,16 +66,16 @@ func makeTestStoreElement(pod *v1.Pod) *storeElement {
 // newTestWatchCache just adds a fake clock.
 func newTestWatchCache(capacity int) *watchCache {
 	keyFunc := func(obj runtime.Object) (string, error) {
-		return NamespaceKeyFunc("prefix", obj)
+		return storage.NamespaceKeyFunc("prefix", obj)
 	}
 	getAttrsFunc := func(obj runtime.Object) (labels.Set, fields.Set, bool, error) {
 		pod, ok := obj.(*v1.Pod)
 		if !ok {
-			return nil, nil, false, fmt.Errorf("not a pod!")
+			return nil, nil, false, fmt.Errorf("not a pod")
 		}
 		return labels.Set(pod.Labels), fields.Set{"spec.nodeName": pod.Spec.NodeName}, false, nil
 	}
-	versioner := etcdstorage.APIObjectVersioner{}
+	versioner := etcd.APIObjectVersioner{}
 	wc := newWatchCache(capacity, keyFunc, getAttrsFunc, versioner)
 	wc.clock = clock.NewFakeClock(time.Now())
 	return wc

staging/src/k8s.io/apiserver/pkg/storage/tests/cacher_test.go

@@ -40,6 +40,7 @@ import (
 	"k8s.io/apiserver/pkg/apis/example"
 	examplev1 "k8s.io/apiserver/pkg/apis/example/v1"
 	"k8s.io/apiserver/pkg/storage"
+	cacherstorage "k8s.io/apiserver/pkg/storage/cacher"
 	etcdstorage "k8s.io/apiserver/pkg/storage/etcd"
 	"k8s.io/apiserver/pkg/storage/etcd/etcdtest"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
@@ -95,10 +96,10 @@ func newEtcdTestStorage(t *testing.T, prefix string) (*etcdtesting.EtcdTestServe
 	return server, storage
 }
 
-func newTestCacher(s storage.Interface, cap int) (*storage.Cacher, storage.Versioner) {
+func newTestCacher(s storage.Interface, cap int) (*cacherstorage.Cacher, storage.Versioner) {
 	prefix := "pods"
 	v := etcdstorage.APIObjectVersioner{}
-	config := storage.CacherConfig{
+	config := cacherstorage.Config{
 		CacheCapacity:  cap,
 		Storage:        s,
 		Versioner:      v,
@@ -109,7 +110,7 @@ func newTestCacher(s storage.Interface, cap int) (*storage.Cacher, storage.Versi
 		NewListFunc:    func() runtime.Object { return &example.PodList{} },
 		Codec:          codecs.LegacyCodec(examplev1.SchemeGroupVersion),
 	}
-	return storage.NewCacherFromConfig(config), v
+	return cacherstorage.NewCacherFromConfig(config), v
 }
 
 func makeTestPod(name string) *example.Pod {

staging/src/k8s.io/apiserver/pkg/storage/util.go

@@ -18,7 +18,6 @@ package storage
 
 import (
 	"fmt"
-	"strings"
 	"sync/atomic"
 
 	"k8s.io/apimachinery/pkg/api/meta"
@@ -72,31 +71,6 @@ func NoNamespaceKeyFunc(prefix string, obj runtime.Object) (string, error) {
 	return prefix + "/" + name, nil
 }
 
-// hasPathPrefix returns true if the string matches pathPrefix exactly, or if is prefixed with pathPrefix at a path segment boundary
-func hasPathPrefix(s, pathPrefix string) bool {
-	// Short circuit if s doesn't contain the prefix at all
-	if !strings.HasPrefix(s, pathPrefix) {
-		return false
-	}
-
-	pathPrefixLength := len(pathPrefix)
-
-	if len(s) == pathPrefixLength {
-		// Exact match
-		return true
-	}
-	if strings.HasSuffix(pathPrefix, "/") {
-		// pathPrefix already ensured a path segment boundary
-		return true
-	}
-	if s[pathPrefixLength:pathPrefixLength+1] == "/" {
-		// The next character in s is a path segment boundary
-		// Check this instead of normalizing pathPrefix to avoid allocating on every call
-		return true
-	}
-	return false
-}
-
 // HighWaterMark is a thread-safe object for tracking the maximum value seen
 // for some quantity.
 type HighWaterMark int64

staging/src/k8s.io/apiserver/pkg/storage/util_test.go

@@ -22,54 +22,6 @@ import (
 	"testing"
 )
 
-func TestHasPathPrefix(t *testing.T) {
-	validTestcases := []struct {
-		s      string
-		prefix string
-	}{
-		// Exact matches
-		{"", ""},
-		{"a", "a"},
-		{"a/", "a/"},
-		{"a/../", "a/../"},
-
-		// Path prefix matches
-		{"a/b", "a"},
-		{"a/b", "a/"},
-		{"中文/", "中文"},
-	}
-	for i, tc := range validTestcases {
-		if !hasPathPrefix(tc.s, tc.prefix) {
-			t.Errorf(`%d: Expected hasPathPrefix("%s","%s") to be true`, i, tc.s, tc.prefix)
-		}
-	}
-
-	invalidTestcases := []struct {
-		s      string
-		prefix string
-	}{
-		// Mismatch
-		{"a", "b"},
-
-		// Dir requirement
-		{"a", "a/"},
-
-		// Prefix mismatch
-		{"ns2", "ns"},
-		{"ns2", "ns/"},
-		{"中文文", "中文"},
-
-		// Ensure no normalization is applied
-		{"a/c/../b/", "a/b/"},
-		{"a/", "a/b/.."},
-	}
-	for i, tc := range invalidTestcases {
-		if hasPathPrefix(tc.s, tc.prefix) {
-			t.Errorf(`%d: Expected hasPathPrefix("%s","%s") to be false`, i, tc.s, tc.prefix)
-		}
-	}
-}
-
 func TestHighWaterMark(t *testing.T) {
 	var h HighWaterMark