mirror of
https://github.com/netbirdio/netbird.git
synced 2026-04-22 10:16:38 +00:00
5a89e6621b
* [client] Suppress ICE signaling and periodic offers in force-relay mode When NB_FORCE_RELAY is enabled, skip WorkerICE creation entirely, suppress ICE credentials in offer/answer messages, disable the periodic ICE candidate monitor, and fix isConnectedOnAllWay to only check relay status so the guard stops sending unnecessary offers. * [client] Dynamically suppress ICE based on remote peer's offer credentials Track whether the remote peer includes ICE credentials in its offers/answers. When remote stops sending ICE credentials, skip ICE listener dispatch, suppress ICE credentials in responses, and exclude ICE from the guard connectivity check. When remote resumes sending ICE credentials, re-enable all ICE behavior. * [client] Fix nil SessionID panic and force ICE teardown on relay-only transition Fix nil pointer dereference in signalOfferAnswer when SessionID is nil (relay-only offers). Close stale ICE agent immediately when remote peer stops sending ICE credentials to avoid traffic black-hole during the ICE disconnect timeout. * [client] Add relay-only fallback check when ICE is unavailable Ensure the relay connection is supported with the peer when ICE is disabled to prevent connectivity issues. * [client] Add tri-state connection status to guard for smarter ICE retry (#5828) * [client] Add tri-state connection status to guard for smarter ICE retry Refactor isConnectedOnAllWay to return a ConnStatus enum (Connected, Disconnected, PartiallyConnected) instead of a boolean. When relay is up but ICE is not (PartiallyConnected), limit ICE offers to 3 retries with exponential backoff then fall back to hourly attempts, reducing unnecessary signaling traffic. Fully disconnected peers continue to retry aggressively. External events (relay/ICE disconnect, signal/relay reconnect) reset retry state to give ICE a fresh chance. * [client] Clarify guard ICE retry state and trace log trigger Split iceRetryState.attempt into shouldRetry (pure predicate) and enterHourlyMode (explicit state transition) so the caller in reconnectLoopWithRetry reads top-to-bottom. Restore the original trace-log behavior in isConnectedOnAllWay so it only logs on full disconnection, not on the new PartiallyConnected state. * [client] Extract pure evalConnStatus and add unit tests Split isConnectedOnAllWay into a thin method that snapshots state and a pure evalConnStatus helper that takes a connStatusInputs struct, so the tri-state decision logic can be exercised without constructing full Worker or Handshaker objects. Add table-driven tests covering force-relay, ICE-unavailable and fully-available code paths, plus unit tests for iceRetryState budget/hourly transitions and reset. * [client] Improve grammar in logs and refactor ICE credential checks
121 lines
2.6 KiB
Go
121 lines
2.6 KiB
Go
package guard
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
log "github.com/sirupsen/logrus"
|
|
|
|
"github.com/netbirdio/netbird/client/internal/peer/ice"
|
|
"github.com/netbirdio/netbird/client/internal/stdnet"
|
|
)
|
|
|
|
type chNotifier interface {
|
|
SetOnReconnectedListener(func())
|
|
Ready() bool
|
|
}
|
|
|
|
type SRWatcher struct {
|
|
signalClient chNotifier
|
|
relayManager chNotifier
|
|
|
|
listeners map[chan struct{}]struct{}
|
|
mu sync.Mutex
|
|
iFaceDiscover stdnet.ExternalIFaceDiscover
|
|
iceConfig ice.Config
|
|
cancelIceMonitor context.CancelFunc
|
|
}
|
|
|
|
// NewSRWatcher creates a new SRWatcher. This watcher will notify the listeners when the ICE candidates change or the
|
|
// Relay connection is reconnected or the Signal client reconnected.
|
|
func NewSRWatcher(signalClient chNotifier, relayManager chNotifier, iFaceDiscover stdnet.ExternalIFaceDiscover, iceConfig ice.Config) *SRWatcher {
|
|
srw := &SRWatcher{
|
|
signalClient: signalClient,
|
|
relayManager: relayManager,
|
|
iFaceDiscover: iFaceDiscover,
|
|
iceConfig: iceConfig,
|
|
listeners: make(map[chan struct{}]struct{}),
|
|
}
|
|
return srw
|
|
}
|
|
|
|
func (w *SRWatcher) Start(disableICEMonitor bool) {
|
|
w.mu.Lock()
|
|
defer w.mu.Unlock()
|
|
|
|
if w.cancelIceMonitor != nil {
|
|
return
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
w.cancelIceMonitor = cancel
|
|
|
|
if !disableICEMonitor {
|
|
iceMonitor := NewICEMonitor(w.iFaceDiscover, w.iceConfig, GetICEMonitorPeriod())
|
|
go iceMonitor.Start(ctx, w.onICEChanged)
|
|
}
|
|
w.signalClient.SetOnReconnectedListener(w.onReconnected)
|
|
w.relayManager.SetOnReconnectedListener(w.onReconnected)
|
|
|
|
}
|
|
|
|
func (w *SRWatcher) Close() {
|
|
w.mu.Lock()
|
|
defer w.mu.Unlock()
|
|
|
|
if w.cancelIceMonitor == nil {
|
|
return
|
|
}
|
|
w.cancelIceMonitor()
|
|
w.signalClient.SetOnReconnectedListener(nil)
|
|
w.relayManager.SetOnReconnectedListener(nil)
|
|
}
|
|
|
|
func (w *SRWatcher) NewListener() chan struct{} {
|
|
w.mu.Lock()
|
|
defer w.mu.Unlock()
|
|
|
|
listenerChan := make(chan struct{}, 1)
|
|
w.listeners[listenerChan] = struct{}{}
|
|
return listenerChan
|
|
}
|
|
|
|
func (w *SRWatcher) RemoveListener(listenerChan chan struct{}) {
|
|
w.mu.Lock()
|
|
defer w.mu.Unlock()
|
|
delete(w.listeners, listenerChan)
|
|
close(listenerChan)
|
|
}
|
|
|
|
func (w *SRWatcher) onICEChanged() {
|
|
if !w.signalClient.Ready() {
|
|
return
|
|
}
|
|
|
|
log.Infof("network changes detected by ICE agent")
|
|
w.notify()
|
|
}
|
|
|
|
func (w *SRWatcher) onReconnected() {
|
|
if !w.signalClient.Ready() {
|
|
return
|
|
}
|
|
if !w.relayManager.Ready() {
|
|
return
|
|
}
|
|
|
|
log.Infof("reconnected to Signal or Relay server")
|
|
w.notify()
|
|
}
|
|
|
|
func (w *SRWatcher) notify() {
|
|
w.mu.Lock()
|
|
defer w.mu.Unlock()
|
|
for listener := range w.listeners {
|
|
select {
|
|
case listener <- struct{}{}:
|
|
default:
|
|
}
|
|
}
|
|
}
|