feat: wrap content to support remote cache

We can use  LRU in content store  and wrap some methods to provides  remote cache. Here Info, Update, ReaderAt, Walk methods were wraped and they can get, update, and do other operations in LRU cache.
Also, we can configure whether to enable cache or not with cache_tag_suffix.And we can config cache size.

Signed-off-by: YuQiang <y_q_email@163.com>

misc/config/config.nydus.ref.yaml

@@ -31,6 +31,8 @@ provider:
   gcpolicy:
       # size threshold that triggers GC, the oldest used blobs will be reclaimed if exceeds the size.
       threshold: 1000MB
+  # remote cache record capacity of converted layers, default is 200.
+  cache_size: 200
 
 converter:
   # number of worker for executing conversion task
@@ -61,3 +63,5 @@ converter:
   rules:
     # add suffix to tag of source image reference as target image reference
     - tag_suffix: -nydus-oci-ref
+    # add suffix to tag of source image reference as remote cache reference, leave empty to disable remote cache.
+    - cache_tag_suffix: -nydus-cache

misc/config/config.nydus.yaml

@@ -31,6 +31,8 @@ provider:
   gcpolicy:
       # size threshold that triggers GC, the oldest used blobs will be reclaimed if exceeds the size.
       threshold: 1000MB
+  # remote cache record capacity of converted layers, default is 200.
+  cache_size: 200
 
 converter:
   # number of worker for executing conversion task
@@ -100,3 +102,5 @@ converter:
   rules:
     # add suffix to tag of source image reference as target image reference
     - tag_suffix: -nydus
+    # add suffix to tag of source image reference as remote cache reference, leave empty to disable remote cache.
+    - cache_tag_suffix: -nydus-cache

pkg/adapter/adapter.go

@@ -61,7 +61,7 @@ func NewLocalAdapter(cfg *config.Config) (*LocalAdapter, error) {
 		return nil, errors.Wrap(err, "invalid platform configuration")
 	}
 
-	provider, content, err := content.NewLocalProvider(cfg.Provider.WorkDir, cfg.Provider.GCPolicy.Threshold, cfg.Host, platformMC)
+	provider, content, err := content.NewLocalProvider(cfg, platformMC)
 	if err != nil {
 		return nil, errors.Wrap(err, "create content provider")
 	}
@@ -95,15 +95,25 @@ func NewLocalAdapter(cfg *config.Config) (*LocalAdapter, error) {
 }
 
 func (adp *LocalAdapter) Convert(ctx context.Context, source string) error {
-	target, err := adp.rule.Map(source)
+	target, err := adp.rule.Map(source, TagSuffix)
 	if err != nil {
 		if errors.Is(err, errdefs.ErrAlreadyConverted) {
 			logrus.Infof("image has been converted: %s", source)
 			return nil
 		}
 		return errors.Wrap(err, "create target reference by rule")
 	}
-	if _, err = adp.cvt.Convert(ctx, source, target); err != nil {
+	cacheRef, err := adp.rule.Map(source, CacheTagSuffix)
+	if err != nil {
+		if errors.Is(err, errdefs.ErrIsRemoteCache) {
+			logrus.Infof("image was remote cache: %s", source)
+			return nil
+		}
+	}
+	if err = adp.content.NewRemoteCache(cacheRef); err != nil {
+		return err
+	}
+	if _, err = adp.cvt.Convert(ctx, source, target, cacheRef); err != nil {
 		return err
 	}
 	if err := adp.content.GC(ctx); err != nil {

pkg/adapter/rule.go

@@ -24,6 +24,11 @@ import (
 	"github.com/goharbor/acceleration-service/pkg/errdefs"
 )
 
+const (
+	TagSuffix      = "tag_suffix"
+	CacheTagSuffix = "cache_tag_suffix"
+)
+
 // Add suffix to source image reference as the target
 // image reference, for example:
 // Source: 192.168.1.1/nginx:latest
@@ -47,16 +52,33 @@ type Rule struct {
 
 // Map maps the source image reference to a new one according to
 // a rule, the new one will be used as the reference of target image.
-func (rule *Rule) Map(ref string) (string, error) {
-	for _, item := range rule.items {
-		if item.TagSuffix != "" {
-			if strings.HasSuffix(ref, item.TagSuffix) {
-				// FIXME: To check if an image has been converted, a better solution
-				// is to use the annotation on image manifest.
-				return "", errdefs.ErrAlreadyConverted
+func (rule *Rule) Map(ref, opt string) (string, error) {
+	switch opt {
+	case TagSuffix:
+		for _, item := range rule.items {
+			if item.TagSuffix != "" {
+				if strings.HasSuffix(ref, item.TagSuffix) {
+					// FIXME: To check if an image has been converted, a better solution
+					// is to use the annotation on image manifest.
+					return "", errdefs.ErrAlreadyConverted
+				}
+				return addSuffix(ref, item.TagSuffix)
+			}
+		}
+	case CacheTagSuffix:
+		for _, item := range rule.items {
+			if item.CacheTagSuffix != "" {
+				if strings.HasSuffix(ref, item.CacheTagSuffix) {
+					// FIXME: Ditto.A better way is to use the annotation on image manifest.
+					return "", errdefs.ErrIsRemoteCache
+				}
+				return addSuffix(ref, item.CacheTagSuffix)
 			}
-			return addSuffix(ref, item.TagSuffix)
 		}
+		// CacheTagSuffix empty means do not provide remote cache, just return empty string.
+		return "", nil
+	default:
+		return "", fmt.Errorf("unsupported map option: %s", opt)
 	}
 	return "", errors.New("not found matched conversion rule")
 }

pkg/config/config.go

@@ -46,9 +46,10 @@ type MetricConfig struct {
 }
 
 type ProviderConfig struct {
-	Source   map[string]SourceConfig `yaml:"source"`
-	WorkDir  string                  `yaml:"work_dir"`
-	GCPolicy GCPolicy                `yaml:"gcpolicy"`
+	Source    map[string]SourceConfig `yaml:"source"`
+	WorkDir   string                  `yaml:"work_dir"`
+	GCPolicy  GCPolicy                `yaml:"gcpolicy"`
+	CacheSize int                     `yaml:"cache_size"`
 }
 
 type GCPolicy struct {
@@ -66,7 +67,8 @@ type SourceConfig struct {
 }
 
 type ConversionRule struct {
-	TagSuffix string `yaml:"tag_suffix"`
+	TagSuffix      string `yaml:"tag_suffix"`
+	CacheTagSuffix string `yaml:"cache_tag_suffix"`
 }
 
 type ConverterConfig struct {
@@ -137,3 +139,12 @@ func (cfg *Config) Host(ref string) (remote.CredentialFunc, bool, error) {
 		return ary[0], ary[1], nil
 	}, auth.Insecure, nil
 }
+
+func (cfg *Config) EnableRemoteCache() bool {
+	for _, rule := range cfg.Converter.Rules {
+		if rule.CacheTagSuffix != "" {
+			return true
+		}
+	}
+	return false
+}

pkg/content/cache.go

@@ -23,7 +23,9 @@ import (
 
 	"github.com/containerd/containerd/leases"
 	"github.com/containerd/containerd/namespaces"
+	"github.com/goharbor/acceleration-service/pkg/remote"
 	lru "github.com/hashicorp/golang-lru/v2"
+	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
 )
 
 // This is not thread-safe, which means it will depend on the parent implementation to do the locking mechanism.
@@ -122,3 +124,61 @@ func (leaseCache *leaseCache) remove(key string, usedCount string) {
 func (leaseCache *leaseCache) Len() int {
 	return leaseCache.size
 }
+
+type RemoteCache struct {
+	// remoteCache is an LRU cache for caching target layer descriptors, the cache key is the source layer digest,
+	// and the cache value is the target layer descriptor after conversion.
+	remoteCache *lru.Cache[string, ocispec.Descriptor]
+	// cacheRef is the remote cache reference.
+	cacheRef string
+	// host is a func to provide registry credential by host name.
+	host remote.HostFunc
+	// cacheSize is the remote cache record capacity of converted layers.
+	cacheSize int
+}
+
+func NewRemoteCache(cacheSize int, host remote.HostFunc) (*RemoteCache, error) {
+	remoteCache, err := lru.New[string, ocispec.Descriptor](cacheSize)
+	if err != nil {
+		return nil, err
+	}
+	return &RemoteCache{
+		remoteCache: remoteCache,
+		host:        host,
+		cacheSize:   cacheSize,
+	}, nil
+}
+
+func (rc *RemoteCache) Values() []ocispec.Descriptor {
+	return rc.remoteCache.Values()
+}
+
+func (rc *RemoteCache) Get(key string) (ocispec.Descriptor, bool) {
+	return rc.remoteCache.Get(key)
+}
+
+func (rc *RemoteCache) Add(key string, value ocispec.Descriptor) {
+	rc.remoteCache.Add(key, value)
+}
+
+func (rc *RemoteCache) Remove(key string) {
+	rc.remoteCache.Remove(key)
+}
+
+// Size returns the number of items in the cache.
+func (rc *RemoteCache) Size() int {
+	return rc.remoteCache.Len()
+
+}
+
+func (rc *RemoteCache) NewLRUCache(cacheSize int, cacheRef string) error {
+	if rc != nil {
+		remoteCache, err := lru.New[string, ocispec.Descriptor](cacheSize)
+		if err != nil {
+			return err
+		}
+		rc.remoteCache = remoteCache
+		rc.cacheRef = cacheRef
+	}
+	return nil
+}

pkg/content/cache_test.go

@@ -44,7 +44,7 @@ func TestLeaseCache(t *testing.T) {
 func TestLeaseCacheInit(t *testing.T) {
 	os.MkdirAll("./tmp", 0755)
 	defer os.RemoveAll("./tmp")
-	content, err := NewContent("./tmp", "./tmp", "100MB")
+	content, err := NewContent("./tmp", "./tmp", "100MB", false, 200, nil)
 	require.NoError(t, err)
 	testDigest := []string{
 		"sha256:9bb13890319dc01e5f8a4d3d0c4c72685654d682d568350fd38a02b1d70aee6b",