1package cache
2
3import (
4 "bytes"
5 "encoding/gob"
6 "errors"
7 "fmt"
8 "sort"
9 "time"
10
11 "github.com/MichaelMure/git-bug/bug"
12 "github.com/MichaelMure/git-bug/entity"
13 "github.com/MichaelMure/git-bug/query"
14 "github.com/MichaelMure/git-bug/repository"
15)
16
17const bugCacheFile = "bug-cache"
18
19var errBugNotInCache = errors.New("bug missing from cache")
20
21// bugUpdated is a callback to trigger when the excerpt of a bug changed,
22// that is each time a bug is updated
23func (c *RepoCache) bugUpdated(id entity.Id) error {
24 c.muBug.Lock()
25 b, ok := c.bugs[id]
26 if !ok {
27 c.muBug.Unlock()
28
29 // if the bug is not loaded at this point, it means it was loaded before
30 // but got evicted. Which means we potentially have multiple copies in
31 // memory and thus concurrent write.
32 // Failing immediately here is the simple and safe solution to avoid
33 // complicated data loss.
34 return errBugNotInCache
35 }
36 c.loadedBugs.Get(id)
37 c.bugExcerpts[id] = NewBugExcerpt(b.bug, b.Snapshot())
38 c.muBug.Unlock()
39
40 // we only need to write the bug cache
41 return c.writeBugCache()
42}
43
44// load will try to read from the disk the bug cache file
45func (c *RepoCache) loadBugCache() error {
46 c.muBug.Lock()
47 defer c.muBug.Unlock()
48
49 f, err := c.repo.LocalStorage().Open(bugCacheFile)
50 if err != nil {
51 return err
52 }
53
54 decoder := gob.NewDecoder(f)
55
56 aux := struct {
57 Version uint
58 Excerpts map[entity.Id]*BugExcerpt
59 }{}
60
61 err = decoder.Decode(&aux)
62 if err != nil {
63 return err
64 }
65
66 if aux.Version != formatVersion {
67 return fmt.Errorf("unknown cache format version %v", aux.Version)
68 }
69
70 c.bugExcerpts = aux.Excerpts
71 return nil
72}
73
74// write will serialize on disk the bug cache file
75func (c *RepoCache) writeBugCache() error {
76 c.muBug.RLock()
77 defer c.muBug.RUnlock()
78
79 var data bytes.Buffer
80
81 aux := struct {
82 Version uint
83 Excerpts map[entity.Id]*BugExcerpt
84 }{
85 Version: formatVersion,
86 Excerpts: c.bugExcerpts,
87 }
88
89 encoder := gob.NewEncoder(&data)
90
91 err := encoder.Encode(aux)
92 if err != nil {
93 return err
94 }
95
96 f, err := c.repo.LocalStorage().Create(bugCacheFile)
97 if err != nil {
98 return err
99 }
100
101 _, err = f.Write(data.Bytes())
102 if err != nil {
103 return err
104 }
105
106 return f.Close()
107}
108
109// ResolveBugExcerpt retrieve a BugExcerpt matching the exact given id
110func (c *RepoCache) ResolveBugExcerpt(id entity.Id) (*BugExcerpt, error) {
111 c.muBug.RLock()
112 defer c.muBug.RUnlock()
113
114 excerpt, ok := c.bugExcerpts[id]
115 if !ok {
116 return nil, bug.ErrBugNotExist
117 }
118
119 return excerpt, nil
120}
121
122// ResolveBug retrieve a bug matching the exact given id
123func (c *RepoCache) ResolveBug(id entity.Id) (*BugCache, error) {
124 c.muBug.RLock()
125 cached, ok := c.bugs[id]
126 if ok {
127 c.loadedBugs.Get(id)
128 c.muBug.RUnlock()
129 return cached, nil
130 }
131 c.muBug.RUnlock()
132
133 b, err := bug.ReadLocalWithResolver(c.repo, newIdentityCacheResolver(c), id)
134 if err != nil {
135 return nil, err
136 }
137
138 cached = NewBugCache(c, b)
139
140 c.muBug.Lock()
141 c.bugs[id] = cached
142 c.loadedBugs.Add(id)
143 c.muBug.Unlock()
144
145 c.evictIfNeeded()
146
147 return cached, nil
148}
149
150// evictIfNeeded will evict a bug from the cache if needed
151// it also removes references of the bug from the bugs
152func (c *RepoCache) evictIfNeeded() {
153 c.muBug.Lock()
154 defer c.muBug.Unlock()
155 if c.loadedBugs.Len() <= c.maxLoadedBugs {
156 return
157 }
158
159 for _, id := range c.loadedBugs.GetOldestToNewest() {
160 b := c.bugs[id]
161 if b.NeedCommit() {
162 continue
163 }
164
165 b.mu.Lock()
166 c.loadedBugs.Remove(id)
167 delete(c.bugs, id)
168
169 if c.loadedBugs.Len() <= c.maxLoadedBugs {
170 return
171 }
172 }
173}
174
175// ResolveBugExcerptPrefix retrieve a BugExcerpt matching an id prefix. It fails if multiple
176// bugs match.
177func (c *RepoCache) ResolveBugExcerptPrefix(prefix string) (*BugExcerpt, error) {
178 return c.ResolveBugExcerptMatcher(func(excerpt *BugExcerpt) bool {
179 return excerpt.Id.HasPrefix(prefix)
180 })
181}
182
183// ResolveBugPrefix retrieve a bug matching an id prefix. It fails if multiple
184// bugs match.
185func (c *RepoCache) ResolveBugPrefix(prefix string) (*BugCache, error) {
186 return c.ResolveBugMatcher(func(excerpt *BugExcerpt) bool {
187 return excerpt.Id.HasPrefix(prefix)
188 })
189}
190
191// ResolveBugCreateMetadata retrieve a bug that has the exact given metadata on
192// its Create operation, that is, the first operation. It fails if multiple bugs
193// match.
194func (c *RepoCache) ResolveBugCreateMetadata(key string, value string) (*BugCache, error) {
195 return c.ResolveBugMatcher(func(excerpt *BugExcerpt) bool {
196 return excerpt.CreateMetadata[key] == value
197 })
198}
199
200func (c *RepoCache) ResolveBugExcerptMatcher(f func(*BugExcerpt) bool) (*BugExcerpt, error) {
201 id, err := c.resolveBugMatcher(f)
202 if err != nil {
203 return nil, err
204 }
205 return c.ResolveBugExcerpt(id)
206}
207
208func (c *RepoCache) ResolveBugMatcher(f func(*BugExcerpt) bool) (*BugCache, error) {
209 id, err := c.resolveBugMatcher(f)
210 if err != nil {
211 return nil, err
212 }
213 return c.ResolveBug(id)
214}
215
216func (c *RepoCache) resolveBugMatcher(f func(*BugExcerpt) bool) (entity.Id, error) {
217 c.muBug.RLock()
218 defer c.muBug.RUnlock()
219
220 // preallocate but empty
221 matching := make([]entity.Id, 0, 5)
222
223 for _, excerpt := range c.bugExcerpts {
224 if f(excerpt) {
225 matching = append(matching, excerpt.Id)
226 }
227 }
228
229 if len(matching) > 1 {
230 return entity.UnsetId, bug.NewErrMultipleMatchBug(matching)
231 }
232
233 if len(matching) == 0 {
234 return entity.UnsetId, bug.ErrBugNotExist
235 }
236
237 return matching[0], nil
238}
239
240// QueryBugs return the id of all Bug matching the given Query
241func (c *RepoCache) QueryBugs(q *query.Query) []entity.Id {
242 c.muBug.RLock()
243 defer c.muBug.RUnlock()
244
245 if q == nil {
246 return c.AllBugsIds()
247 }
248
249 matcher := compileMatcher(q.Filters)
250
251 var filtered []*BugExcerpt
252
253 for _, excerpt := range c.bugExcerpts {
254 if matcher.Match(excerpt, c) {
255 filtered = append(filtered, excerpt)
256 }
257 }
258
259 var sorter sort.Interface
260
261 switch q.OrderBy {
262 case query.OrderById:
263 sorter = BugsById(filtered)
264 case query.OrderByCreation:
265 sorter = BugsByCreationTime(filtered)
266 case query.OrderByEdit:
267 sorter = BugsByEditTime(filtered)
268 default:
269 panic("missing sort type")
270 }
271
272 switch q.OrderDirection {
273 case query.OrderAscending:
274 // Nothing to do
275 case query.OrderDescending:
276 sorter = sort.Reverse(sorter)
277 default:
278 panic("missing sort direction")
279 }
280
281 sort.Sort(sorter)
282
283 result := make([]entity.Id, len(filtered))
284
285 for i, val := range filtered {
286 result[i] = val.Id
287 }
288
289 return result
290}
291
292// AllBugsIds return all known bug ids
293func (c *RepoCache) AllBugsIds() []entity.Id {
294 c.muBug.RLock()
295 defer c.muBug.RUnlock()
296
297 result := make([]entity.Id, len(c.bugExcerpts))
298
299 i := 0
300 for _, excerpt := range c.bugExcerpts {
301 result[i] = excerpt.Id
302 i++
303 }
304
305 return result
306}
307
308// ValidLabels list valid labels
309//
310// Note: in the future, a proper label policy could be implemented where valid
311// labels are defined in a configuration file. Until that, the default behavior
312// is to return the list of labels already used.
313func (c *RepoCache) ValidLabels() []bug.Label {
314 c.muBug.RLock()
315 defer c.muBug.RUnlock()
316
317 set := map[bug.Label]interface{}{}
318
319 for _, excerpt := range c.bugExcerpts {
320 for _, l := range excerpt.Labels {
321 set[l] = nil
322 }
323 }
324
325 result := make([]bug.Label, len(set))
326
327 i := 0
328 for l := range set {
329 result[i] = l
330 i++
331 }
332
333 // Sort
334 sort.Slice(result, func(i, j int) bool {
335 return string(result[i]) < string(result[j])
336 })
337
338 return result
339}
340
341// NewBug create a new bug
342// The new bug is written in the repository (commit)
343func (c *RepoCache) NewBug(title string, message string) (*BugCache, *bug.CreateOperation, error) {
344 return c.NewBugWithFiles(title, message, nil)
345}
346
347// NewBugWithFiles create a new bug with attached files for the message
348// The new bug is written in the repository (commit)
349func (c *RepoCache) NewBugWithFiles(title string, message string, files []repository.Hash) (*BugCache, *bug.CreateOperation, error) {
350 author, err := c.GetUserIdentity()
351 if err != nil {
352 return nil, nil, err
353 }
354
355 return c.NewBugRaw(author, time.Now().Unix(), title, message, files, nil)
356}
357
358// NewBugWithFilesMeta create a new bug with attached files for the message, as
359// well as metadata for the Create operation.
360// The new bug is written in the repository (commit)
361func (c *RepoCache) NewBugRaw(author *IdentityCache, unixTime int64, title string, message string, files []repository.Hash, metadata map[string]string) (*BugCache, *bug.CreateOperation, error) {
362 b, op, err := bug.CreateWithFiles(author.Identity, unixTime, title, message, files)
363 if err != nil {
364 return nil, nil, err
365 }
366
367 for key, value := range metadata {
368 op.SetMetadata(key, value)
369 }
370
371 err = b.Commit(c.repo)
372 if err != nil {
373 return nil, nil, err
374 }
375
376 c.muBug.Lock()
377 if _, has := c.bugs[b.Id()]; has {
378 c.muBug.Unlock()
379 return nil, nil, fmt.Errorf("bug %s already exist in the cache", b.Id())
380 }
381
382 cached := NewBugCache(c, b)
383 c.bugs[b.Id()] = cached
384 c.loadedBugs.Add(b.Id())
385 c.muBug.Unlock()
386
387 c.evictIfNeeded()
388
389 // force the write of the excerpt
390 err = c.bugUpdated(b.Id())
391 if err != nil {
392 return nil, nil, err
393 }
394
395 return cached, op, nil
396}
397
398// RemoveBug removes a bug from the cache and repo given a bug id prefix
399func (c *RepoCache) RemoveBug(prefix string) error {
400 c.muBug.RLock()
401
402 b, err := c.ResolveBugPrefix(prefix)
403 if err != nil {
404 c.muBug.RUnlock()
405 return err
406 }
407 c.muBug.RUnlock()
408
409 c.muBug.Lock()
410 err = bug.RemoveBug(c.repo, b.Id())
411
412 delete(c.bugs, b.Id())
413 delete(c.bugExcerpts, b.Id())
414 c.loadedBugs.Remove(b.Id())
415
416 c.muBug.Unlock()
417
418 return c.writeBugCache()
419}