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