From f2ed52347ec461a2b7a70787192f3615bcb6bafd Mon Sep 17 00:00:00 2001 From: Jakob Borg Date: Thu, 19 Nov 2026 11:51:57 +0100 Subject: [PATCH] refactor(discover): simplify cache handling by moving to the cachedFinder (#10956) Where it should have been to begin with --------- Signed-off-by: Jakob Borg --- .github/workflows/build-syncthing.yaml | 9 ++-- lib/discover/cache.go | 47 +++++++++++++++++++- lib/discover/manager.go | 61 ++++---------------------- 3 files changed, 60 insertions(+), 57 deletions(-) diff --git a/.github/workflows/build-syncthing.yaml b/.github/workflows/build-syncthing.yaml index c042cb0cf..125065af8 100644 --- a/.github/workflows/build-syncthing.yaml +++ b/.github/workflows/build-syncthing.yaml @@ -278,7 +278,8 @@ jobs: package-linux: name: Package for Linux (${{ matrix.group }}) - runs-on: ubuntu-latest + # Ubuntu 26.04 no longer ships the MIPS64 GCC cross-compilers. + runs-on: ${{ matrix.group == 'mips' && 'ubuntu-24.04' || 'ubuntu-latest' }} needs: - facts strategy: @@ -330,7 +331,9 @@ jobs: - name: Install extra packages if: matrix.extra-packages != '' - run: sudo apt-get install -y ${{ matrix.extra-packages }} + run: | + sudo apt-get update + sudo apt-get install -y ${{ matrix.extra-packages }} - name: Create packages run: | @@ -735,7 +738,7 @@ jobs: go-version: ${{ needs.facts.outputs.go-version }} cache: false - - uses: ruby/setup-ruby@eab2afb99481ca09a4e91171a8e0aee0e89bfedd # v1 + - uses: ruby/setup-ruby@f9c4492e86def3e644ab32a0ef185eda5b0c20d0 # v1.342.0 with: ruby-version: '3.0' diff --git a/lib/discover/cache.go b/lib/discover/cache.go index ea00966e3..f3d73302f 100644 --- a/lib/discover/cache.go +++ b/lib/discover/cache.go @@ -7,12 +7,13 @@ package discover import ( + "context" + "log/slog" "maps" "sync" "time" "github.com/syncthing/syncthing/lib/protocol" - "github.com/thejerf/suture/v4" ) // A cachedFinder is a Finder with associated cache timeouts. @@ -22,7 +23,6 @@ type cachedFinder struct { cacheTime time.Duration negCacheTime time.Duration cache *cache - token *suture.ServiceToken } // An error may implement cachedError, in which case it will be interrogated @@ -32,6 +32,49 @@ type cachedError interface { CacheFor() time.Duration } +func (f *cachedFinder) Lookup(ctx context.Context, deviceID protocol.DeviceID) ([]string, error) { + if cacheEntry, ok := f.cache.Get(deviceID); ok { + // We have a cache entry. Lets see what it says. + + if cacheEntry.found && time.Since(cacheEntry.when) < f.cacheTime { + // It's a positive, valid entry. Use it. + slog.DebugContext(ctx, "Found cached discovery entry", "device", deviceID, "finder", f, "entry", cacheEntry) + return cacheEntry.Addresses, nil + } + + valid := time.Now().Before(cacheEntry.validUntil) || time.Since(cacheEntry.when) < f.negCacheTime + if !cacheEntry.found && valid { + // It's a negative, valid entry. We should not make another + // attempt right now. + slog.DebugContext(ctx, "Negative cache entry", "device", deviceID, "finder", f, "until1", cacheEntry.when.Add(f.negCacheTime), "until2", cacheEntry.validUntil) + return nil, nil + } + } + + // Perform the actual lookup and cache the result. + addrs, err := f.Finder.Lookup(ctx, deviceID) + if err == nil { + slog.DebugContext(ctx, "Got finder result", "device", deviceID, "finder", f, "address", addrs) + f.cache.Set(deviceID, CacheEntry{ + Addresses: addrs, + when: time.Now(), + found: len(addrs) > 0, + }) + } else { + // Lookup returned error, add a negative cache entry. + entry := CacheEntry{ + when: time.Now(), + found: false, + } + if err, ok := err.(cachedError); ok { + entry.validUntil = time.Now().Add(err.CacheFor()) + } + f.cache.Set(deviceID, entry) + } + + return addrs, err +} + // A cache can be embedded wherever useful type cache struct { diff --git a/lib/discover/manager.go b/lib/discover/manager.go index 4fe9e8312..167f8f128 100644 --- a/lib/discover/manager.go +++ b/lib/discover/manager.go @@ -49,8 +49,9 @@ type manager struct { addressLister AddressLister registry *registry.Registry - finders map[string]cachedFinder mut sync.RWMutex + finders map[string]cachedFinder + tokens map[string]suture.ServiceToken } func NewManager(myID protocol.DeviceID, cfg config.Wrapper, cert tls.Certificate, evLogger events.Logger, lister AddressLister, registry *registry.Registry) Manager { @@ -62,8 +63,8 @@ func NewManager(myID protocol.DeviceID, cfg config.Wrapper, cert tls.Certificate evLogger: evLogger, addressLister: lister, registry: registry, - - finders: make(map[string]cachedFinder), + finders: make(map[string]cachedFinder), + tokens: make(map[string]suture.ServiceToken), } m.Add(svcutil.AsService(m.serve, m.String())) return m @@ -78,33 +79,27 @@ func (m *manager) serve(ctx context.Context) error { } func (m *manager) addLocked(identity string, finder Finder, cacheTime, negCacheTime time.Duration) { - entry := cachedFinder{ + m.finders[identity] = cachedFinder{ Finder: finder, cacheTime: cacheTime, negCacheTime: negCacheTime, cache: newCache(), - token: nil, } if service, ok := finder.(suture.Service); ok { token := m.Supervisor.Add(service) - entry.token = &token + m.tokens[identity] = token } - m.finders[identity] = entry slog.Info("Using discovery mechanism", "identity", identity) } func (m *manager) removeLocked(identity string) { - entry, ok := m.finders[identity] - if !ok { - return - } - if entry.token != nil { - err := m.Supervisor.Remove(*entry.token) - if err != nil { + if token, ok := m.tokens[identity]; ok { + if err := m.Supervisor.Remove(token); err != nil { slog.Warn("Failed to remove discovery mechanism", slog.String("identity", identity), slogutil.Error(err)) } } delete(m.finders, identity) + delete(m.tokens, identity) slog.Info("Stopped using discovery mechanism", "identity", identity) } @@ -113,46 +108,8 @@ func (m *manager) removeLocked(identity string) { func (m *manager) Lookup(ctx context.Context, deviceID protocol.DeviceID) (addresses []string, err error) { m.mut.RLock() for _, finder := range m.finders { - if cacheEntry, ok := finder.cache.Get(deviceID); ok { - // We have a cache entry. Lets see what it says. - - if cacheEntry.found && time.Since(cacheEntry.when) < finder.cacheTime { - // It's a positive, valid entry. Use it. - slog.DebugContext(ctx, "Found cached discovery entry", "device", deviceID, "finder", finder, "entry", cacheEntry) - addresses = append(addresses, cacheEntry.Addresses...) - continue - } - - valid := time.Now().Before(cacheEntry.validUntil) || time.Since(cacheEntry.when) < finder.negCacheTime - if !cacheEntry.found && valid { - // It's a negative, valid entry. We should not make another - // attempt right now. - slog.DebugContext(ctx, "Negative cache entry", "device", deviceID, "finder", finder, "until1", cacheEntry.when.Add(finder.negCacheTime), "until2", cacheEntry.validUntil) - continue - } - - // It's expired. Ignore and continue. - } - - // Perform the actual lookup and cache the result. if addrs, err := finder.Lookup(ctx, deviceID); err == nil { - slog.DebugContext(ctx, "Got finder result", "device", deviceID, "finder", finder, "address", addrs) addresses = append(addresses, addrs...) - finder.cache.Set(deviceID, CacheEntry{ - Addresses: addrs, - when: time.Now(), - found: len(addrs) > 0, - }) - } else { - // Lookup returned error, add a negative cache entry. - entry := CacheEntry{ - when: time.Now(), - found: false, - } - if err, ok := err.(cachedError); ok { - entry.validUntil = time.Now().Add(err.CacheFor()) - } - finder.cache.Set(deviceID, entry) } } m.mut.RUnlock()