1package cache
  2
  3import (
  4	"fmt"
  5
  6	"github.com/git-bug/git-bug/repository"
  7)
  8
  9const lockfile = "lock"
 10const defaultRepoName = "__default"
 11
 12// MultiRepoCache is the root cache, holding multiple RepoCache.
 13type MultiRepoCache struct {
 14	repos map[string]*RepoCache
 15}
 16
 17func NewMultiRepoCache() *MultiRepoCache {
 18	return &MultiRepoCache{
 19		repos: make(map[string]*RepoCache),
 20	}
 21}
 22
 23// RegisterRepository registers a named repository. Use this for multi-repo setup
 24func (c *MultiRepoCache) RegisterRepository(repo repository.ClockedRepo, name string) (*RepoCache, chan BuildEvent) {
 25	r, events := NewNamedRepoCache(repo, name)
 26
 27	// intercept events to make sure the cache building process succeeds properly
 28	out := make(chan BuildEvent)
 29	go func() {
 30		defer close(out)
 31
 32		for event := range events {
 33			out <- event
 34			if event.Err != nil {
 35				return
 36			}
 37		}
 38
 39		c.repos[name] = r
 40	}()
 41
 42	return r, out
 43}
 44
 45// RegisterDefaultRepository registers an unnamed repository. Use this for single-repo setup
 46func (c *MultiRepoCache) RegisterDefaultRepository(repo repository.ClockedRepo) (*RepoCache, chan BuildEvent) {
 47	return c.RegisterRepository(repo, defaultRepoName)
 48}
 49
 50// DefaultRepo retrieves the default repository
 51func (c *MultiRepoCache) DefaultRepo() (*RepoCache, error) {
 52	if len(c.repos) != 1 {
 53		return nil, fmt.Errorf("repository is not unique")
 54	}
 55
 56	for _, r := range c.repos {
 57		return r, nil
 58	}
 59
 60	panic("unreachable")
 61}
 62
 63// ResolveRepo retrieve a repository by name or slug
 64func (c *MultiRepoCache) ResolveRepo(ref string) (*RepoCache, error) {
 65	// Direct name lookup first
 66	if r, ok := c.repos[ref]; ok {
 67		return r, nil
 68	}
 69	// Slug lookup fallback — allows using the human-readable slug (derived
 70	// from the path basename) instead of the internal cache name.
 71	for _, r := range c.repos {
 72		if r.Slug() == ref {
 73			return r, nil
 74		}
 75	}
 76	return nil, fmt.Errorf("unknown repo %q", ref)
 77}
 78
 79// AllRepos returns all registered repositories. Order is not guaranteed.
 80func (c *MultiRepoCache) AllRepos() []*RepoCache {
 81	result := make([]*RepoCache, 0, len(c.repos))
 82	for _, r := range c.repos {
 83		result = append(result, r)
 84	}
 85	return result
 86}
 87
 88// RegisterObserver registers an Observer on repo and entity, according to nameFilter and typename.
 89// - if nameFilter is empty, the observer is registered on all available repo
 90// - if nameFilter is not empty, the observer is registered on the repo with the matching name
 91// - if typename is empty, the observer is registered on all available entities
 92// - if typename is not empty, the observer is registered on the matching entity type only
 93func (c *MultiRepoCache) RegisterObserver(observer Observer, nameFilter string, typename string) error {
 94	if nameFilter == "" {
 95		for repoName, repo := range c.repos {
 96			if typename == "" {
 97				repo.registerAllObservers(repoName, observer)
 98			} else {
 99				if err := repo.registerObserver(repoName, typename, observer); err != nil {
100					return err
101				}
102			}
103		}
104		return nil
105	}
106
107	r, err := c.ResolveRepo(nameFilter)
108	if err != nil {
109		return err
110	}
111	if typename == "" {
112		r.registerAllObservers(r.Name(), observer)
113	} else {
114		if err := r.registerObserver(r.Name(), typename, observer); err != nil {
115			return err
116		}
117	}
118	return nil
119}
120
121// UnregisterObserver deregisters the observer from all repos and all entity types.
122func (c *MultiRepoCache) UnregisterObserver(observer Observer) {
123	for _, repo := range c.repos {
124		repo.unregisterAllObservers(observer)
125	}
126}
127
128// Close will do anything that is needed to close the cache properly
129func (c *MultiRepoCache) Close() error {
130	for _, cachedRepo := range c.repos {
131		err := cachedRepo.Close()
132		if err != nil {
133			return err
134		}
135	}
136	return nil
137}