fix: review findings for lazysecrets list: recent means the last 90 days, cache saves lock and keep deletions and the TUI's cursors, failed lists aren't retried, one expiry rule

internal/listing/listing.go

@@ -74,25 +74,37 @@ type Options struct {
 	// Lists only needed for other kinds aren't loaded: sources and vaults
 	// alone don't load any secrets. Lists that fail are always listed.
 	Kinds []string
-	// Mark tells whether the entry with link is starred for account,
-	// when it was last used and how often (zero: not lately), and its
-	// note; nil marks nothing.
-	Mark    func(link, account string) (starred bool, lastUsed time.Time, uses int, note string)
-	Timeout func(provider.Kind) time.Duration
+	// Mark tells what's remembered about the entry with link, seen
+	// through account; nil marks nothing.
+	Mark    func(link, account string) Marks
+	Timeout func(provider.Kind) time.Duration // nil: 30s
 	Now     func() time.Time
 }
 
+// Marks are what's remembered about an entry: starred for the account,
+// used lately (Recent) and when and how often, and its note.
+type Marks struct {
+	Starred, Recent bool
+	LastUsed        time.Time
+	Uses            int
+	Note            string
+}
+
 // Run lists everything, calling emit for each entry once, from this
 // goroutine, and for each list that can't be loaded, as it fails. An
 // error from emit (the reader went away) stops it. It returns the cache
-// with what was loaded.
-func Run(ctx context.Context, o Options, emit func(Entry) error) cachefile.File {
+// with what was loaded, and whether anything was.
+func Run(ctx context.Context, o Options, emit func(Entry) error) (cachefile.File, bool) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
-	l := &lister{o: o, emit: emit, seen: map[string]bool{}, pending: map[string]bool{}, results: make(chan result)}
+	l := &lister{o: o, emit: emit, seen: map[string]bool{}, pending: map[string]bool{}, failed: map[string]bool{},
+		results: make(chan result)}
 	if l.o.Now == nil {
 		l.o.Now = time.Now
 	}
+	if l.o.Timeout == nil {
+		l.o.Timeout = func(provider.Kind) time.Duration { return 30 * time.Second }
+	}
 	for _, p := range o.Providers {
 		if l.stopped != nil {
 			break
@@ -111,7 +123,7 @@ func Run(ctx context.Context, o Options, emit func(Entry) error) cachefile.File
 			cancel()
 		}
 	}
-	return l.o.Cache
+	return l.o.Cache, l.loaded
 }
 
 type job struct {
@@ -135,6 +147,8 @@ type lister struct {
 	emit    func(Entry) error
 	seen    map[string]bool // provider ID + link of entries emitted
 	pending map[string]bool // cache keys queued or loading
+	failed  map[string]bool // cache keys that couldn't be loaded: not again
+	loaded  bool            // something was cached
 	queue   []job
 	active  int
 	results chan result
@@ -240,8 +254,11 @@ func (l *lister) put(p provider.Provider, e Entry) {
 	}
 	e.Account = p.ID()
 	if l.o.Mark != nil && e.Link != "" {
-		e.Starred, e.LastUsed, e.Uses, e.Note = l.o.Mark(e.Link, e.Account)
-		e.Recent = !e.LastUsed.IsZero()
+		m := l.o.Mark(e.Link, e.Account)
+		e.Starred, e.Recent, e.Note = m.Starred, m.Recent, m.Note
+		if m.Recent {
+			e.LastUsed, e.Uses = m.LastUsed, m.Uses
+		}
 	}
 	id := p.ID() + "\x00" + e.Link + "\x00" + e.Error
 	if l.stopped != nil || l.seen[id] {
@@ -265,7 +282,7 @@ func (l *lister) wants(kinds ...string) bool {
 }
 
 func (l *lister) enqueue(j job) {
-	if l.pending[j.key] {
+	if l.pending[j.key] || l.failed[j.key] {
 		return
 	}
 	l.pending[j.key] = true
@@ -301,9 +318,11 @@ func (l *lister) handle(r result) {
 	delete(l.pending, r.key)
 	now := l.o.Now()
 	if r.err != nil {
+		l.failed[r.key] = true
 		l.put(r.p, r.failed())
 		return
 	}
+	l.loaded = l.loaded || l.cacheable(r.p)
 	cache := l.cacheable(r.p)
 	switch {
 	case r.c != nil: