package cache
import (
"fmt"
"io"
"io/ioutil"
"os"
"path"
"path/filepath"
"strconv"
"sync"
"github.com/MichaelMure/git-bug/bug"
"github.com/MichaelMure/git-bug/entity"
"github.com/MichaelMure/git-bug/identity"
"github.com/MichaelMure/git-bug/repository"
"github.com/MichaelMure/git-bug/util/process"
"github.com/blevesearch/bleve"
)
// 1: original format
// 2: added cache for identities with a reference in the bug cache
// 3: no more legacy identity
const formatVersion = 3
// The maximum number of bugs loaded in memory. After that, eviction will be done.
const defaultMaxLoadedBugs = 1000
var _ repository.RepoCommon = &RepoCache{}
var _ repository.RepoConfig = &RepoCache{}
var _ repository.RepoKeyring = &RepoCache{}
// RepoCache is a cache for a Repository. This cache has multiple functions:
//
// 1. After being loaded, a Bug is kept in memory in the cache, allowing for fast
// access later.
// 2. The cache maintain in memory and on disk a pre-digested excerpt for each bug,
// allowing for fast querying the whole set of bugs without having to load
// them individually.
// 3. The cache guarantee that a single instance of a Bug is loaded at once, avoiding
// loss of data that we could have with multiple copies in the same process.
// 4. The same way, the cache maintain in memory a single copy of the loaded identities.
//
// The cache also protect the on-disk data by locking the git repository for its
// own usage, by writing a lock file. Of course, normal git operations are not
// affected, only git-bug related one.
type RepoCache struct {
// the underlying repo
repo repository.ClockedRepo
// the name of the repository, as defined in the MultiRepoCache
name string
// maximum number of loaded bugs
maxLoadedBugs int
muBug sync.RWMutex
// excerpt of bugs data for all bugs
bugExcerpts map[entity.Id]*BugExcerpt
// searchable cache of all bugs
searchCache bleve.Index
// bug loaded in memory
bugs map[entity.Id]*BugCache
// loadedBugs is an LRU cache that records which bugs the cache has loaded in
loadedBugs *LRUIdCache
muIdentity sync.RWMutex
// excerpt of identities data for all identities
identitiesExcerpts map[entity.Id]*IdentityExcerpt
// identities loaded in memory
identities map[entity.Id]*IdentityCache
// the user identity's id, if known
userIdentityId entity.Id
}
func NewRepoCache(r repository.ClockedRepo) (*RepoCache, error) {
return NewNamedRepoCache(r, "")
}
func NewNamedRepoCache(r repository.ClockedRepo, name string) (*RepoCache, error) {
c := &RepoCache{
repo: r,
name: name,
maxLoadedBugs: defaultMaxLoadedBugs,
bugs: make(map[entity.Id]*BugCache),
loadedBugs: NewLRUIdCache(),
identities: make(map[entity.Id]*IdentityCache),
}
err := c.lock()
if err != nil {
return &RepoCache{}, err
}
err = c.load()
if err == nil {
return c, nil
}
// Cache is either missing, broken or outdated. Rebuilding.
err = c.buildCache()
if err != nil {
return nil, err
}
return c, c.write()
}
// setCacheSize change the maximum number of loaded bugs
func (c *RepoCache) setCacheSize(size int) {
c.maxLoadedBugs = size
c.evictIfNeeded()
}
// load will try to read from the disk all the cache files
func (c *RepoCache) load() error {
err := c.loadBugCache()
if err != nil {
return err
}
return c.loadIdentityCache()
}
// write will serialize on disk all the cache files
func (c *RepoCache) write() error {
err := c.writeBugCache()
if err != nil {
return err
}
return c.writeIdentityCache()
}
func (c *RepoCache) lock() error {
lockPath := repoLockFilePath(c.repo)
err := repoIsAvailable(c.repo)
if err != nil {
return err
}
err = os.MkdirAll(filepath.Dir(lockPath), 0777)
if err != nil {
return err
}
f, err := os.Create(lockPath)
if err != nil {
return err
}
pid := fmt.Sprintf("%d", os.Getpid())
_, err = f.WriteString(pid)
if err != nil {
return err
}
return f.Close()
}
func (c *RepoCache) Close() error {
c.muBug.Lock()
defer c.muBug.Unlock()
c.muIdentity.Lock()
defer c.muIdentity.Unlock()
c.identities = make(map[entity.Id]*IdentityCache)
c.identitiesExcerpts = nil
c.bugs = make(map[entity.Id]*BugCache)
c.bugExcerpts = nil
if c.searchCache != nil {
c.searchCache.Close()
c.searchCache = nil
}
lockPath := repoLockFilePath(c.repo)
return os.Remove(lockPath)
}
func (c *RepoCache) buildCache() error {
c.muBug.Lock()
defer c.muBug.Unlock()
c.muIdentity.Lock()
defer c.muIdentity.Unlock()
_, _ = fmt.Fprintf(os.Stderr, "Building identity cache... ")
c.identitiesExcerpts = make(map[entity.Id]*IdentityExcerpt)
allIdentities := identity.ReadAllLocal(c.repo)
for i := range allIdentities {
if i.Err != nil {
return i.Err
}
c.identitiesExcerpts[i.Identity.Id()] = NewIdentityExcerpt(i.Identity)
}
_, _ = fmt.Fprintln(os.Stderr, "Done.")
_, _ = fmt.Fprintf(os.Stderr, "Building bug cache... ")
c.bugExcerpts = make(map[entity.Id]*BugExcerpt)
allBugs := bug.ReadAllLocal(c.repo)
err := c.createBleveIndex()
if err != nil {
return fmt.Errorf("Unable to create search cache. Error: %v", err)
}
for b := range allBugs {
if b.Err != nil {
return b.Err
}
snap := b.Bug.Compile()
c.bugExcerpts[b.Bug.Id()] = NewBugExcerpt(b.Bug, &snap)
if err := c.addBugToSearchIndex(&snap); err != nil {
return err
}
}
_, _ = fmt.Fprintln(os.Stderr, "Done.")
return nil
}
func repoLockFilePath(repo repository.Repo) string {
return path.Join(repo.GetPath(), "git-bug", lockfile)
}
// repoIsAvailable check is the given repository is locked by a Cache.
// Note: this is a smart function that will cleanup the lock file if the
// corresponding process is not there anymore.
// If no error is returned, the repo is free to edit.
func repoIsAvailable(repo repository.Repo) error {
lockPath := repoLockFilePath(repo)
// Todo: this leave way for a racey access to the repo between the test
// if the file exist and the actual write. It's probably not a problem in
// practice because using a repository will be done from user interaction
// or in a context where a single instance of git-bug is already guaranteed
// (say, a server with the web UI running). But still, that might be nice to
// have a mutex or something to guard that.
// Todo: this will fail if somehow the filesystem is shared with another
// computer. Should add a configuration that prevent the cleaning of the
// lock file
f, err := os.Open(lockPath)
if err != nil && !os.IsNotExist(err) {
return err
}
if err == nil {
// lock file already exist
buf, err := ioutil.ReadAll(io.LimitReader(f, 10))
if err != nil {
return err
}
if len(buf) == 10 {
return fmt.Errorf("the lock file should be < 10 bytes")
}
pid, err := strconv.Atoi(string(buf))
if err != nil {
return err
}
if process.IsRunning(pid) {
return fmt.Errorf("the repository you want to access is already locked by the process pid %d", pid)
}
// The lock file is just laying there after a crash, clean it
fmt.Println("A lock file is present but the corresponding process is not, removing it.")
err = f.Close()
if err != nil {
return err
}
err = os.Remove(lockPath)
if err != nil {
return err
}
}
return nil
}
