package store import ( "bytes" "encoding/json" "fmt" "os" "path" "strings" "git.sr.ht/~rjarry/aerc/lib/pama/models" "git.sr.ht/~rjarry/aerc/lib/xdg" "git.sr.ht/~rjarry/aerc/log" "github.com/syndtr/goleveldb/leveldb" ) const ( keyPrefix = "project." ) var ( // versTag should be incremented when the underyling data structure // changes. versTag = []byte("0001") versTagKey = []byte("version.tag") currentKey = []byte("current.project") ) func createKey(name string) []byte { return []byte(keyPrefix + name) } func parseKey(key []byte) string { return strings.TrimPrefix(string(key), keyPrefix) } func isProjectKey(key []byte) bool { return bytes.HasPrefix(key, []byte(keyPrefix)) } func cacheDir() (string, error) { dir, err := os.UserCacheDir() if err != nil { dir = xdg.ExpandHome("~/.cache") } return path.Join(dir, "aerc"), nil } func openStorage() (*leveldb.DB, error) { cd, err := cacheDir() if err != nil { return nil, fmt.Errorf("Unable to find project store directory: %w", err) } p := path.Join(cd, "projects") db, err := leveldb.OpenFile(p, nil) if err != nil { return nil, fmt.Errorf("Unable to open project store: %w", err) } has, err := db.Has(versTagKey, nil) if err != nil { return nil, err } setTag := !has if has { vers, err := db.Get(versTagKey, nil) if err != nil { return nil, err } if !bytes.Equal(vers, versTag) { log.Warnf("patch store: version mismatch: wipe data") iter := db.NewIterator(nil, nil) for iter.Next() { err := db.Delete(iter.Key(), nil) if err != nil { log.Errorf("delete: %v") } } iter.Release() setTag = true } } if setTag { err := db.Put(versTagKey, versTag, nil) if err != nil { return nil, err } log.Infof("patch store: set version: %s", string(versTag)) } return db, nil } func encode(p models.Project) ([]byte, error) { return json.Marshal(p) } func decode(data []byte) (p models.Project, err error) { err = json.Unmarshal(data, &p) return } func Store() models.PersistentStorer { return &instance{} } type instance struct{} func (instance) StoreProject(p models.Project, overwrite bool) error { db, err := openStorage() if err != nil { return err } defer db.Close() key := createKey(p.Name) has, err := db.Has(key, nil) if err != nil { return err } if has && !overwrite { return fmt.Errorf("Project '%s' already exists.", p.Name) } log.Debugf("project data: %v", p) encoded, err := encode(p) if err != nil { return err } return db.Put(key, encoded, nil) } func (instance) DeleteProject(name string) error { db, err := openStorage() if err != nil { return err } defer db.Close() key := createKey(name) has, err := db.Has(key, nil) if err != nil { return err } if !has { return fmt.Errorf("Project does not exist.") } return db.Delete(key, nil) } func (instance) CurrentName() (string, error) { db, err := openStorage() if err != nil { return "", err } defer db.Close() cur, err := db.Get(currentKey, nil) if err != nil { return "", err } return parseKey(cur), nil } func (instance) SetCurrent(name string) error { db, err := openStorage() if err != nil { return err } defer db.Close() key := createKey(name) return db.Put(currentKey, key, nil) } func (instance) Current() (models.Project, error) { db, err := openStorage() if err != nil { return models.Project{}, err } defer db.Close() has, err := db.Has(currentKey, nil) if err != nil { return models.Project{}, err } if !has { return models.Project{}, fmt.Errorf("No (current) project found; run 'project init' first.") } curProjectKey, err := db.Get(currentKey, nil) if err != nil { return models.Project{}, err } raw, err := db.Get(curProjectKey, nil) if err != nil { return models.Project{}, err } p, err := decode(raw) if err != nil { return models.Project{}, err } return p, nil } func (instance) Names() ([]string, error) { db, err := openStorage() if err != nil { return nil, err } defer db.Close() var names []string iter := db.NewIterator(nil, nil) for iter.Next() { if !isProjectKey(iter.Key()) { continue } names = append(names, parseKey(iter.Key())) } iter.Release() return names, nil } func (instance) Project(name string) (models.Project, error) { db, err := openStorage() if err != nil { return models.Project{}, err } defer db.Close() raw, err := db.Get(createKey(name), nil) if err != nil { return models.Project{}, err } p, err := decode(raw) if err != nil { return models.Project{}, err } return p, nil } func (instance) Projects() ([]models.Project, error) { var projects []models.Project db, err := openStorage() if err != nil { return nil, err } defer db.Close() iter := db.NewIterator(nil, nil) for iter.Next() { if !isProjectKey(iter.Key()) { continue } p, err := decode(iter.Value()) if err != nil { return nil, err } projects = append(projects, p) } iter.Release() return projects, nil }