Refactored codebase to remove git references outside git parts of the…

… codebase

pkg/apiserver/apiserver.go

@@ -31,6 +31,7 @@ import (
 	"github.com/nephio-project/porch/pkg/engine"
 	"github.com/nephio-project/porch/pkg/meta"
 	"github.com/nephio-project/porch/pkg/registry/porch"
+	repoimpltypes "github.com/nephio-project/porch/pkg/repoimpl/types"
 	"google.golang.org/api/option"
 	"google.golang.org/api/sts/v1"
 	corev1 "k8s.io/api/core/v1"
@@ -75,13 +76,13 @@ func init() {
 
 // ExtraConfig holds custom apiserver config
 type ExtraConfig struct {
-	CoreAPIKubeconfigPath string
-	CacheDirectory        string
-	FunctionRunnerAddress string
-	DefaultImagePrefix    string
-	RepoSyncFrequency     time.Duration
-	UseGitCaBundle        bool
-	MaxGrpcMessageSize    int
+	CoreAPIKubeconfigPath  string
+	CacheDirectory         string
+	FunctionRunnerAddress  string
+	DefaultImagePrefix     string
+	RepoSyncFrequency      time.Duration
+	UseUserDefinedCaBundle bool
+	MaxGrpcMessageSize     int
 }
 
 // Config defines the config for the apiserver
@@ -228,11 +229,14 @@ func (c completedConfig) New() (*PorchServer, error) {
 
 	watcherMgr := engine.NewWatcherManager()
 
-	memoryCache := memorycache.NewCache(c.ExtraConfig.CacheDirectory, c.ExtraConfig.RepoSyncFrequency, c.ExtraConfig.UseGitCaBundle, memorycache.CacheOptions{
-		CredentialResolver: credentialResolver,
-		UserInfoProvider:   userInfoProvider,
-		MetadataStore:      metadataStore,
-		ObjectNotifier:     watcherMgr,
+	memoryCache := memorycache.NewCache(repoimpltypes.RepoImplOptions{
+		LocalDirectory:         c.ExtraConfig.CacheDirectory,
+		RepoSyncFrequency:      c.ExtraConfig.RepoSyncFrequency,
+		UseUserDefinedCaBundle: c.ExtraConfig.UseUserDefinedCaBundle,
+		CredentialResolver:     credentialResolver,
+		UserInfoProvider:       userInfoProvider,
+		MetadataStore:          metadataStore,
+		ObjectNotifier:         watcherMgr,
 	})
 
 	runnerOptionsResolver := func(namespace string) fnruntime.RunnerOptions {

pkg/cache/memory/cache.go

@@ -16,21 +16,14 @@ package memory
 
 import (
 	"context"
-	"errors"
-	"fmt"
-	"path/filepath"
 	"sync"
-	"time"
 
-	kptoci "github.com/GoogleContainerTools/kpt/pkg/oci"
 	configapi "github.com/nephio-project/porch/api/porchconfig/v1alpha1"
 	"github.com/nephio-project/porch/pkg/cache"
-	"github.com/nephio-project/porch/pkg/git"
-	"github.com/nephio-project/porch/pkg/meta"
-	"github.com/nephio-project/porch/pkg/oci"
+	"github.com/nephio-project/porch/pkg/repoimpl"
+	repoimpltypes "github.com/nephio-project/porch/pkg/repoimpl/types"
 	"github.com/nephio-project/porch/pkg/repository"
 	"go.opentelemetry.io/otel/trace"
-	"k8s.io/apimachinery/pkg/watch"
 )
 
 // Cache allows us to keep state for repositories, rather than querying them every time.
@@ -44,138 +37,57 @@ import (
 // * We Cache flattened tar files in <cacheDir>/oci/ (so we don't need to pull to read resources)
 // * We poll the repositories (every minute) and Cache the discovered images in memory.
 type Cache struct {
-	mutex              sync.Mutex
-	repositories       map[string]*cachedRepository
-	cacheDir           string
-	credentialResolver repository.CredentialResolver
-	userInfoProvider   repository.UserInfoProvider
-	metadataStore      meta.MetadataStore
-	repoSyncFrequency  time.Duration
-	objectNotifier     objectNotifier
-	useGitCaBundle     bool
+	mutex        sync.Mutex
+	repositories map[string]*cachedRepository
+	options      repoimpltypes.RepoImplOptions
 }
 
 var _ cache.Cache = &Cache{}
 
-type objectNotifier interface {
-	NotifyPackageRevisionChange(eventType watch.EventType, obj repository.PackageRevision) int
-}
-
-type CacheOptions struct {
-	CredentialResolver repository.CredentialResolver
-	UserInfoProvider   repository.UserInfoProvider
-	MetadataStore      meta.MetadataStore
-	ObjectNotifier     objectNotifier
-}
-
-func NewCache(cacheDir string, repoSyncFrequency time.Duration, useGitCaBundle bool, opts CacheOptions) *Cache {
+func NewCache(options repoimpltypes.RepoImplOptions) *Cache {
 	return &Cache{
-		repositories:       make(map[string]*cachedRepository),
-		cacheDir:           cacheDir,
-		credentialResolver: opts.CredentialResolver,
-		userInfoProvider:   opts.UserInfoProvider,
-		metadataStore:      opts.MetadataStore,
-		objectNotifier:     opts.ObjectNotifier,
-		repoSyncFrequency:  repoSyncFrequency,
-		useGitCaBundle:     useGitCaBundle,
-	}
-}
-
-func getCacheKey(repositorySpec *configapi.Repository) (string, error) {
-	switch repositoryType := repositorySpec.Spec.Type; repositoryType {
-	case configapi.RepositoryTypeOCI:
-		ociSpec := repositorySpec.Spec.Oci
-		if ociSpec == nil {
-			return "", fmt.Errorf("oci not configured")
-		}
-		return "oci://" + ociSpec.Registry, nil
-
-	case configapi.RepositoryTypeGit:
-		gitSpec := repositorySpec.Spec.Git
-		if gitSpec == nil {
-			return "", errors.New("git property is required")
-		}
-		if gitSpec.Repo == "" {
-			return "", errors.New("git.repo property is required")
-		}
-		return fmt.Sprintf("git://%s/%s@%s/%s", gitSpec.Repo, gitSpec.Directory, repositorySpec.Namespace, repositorySpec.Name), nil
-
-	default:
-		return "", fmt.Errorf("repository type %q not supported", repositoryType)
+		repositories: make(map[string]*cachedRepository),
+		options:      options,
 	}
 }
 
 func (c *Cache) OpenRepository(ctx context.Context, repositorySpec *configapi.Repository) (repository.Repository, error) {
 	ctx, span := tracer.Start(ctx, "Cache::OpenRepository", trace.WithAttributes())
 	defer span.End()
 
-	key, err := getCacheKey(repositorySpec)
+	key, err := repoimpl.RepositoryKey(repositorySpec)
 	if err != nil {
 		return nil, err
 	}
+
 	c.mutex.Lock()
 	defer c.mutex.Unlock()
-	cachedRepo := c.repositories[key]
-
-	switch repositoryType := repositorySpec.Spec.Type; repositoryType {
-	case configapi.RepositoryTypeOCI:
-		ociSpec := repositorySpec.Spec.Oci
-		if cachedRepo == nil {
-			cacheDir := filepath.Join(c.cacheDir, "oci")
-			storage, err := kptoci.NewStorage(cacheDir)
-			if err != nil {
-				return nil, err
-			}
-
-			r, err := oci.OpenRepository(repositorySpec.Name, repositorySpec.Namespace, ociSpec, repositorySpec.Spec.Deployment, storage)
-			if err != nil {
-				return nil, err
-			}
-			cachedRepo = newRepository(key, repositorySpec, r, c.objectNotifier, c.metadataStore, c.repoSyncFrequency)
-			c.repositories[key] = cachedRepo
-		}
-		return cachedRepo, nil
-
-	case configapi.RepositoryTypeGit:
-		gitSpec := repositorySpec.Spec.Git
-		if cachedRepo == nil {
-			var mbs git.MainBranchStrategy
-			if gitSpec.CreateBranch {
-				mbs = git.CreateIfMissing
-			} else {
-				mbs = git.ErrorIfMissing
-			}
-
-			r, err := git.OpenRepository(ctx, repositorySpec.Name, repositorySpec.Namespace, gitSpec, repositorySpec.Spec.Deployment, filepath.Join(c.cacheDir, "git"), git.GitRepositoryOptions{
-				CredentialResolver: c.credentialResolver,
-				UserInfoProvider:   c.userInfoProvider,
-				MainBranchStrategy: mbs,
-				UseGitCaBundle:     c.useGitCaBundle,
-			})
-			if err != nil {
-				return nil, err
-			}
-
-			cachedRepo = newRepository(key, repositorySpec, r, c.objectNotifier, c.metadataStore, c.repoSyncFrequency)
-			c.repositories[key] = cachedRepo
+
+	if cachedRepo := c.repositories[key]; cachedRepo != nil {
+		// If there is an error from the background refresh goroutine, return it.
+		if err := cachedRepo.getRefreshError(); err == nil {
+			return cachedRepo, nil
 		} else {
-			// If there is an error from the background refresh goroutine, return it.
-			if err := cachedRepo.getRefreshError(); err != nil {
-				return nil, err
-			}
+			return nil, err
 		}
-		return cachedRepo, nil
+	}
 
-	default:
-		return nil, fmt.Errorf("type %q not supported", repositoryType)
+	repoImpl, err := repoimpl.RepositoryFactory(ctx, repositorySpec, c.options)
+	if err != nil {
+		return nil, err
 	}
+
+	cachedRepo := newRepository(key, repositorySpec, repoImpl, c.options)
+	c.repositories[key] = cachedRepo
+
+	return cachedRepo, nil
 }
 
 func (c *Cache) CloseRepository(ctx context.Context, repositorySpec *configapi.Repository, allRepos []configapi.Repository) error {
 	_, span := tracer.Start(ctx, "Cache::CloseRepository", trace.WithAttributes())
 	defer span.End()
 
-	key, err := getCacheKey(repositorySpec)
+	key, err := repoimpl.RepositoryKey(repositorySpec)
 	if err != nil {
 		return err
 	}
@@ -185,7 +97,7 @@ func (c *Cache) CloseRepository(ctx context.Context, repositorySpec *configapi.R
 		if r.Name == repositorySpec.Name && r.Namespace == repositorySpec.Namespace {
 			continue
 		}
-		otherKey, err := getCacheKey(&r)
+		otherKey, err := repoimpl.RepositoryKey(&r)
 		if err != nil {
 			return err
 		}

pkg/cache/memory/cache_test.go

@@ -27,17 +27,18 @@ import (
 	"github.com/nephio-project/porch/api/porchconfig/v1alpha1"
 
 	fakecache "github.com/nephio-project/porch/pkg/cache/fake"
-	"github.com/nephio-project/porch/pkg/git"
 	"github.com/nephio-project/porch/pkg/meta"
 	fakemeta "github.com/nephio-project/porch/pkg/meta/fake"
+	"github.com/nephio-project/porch/pkg/repoimpl/git"
+	repoimpltypes "github.com/nephio-project/porch/pkg/repoimpl/types"
 	"github.com/nephio-project/porch/pkg/repository"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"sigs.k8s.io/yaml"
 )
 
 func TestLatestPackages(t *testing.T) {
 	ctx := context.Background()
-	testPath := filepath.Join("..", "..", "git", "testdata")
+	testPath := filepath.Join("..", "..", "repoimpl", "git", "testdata")
 
 	cachedRepo := openRepositoryFromArchive(t, ctx, testPath, "nested")
 
@@ -83,7 +84,7 @@ func TestLatestPackages(t *testing.T) {
 
 func TestPublishedLatest(t *testing.T) {
 	ctx := context.Background()
-	testPath := filepath.Join("..", "..", "git", "testdata")
+	testPath := filepath.Join("..", "..", "repoimpl", "git", "testdata")
 	cachedRepo := openRepositoryFromArchive(t, ctx, testPath, "nested")
 
 	revisions, err := cachedRepo.ListPackageRevisions(ctx, repository.ListPackageRevisionFilter{
@@ -129,7 +130,7 @@ func TestPublishedLatest(t *testing.T) {
 
 func TestDeletePublishedMain(t *testing.T) {
 	ctx := context.Background()
-	testPath := filepath.Join("../..", "git", "testdata")
+	testPath := filepath.Join("../..", "repoimpl", "git", "testdata")
 	cachedRepo := openRepositoryFromArchive(t, ctx, testPath, "nested")
 
 	revisions, err := cachedRepo.ListPackageRevisions(ctx, repository.ListPackageRevisionFilter{
@@ -223,10 +224,13 @@ func openRepositoryFromArchive(t *testing.T, ctx context.Context, testPath, name
 	_, address := git.ServeGitRepository(t, tarfile, tempdir)
 	metadataStore := createMetadataStoreFromArchive(t, fmt.Sprintf("%s-metadata.yaml", name), name)
 
-	cache := NewCache(t.TempDir(), 60*time.Second, true, CacheOptions{
-		MetadataStore:      metadataStore,
-		ObjectNotifier:     &fakecache.ObjectNotifier{},
-		CredentialResolver: &fakecache.CredentialResolver{},
+	cache := NewCache(repoimpltypes.RepoImplOptions{
+		LocalDirectory:         t.TempDir(),
+		RepoSyncFrequency:      60 * time.Second,
+		UseUserDefinedCaBundle: true,
+		MetadataStore:          metadataStore,
+		ObjectNotifier:         &fakecache.ObjectNotifier{},
+		CredentialResolver:     &fakecache.CredentialResolver{},
 	})
 	apiRepo := &v1alpha1.Repository{
 		TypeMeta: metav1.TypeMeta{