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