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