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 retrieves a repository by name
 64func (c *MultiRepoCache) ResolveRepo(name string) (*RepoCache, error) {
 65	r, ok := c.repos[name]
 66	if !ok {
 67		return nil, fmt.Errorf("unknown repo")
 68	}
 69	return r, nil
 70}
 71
 72// AllRepos returns all registered repositories. Order is not guaranteed.
 73func (c *MultiRepoCache) AllRepos() []*RepoCache {
 74	result := make([]*RepoCache, 0, len(c.repos))
 75	for _, r := range c.repos {
 76		result = append(result, r)
 77	}
 78	return result
 79}
 80
 81// RegisterObserver registers an Observer on repo and entity, according to nameFilter and typename.
 82// - if nameFilter is empty, the observer is registered on all available repo
 83// - if nameFilter is not empty, the observer is registered on the repo with the matching name
 84// - if typename is empty, the observer is registered on all available entities
 85// - if typename is not empty, the observer is registered on the matching entity type only
 86func (c *MultiRepoCache) RegisterObserver(observer Observer, nameFilter string, typename string) error {
 87	if nameFilter == "" {
 88		for repoName, repo := range c.repos {
 89			if typename == "" {
 90				repo.registerAllObservers(repoName, observer)
 91			} else {
 92				if err := repo.registerObserver(repoName, typename, observer); err != nil {
 93					return err
 94				}
 95			}
 96		}
 97		return nil
 98	}
 99
100	r, err := c.ResolveRepo(nameFilter)
101	if err != nil {
102		return err
103	}
104	if typename == "" {
105		r.registerAllObservers(r.Name(), observer)
106	} else {
107		if err := r.registerObserver(r.Name(), typename, observer); err != nil {
108			return err
109		}
110	}
111	return nil
112}
113
114// UnregisterObserver deregisters the observer from all repos and all entity types.
115func (c *MultiRepoCache) UnregisterObserver(observer Observer) {
116	for _, repo := range c.repos {
117		repo.unregisterAllObservers(observer)
118	}
119}
120
121// Close will do anything that is needed to close the cache properly
122func (c *MultiRepoCache) Close() error {
123	for _, cachedRepo := range c.repos {
124		err := cachedRepo.Close()
125		if err != nil {
126			return err
127		}
128	}
129	return nil
130}