mirror of
https://github.com/netbirdio/netbird.git
synced 2026-08-24 16:41:30 +02:00
53f2518af1
Ticks taken while the OS reported no network were skipped, but they still advanced the exponential backoff, so a peer could be tens of seconds from its next attempt by the time connectivity returned. Recovery then depended on a signal or relay event, which never arrives when both stayed up across the outage, e.g. a short airplane mode toggle over Wi-Fi. A peer parked in ICE hourly mode stayed there for the same reason. React to the offline-to-online transition directly: re-arm the reconnect ticker and reset the ICE retry state, so the peer retries at once. Add netstate.Changed for callers that own a select loop and cannot block in Wait.
108 lines
2.9 KiB
Go
108 lines
2.9 KiB
Go
// Package netstate tracks OS-reported network availability for the client.
|
|
//
|
|
// A State instance is owned by the platform integration (e.g. the Android or
|
|
// iOS bindings, fed from ConnectivityManager callbacks or NWPathMonitor) and
|
|
// is injected into the connection retry loops (management, signal, relay,
|
|
// peer guards and the top-level connect loop), which consult it to avoid
|
|
// burning CPU and battery on reconnect attempts while the device has no
|
|
// network at all (e.g. airplane mode), and to reset their backoff as soon as
|
|
// the network returns.
|
|
//
|
|
// Consumers hold a *State that may be nil — every non-mobile platform leaves
|
|
// it unset. The read methods are safe on a nil receiver: they report online
|
|
// and never block, so consumers behave as if this package did not exist.
|
|
package netstate
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// State holds the OS-reported network availability. The zero value is not
|
|
// usable; create instances with New.
|
|
type State struct {
|
|
mu sync.Mutex
|
|
online bool
|
|
changed chan struct{}
|
|
}
|
|
|
|
// New creates a State that starts online.
|
|
func New() *State {
|
|
return &State{
|
|
online: true,
|
|
changed: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
// Set records whether the OS reports any usable network. Transitions wake up
|
|
// all Wait callers immediately.
|
|
func (s *State) Set(online bool) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if s.online == online {
|
|
return
|
|
}
|
|
s.online = online
|
|
close(s.changed)
|
|
s.changed = make(chan struct{})
|
|
log.Infof("OS network availability changed: online=%t", online)
|
|
}
|
|
|
|
// IsOnline reports whether the OS reports at least one usable network. On a
|
|
// nil receiver — no State injected — it reports online.
|
|
func (s *State) IsOnline() bool {
|
|
if s == nil {
|
|
return true
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return s.online
|
|
}
|
|
|
|
// Changed returns a channel closed on the next availability transition, for
|
|
// callers that already own a select loop and cannot block in Wait. Re-read it
|
|
// after every fire: each transition installs a fresh channel. On a nil
|
|
// receiver — no State injected — it returns nil, which blocks forever in a
|
|
// select, so the caller simply never observes a transition.
|
|
func (s *State) Changed() <-chan struct{} {
|
|
if s == nil {
|
|
return nil
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return s.changed
|
|
}
|
|
|
|
// Wait blocks while the network is offline. It reports whether it had to
|
|
// wait, so callers can reset their backoff after an outage. It returns early
|
|
// with the context error when ctx is done. On a nil receiver — no State
|
|
// injected — it returns immediately.
|
|
func (s *State) Wait(ctx context.Context) (bool, error) {
|
|
if s == nil {
|
|
return false, nil
|
|
}
|
|
waited := false
|
|
for {
|
|
s.mu.Lock()
|
|
if s.online {
|
|
s.mu.Unlock()
|
|
return waited, nil
|
|
}
|
|
ch := s.changed
|
|
s.mu.Unlock()
|
|
|
|
if !waited {
|
|
waited = true
|
|
log.Debugf("network is offline, pausing connection attempts")
|
|
}
|
|
|
|
select {
|
|
case <-ctx.Done():
|
|
return waited, ctx.Err()
|
|
case <-ch:
|
|
}
|
|
}
|
|
}
|