Add shared cache for resolvers

Author: brianwcook

pkg/remoteresolution/cache/cache.go

@@ -0,0 +1,105 @@
+/*
+Copyright 2024 The Tekton 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 cache
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"time"
+
+	"context"
+
+	v1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1"
+	utilcache "k8s.io/apimachinery/pkg/util/cache"
+	"knative.dev/pkg/logging"
+)
+
+const (
+	// DefaultExpiration is the default expiration time for cache entries
+	DefaultExpiration = 5 * time.Minute
+
+	// DefaultMaxSize is the default size for the cache
+	DefaultMaxSize = 1000
+)
+
+// ResolverCache is a wrapper around utilcache.LRUExpireCache that provides
+// type-safe methods for caching resolver results.
+type ResolverCache struct {
+	cache *utilcache.LRUExpireCache
+}
+
+// NewResolverCache creates a new ResolverCache with the given expiration time and max size
+func NewResolverCache(maxSize int) *ResolverCache {
+	return &ResolverCache{
+		cache: utilcache.NewLRUExpireCache(maxSize),
+	}
+}
+
+// Get retrieves a value from the cache.
+func (c *ResolverCache) Get(key string) (interface{}, bool) {
+	value, found := c.cache.Get(key)
+	logger := logging.FromContext(context.Background())
+	if found {
+		logger.Debugw("Cache hit", "key", key)
+	} else {
+		logger.Debugw("Cache miss", "key", key)
+	}
+	return value, found
+}
+
+// Add adds a value to the cache with the default expiration time.
+func (c *ResolverCache) Add(key string, value interface{}) {
+	logger := logging.FromContext(context.Background())
+	logger.Debugw("Adding to cache", "key", key, "expiration", DefaultExpiration)
+	c.cache.Add(key, value, DefaultExpiration)
+}
+
+// Remove removes a value from the cache.
+func (c *ResolverCache) Remove(key string) {
+	logger := logging.FromContext(context.Background())
+	logger.Debugw("Removing from cache", "key", key)
+	c.cache.Remove(key)
+}
+
+// AddWithExpiration adds a value to the cache with a custom expiration time
+func (c *ResolverCache) AddWithExpiration(key string, value interface{}, expiration time.Duration) {
+	logger := logging.FromContext(context.Background())
+	logger.Debugw("Adding to cache with custom expiration", "key", key, "expiration", expiration)
+	c.cache.Add(key, value, expiration)
+}
+
+// globalCache is the global instance of ResolverCache
+var globalCache = NewResolverCache(DefaultMaxSize)
+
+// GetGlobalCache returns the global cache instance.
+func GetGlobalCache() *ResolverCache {
+	return globalCache
+}
+
+// GenerateCacheKey generates a cache key for the given resolver type and parameters.
+func GenerateCacheKey(resolverType string, params []v1.Param) (string, error) {
+	// Create a deterministic string representation of the parameters
+	paramStr := fmt.Sprintf("%s:", resolverType)
+	for _, p := range params {
+		paramStr += fmt.Sprintf("%s=%s;", p.Name, p.Value.StringVal)
+	}
+
+	// Generate a SHA-256 hash of the parameter string
+	hash := sha256.Sum256([]byte(paramStr))
+	return hex.EncodeToString(hash[:]), nil
+}

pkg/remoteresolution/cache/cache_test.go

@@ -0,0 +1,117 @@
+/*
+Copyright 2024 The Tekton 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 cache
+
+import (
+	"testing"
+	"time"
+
+	pipelinev1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1"
+)
+
+func TestGenerateCacheKey(t *testing.T) {
+	tests := []struct {
+		name         string
+		resolverType string
+		params       []pipelinev1.Param
+		wantErr      bool
+	}{
+		{
+			name:         "empty params",
+			resolverType: "http",
+			params:       []pipelinev1.Param{},
+			wantErr:      false,
+		},
+		{
+			name:         "single param",
+			resolverType: "http",
+			params: []pipelinev1.Param{
+				{
+					Name: "url",
+					Value: pipelinev1.ParamValue{
+						Type:      pipelinev1.ParamTypeString,
+						StringVal: "https://example.com",
+					},
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name:         "multiple params",
+			resolverType: "git",
+			params: []pipelinev1.Param{
+				{
+					Name: "url",
+					Value: pipelinev1.ParamValue{
+						Type:      pipelinev1.ParamTypeString,
+						StringVal: "https://github.com/tektoncd/pipeline",
+					},
+				},
+				{
+					Name: "revision",
+					Value: pipelinev1.ParamValue{
+						Type:      pipelinev1.ParamTypeString,
+						StringVal: "main",
+					},
+				},
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			key, err := GenerateCacheKey(tt.resolverType, tt.params)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GenerateCacheKey() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr && key == "" {
+				t.Error("GenerateCacheKey() returned empty key")
+			}
+		})
+	}
+}
+
+func TestResolverCache(t *testing.T) {
+	cache := NewResolverCache(DefaultMaxSize)
+
+	// Test adding and getting a value
+	key := "test-key"
+	value := "test-value"
+	cache.Add(key, value)
+
+	if got, ok := cache.Get(key); !ok || got != value {
+		t.Errorf("Get() = %v, %v, want %v, true", got, ok, value)
+	}
+
+	// Test expiration
+	shortExpiration := 100 * time.Millisecond
+	cache.AddWithExpiration("expiring-key", "expiring-value", shortExpiration)
+	time.Sleep(shortExpiration + 50*time.Millisecond)
+
+	if _, ok := cache.Get("expiring-key"); ok {
+		t.Error("Get() returned true for expired key")
+	}
+
+	// Test global cache
+	globalCache1 := GetGlobalCache()
+	globalCache2 := GetGlobalCache()
+	if globalCache1 != globalCache2 {
+		t.Error("GetGlobalCache() returned different instances")
+	}
+}

pkg/remoteresolution/resolver/bundle/resolver.go

@@ -19,8 +19,10 @@ package bundle
 import (
 	"context"
 	"errors"
+	"strings"
 
 	"github.com/tektoncd/pipeline/pkg/apis/resolution/v1beta1"
+	"github.com/tektoncd/pipeline/pkg/remoteresolution/cache"
 	"github.com/tektoncd/pipeline/pkg/remoteresolution/resolver/framework"
 	"github.com/tektoncd/pipeline/pkg/resolution/common"
 	"github.com/tektoncd/pipeline/pkg/resolution/resolver/bundle"
@@ -36,6 +38,16 @@ const (
 
 	// BundleResolverName is the name that the bundle resolver should be associated with.
 	BundleResolverName = "bundleresolver"
+
+	// ConfigMapName is the bundle resolver's config map
+	ConfigMapName = "bundleresolver-config"
+
+	// CacheModeAlways means always use cache regardless of bundle reference
+	CacheModeAlways = "always"
+	// CacheModeNever means never use cache regardless of bundle reference
+	CacheModeNever = "never"
+	// CacheModeAuto means use cache only when bundle reference has a digest
+	CacheModeAuto = "auto"
 )
 
 var _ framework.Resolver = &Resolver{}
@@ -58,17 +70,18 @@ func (r *Resolver) GetName(context.Context) string {
 
 // GetConfigName returns the name of the bundle resolver's configmap.
 func (r *Resolver) GetConfigName(context.Context) string {
-	return bundle.ConfigMapName
+	return ConfigMapName
 }
 
-// GetSelector returns a map of labels to match requests to this Resolver.
+// GetSelector returns the labels that resource requests are required to have for
+// the bundle resolver to process them.
 func (r *Resolver) GetSelector(context.Context) map[string]string {
 	return map[string]string{
 		common.LabelKeyResolverType: LabelValueBundleResolverType,
 	}
 }
 
-// Validate ensures reqolution request spec from a request are as expected.
+// Validate ensures parameters from a request are as expected.
 func (r *Resolver) Validate(ctx context.Context, req *v1beta1.ResolutionRequestSpec) error {
 	if len(req.Params) > 0 {
 		return bundle.ValidateParams(ctx, req.Params)
@@ -77,11 +90,79 @@ func (r *Resolver) Validate(ctx context.Context, req *v1beta1.ResolutionRequestS
 	return errors.New("cannot validate request. the Validate method has not been implemented.")
 }
 
-// Resolve uses the given request spec resolve the requested file or resource.
+// ShouldUseCache determines if caching should be used based on the cache mode and bundle reference.
+func ShouldUseCache(cacheMode string, bundleRef string) bool {
+	switch cacheMode {
+	case CacheModeAlways:
+		return true
+	case CacheModeNever:
+		return false
+	case CacheModeAuto, "": // default to auto if not specified
+		return IsOCIPullSpecByDigest(bundleRef)
+	default: // invalid cache mode defaults to auto
+		return IsOCIPullSpecByDigest(bundleRef)
+	}
+}
+
+// Resolve uses the given params to resolve the requested file or resource.
 func (r *Resolver) Resolve(ctx context.Context, req *v1beta1.ResolutionRequestSpec) (resolutionframework.ResolvedResource, error) {
 	if len(req.Params) > 0 {
-		return bundle.ResolveRequest(ctx, r.kubeClientSet, req)
+		if bundle.IsDisabled(ctx) {
+			return nil, errors.New(bundle.DisabledError)
+		}
+
+		origParams := req.Params
+
+		params, err := bundle.OptionsFromParams(ctx, origParams)
+		if err != nil {
+			return nil, err
+		}
+
+		// Determine if caching should be used based on cache mode
+		useCache := ShouldUseCache(params.Cache, params.Bundle)
+
+		if useCache {
+			// Generate cache key
+			cacheKey, err := cache.GenerateCacheKey(LabelValueBundleResolverType, origParams)
+			if err != nil {
+				return nil, err
+			}
+
+			// Check cache first
+			if cached, ok := cache.GetGlobalCache().Get(cacheKey); ok {
+				if resource, ok := cached.(resolutionframework.ResolvedResource); ok {
+					return resource, nil
+				}
+			}
+		}
+
+		resource, err := bundle.ResolveRequest(ctx, r.kubeClientSet, req)
+		if err != nil {
+			return nil, err
+		}
+
+		// Cache the result if caching is enabled
+		if useCache {
+			cacheKey, _ := cache.GenerateCacheKey(LabelValueBundleResolverType, origParams)
+			cache.GetGlobalCache().Add(cacheKey, resource)
+		}
+
+		return resource, nil
 	}
 	// Remove this error once resolution of url has been implemented.
 	return nil, errors.New("the Resolve method has not been implemented.")
 }
+
+// IsOCIPullSpecByDigest checks if the given OCI pull spec contains a digest.
+// A digest is typically in the format of @sha256:<hash> or :<tag>@sha256:<hash>
+func IsOCIPullSpecByDigest(pullSpec string) bool {
+	// Check for @sha256: pattern
+	if strings.Contains(pullSpec, "@sha256:") {
+		return true
+	}
+	// Check for :<tag>@sha256: pattern
+	if strings.Contains(pullSpec, ":") && strings.Contains(pullSpec, "@sha256:") {
+		return true
+	}
+	return false
+}