Merge pull request #4 from gov4git/cache

local disk cache + auth in context

Author: petar

TODO.md

@@ -1 +1,2 @@
-- [ ] local cache for remote repos
+- [√] local cache for remote repos
+- [√] auth in context

git/auth.go

@@ -24,18 +24,26 @@ func MakeSSHFileAuth(ctx context.Context, user string, privKeyFile string) trans
 	return pubKey
 }
 
-// global repo-dependent auth
+// auth manager in context
 
-var authManager = NewAuthManager()
+type contextKeyAuthManager struct{}
 
-func SetAuth(forRepo URL, a transport.AuthMethod) {
-	authManager.SetAuth(forRepo, a)
+func WithAuth(ctx context.Context, am *AuthManager) context.Context {
+	if am == nil {
+		am = NewAuthManager()
+	}
+	return context.WithValue(ctx, contextKeyAuthManager{}, am)
+}
+
+func SetAuth(ctx context.Context, forRepo URL, a transport.AuthMethod) {
+	ctx.Value(contextKeyAuthManager{}).(*AuthManager).SetAuth(forRepo, a)
 }
 
 func GetAuth(ctx context.Context, forRepo URL) transport.AuthMethod {
-	return authManager.GetAuth(ctx, forRepo)
+	return ctx.Value(contextKeyAuthManager{}).(*AuthManager).GetAuth(forRepo)
 }
 
+// AuthManager provides authentication methods given a repo URL.
 type AuthManager struct {
 	lk  sync.Mutex
 	url map[URL]transport.AuthMethod
@@ -51,7 +59,7 @@ func (x *AuthManager) SetAuth(forRepo URL, a transport.AuthMethod) {
 	x.url[forRepo] = a
 }
 
-func (x *AuthManager) GetAuth(ctx context.Context, forRepo URL) transport.AuthMethod {
+func (x *AuthManager) GetAuth(forRepo URL) transport.AuthMethod {
 	x.lk.Lock()
 	defer x.lk.Unlock()
 	return x.url[forRepo]

git/cache.go

@@ -6,28 +6,77 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/gov4git/lib4git/base"
+	"github.com/gov4git/lib4git/must"
+)
+
+var (
+	testBranch  = Branch("test")
+	test2Branch = Branch("test2")
+	test3Branch = Branch("test3")
 )
 
 func TestCache(t *testing.T) {
 	base.LogVerbosely()
-	ctx := context.Background()
+	ctx := WithAuth(context.Background(), nil)
 
 	dir := t.TempDir()
 	fmt.Println("test root ", dir)
 	originDir := filepath.Join(dir, "origin")
 	cacheDir := filepath.Join(dir, "cache")
-	originAddr := Address{Repo: URL(originDir), Branch: MainBranch}
+	originAddr := Address{Repo: URL(originDir), Branch: testBranch}
 
+	// init origin and cache
 	InitPlain(ctx, originDir, true)
-	cache := NewCache(ctx, cacheDir)
+	cache := NewMirrorCache(ctx, cacheDir)
+
 	cloned1 := cache.Clone(ctx, originAddr)
-	populate(ctx, cloned1.Repo(), "hi", true)
+	populateNonce(ctx, cloned1.Repo(), "ok1")
 	cloned1.Push(ctx)
 
 	cloned2 := cache.Clone(ctx, originAddr)
-	populate(ctx, cloned2.Repo(), "ok", false)
+	findNonce(ctx, cloned2.Repo(), "ok1")
+	populateNonce(ctx, cloned2.Repo(), "ok2")
+	cloned2.Tree().Checkout(&git.CheckoutOptions{
+		Branch: plumbing.NewBranchReferenceName(string(test2Branch)),
+		Create: true,
+	})
+	populateNonce(ctx, cloned2.Repo(), "ok3")
 	cloned2.Push(ctx)
 
+	cloned3 := cache.Clone(ctx, Address{Repo: URL(originDir), Branch: test3Branch})
+	populateNonce(ctx, cloned3.Repo(), "ok5")
+	cloned3.Push(ctx)
+
+	cloned4 := cache.Clone(ctx, Address{Repo: URL(originDir), Branch: test2Branch})
+	findNonce(ctx, cloned4.Repo(), "ok3")
+	populateNonce(ctx, cloned4.Repo(), "ok6")
+	cloned4.Push(ctx)
+
 	// <-(chan int)(nil)
 }
+
+func populateNonce(ctx context.Context, r *git.Repository, nonce string) {
+	w, err := r.Worktree()
+	must.NoError(ctx, err)
+
+	f, err := w.Filesystem.Create(nonce)
+	must.NoError(ctx, err)
+	f.Write([]byte(nonce))
+	err = f.Close()
+	must.NoError(ctx, err)
+	_, err = w.Add(nonce)
+	must.NoError(ctx, err)
+	_, err = w.Commit(nonce, &git.CommitOptions{})
+	must.NoError(ctx, err)
+}
+
+func findNonce(ctx context.Context, r *git.Repository, nonce string) {
+	w, err := r.Worktree()
+	must.NoError(ctx, err)
+
+	_, err = w.Filesystem.Stat(nonce)
+	must.NoError(ctx, err)
+}

git/cache_test.go

@@ -0,0 +1,37 @@
+package git
+
+import (
+	"context"
+	"sync"
+)
+
+var (
+	cacheLk sync.Mutex
+	proxy   Proxy
+)
+
+func UseCache(ctx context.Context, dir string) {
+	cacheLk.Lock()
+	defer cacheLk.Unlock()
+	proxy = NewMirrorCache(ctx, dir)
+}
+
+func getProxy() Proxy {
+	cacheLk.Lock()
+	defer cacheLk.Unlock()
+	return proxy
+}
+
+func Clone(ctx context.Context, addr Address) Cloned {
+	if pxy := getProxy(); pxy != nil {
+		return pxy.Clone(ctx, addr)
+	}
+	return GitClone(ctx, addr)
+}
+
+func CloneOrInit(ctx context.Context, addr Address) Cloned {
+	if pxy := getProxy(); pxy != nil {
+		return pxy.Clone(ctx, addr)
+	}
+	return GitCloneOrInit(ctx, addr)
+}

git/clone.go

@@ -18,19 +18,18 @@ import (
 func Embed(
 	ctx context.Context,
 	repo *Repository,
-	keys []string,
 	addrs []Address,
 	toBranch Branch,
 	toNS []ns.NS,
 	allowOverride bool,
 ) {
 
 	// fetch remotes
-	must.Assertf(ctx, len(toNS) == len(addrs) && len(keys) == len(addrs), "names and keys must match addresses")
-	remoteTreeHashes := make([]plumbing.Hash, len(keys))
-	remoteCommitHashes := make([]plumbing.Hash, len(keys))
-	for i := range keys {
-		remoteCommit := fetchEmbedding(ctx, repo, keys[i], addrs[i])
+	must.Assertf(ctx, len(toNS) == len(addrs), "namespaces and addresses must be same count")
+	remoteTreeHashes := make([]plumbing.Hash, len(addrs))
+	remoteCommitHashes := make([]plumbing.Hash, len(addrs))
+	for i := range addrs {
+		remoteCommit := fetchEmbedding(ctx, repo, addrs[i])
 		remoteTreeHashes[i] = PrefixTree(ctx, repo, toNS[i], remoteCommit.TreeHash) // prefix with namespace
 		remoteCommitHashes[i] = remoteCommit.Hash
 	}
@@ -64,14 +63,10 @@ func Embed(
 	must.NoError(ctx, err)
 }
 
-func fetchEmbedding(
-	ctx context.Context,
-	repo *Repository,
-	key string,
-	addr Address,
-) object.Commit {
+func fetchEmbedding(ctx context.Context, repo *Repository, addr Address) object.Commit {
 
 	// fetch remote branch using an ephemeral definition of the remote (not stored in the repo)
+	key := addr.Hash()
 	nonce := "embedding-" + strconv.FormatUint(uint64(rand.Int63()), 36)
 	remoteBranchName := plumbing.NewBranchReferenceName(string(addr.Branch))
 	embeddedBranchName := plumbing.NewBranchReferenceName(filepath.Join("embedding", key))

git/embed.go

@@ -33,7 +33,6 @@ func TestEmbed(t *testing.T) {
 	Embed(
 		ctx,
 		r1,
-		[]string{"r2", "r3"},
 		[]Address{
 			{Repo: URL(dir2), Branch: Branch(MainBranch)},
 			{Repo: URL(dir3), Branch: Branch(MainBranch)},
@@ -50,7 +49,6 @@ func TestEmbed(t *testing.T) {
 	Embed(
 		ctx,
 		r1,
-		[]string{"r2", "r3"},
 		[]Address{
 			{Repo: URL(dir2), Branch: Branch(MainBranch)},
 			{Repo: URL(dir3), Branch: Branch(MainBranch)},