mirror of
https://github.com/netbirdio/netbird.git
synced 2026-04-25 11:46:40 +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
104 lines
2.3 KiB
Go
104 lines
2.3 KiB
Go
package guard
|
|
|
|
import (
|
|
"testing"
|
|
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
func newTestRetryState() *iceRetryState {
|
|
return &iceRetryState{log: log.NewEntry(log.StandardLogger())}
|
|
}
|
|
|
|
func TestICERetryState_AllowsInitialBudget(t *testing.T) {
|
|
s := newTestRetryState()
|
|
|
|
for i := 1; i <= maxICERetries; i++ {
|
|
if !s.shouldRetry() {
|
|
t.Fatalf("shouldRetry returned false on attempt %d, want true (budget = %d)", i, maxICERetries)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestICERetryState_ExhaustsAfterBudget(t *testing.T) {
|
|
s := newTestRetryState()
|
|
|
|
for i := 0; i < maxICERetries; i++ {
|
|
_ = s.shouldRetry()
|
|
}
|
|
|
|
if s.shouldRetry() {
|
|
t.Fatalf("shouldRetry returned true after budget exhausted, want false")
|
|
}
|
|
}
|
|
|
|
func TestICERetryState_HourlyCNilBeforeEnterHourlyMode(t *testing.T) {
|
|
s := newTestRetryState()
|
|
|
|
if s.hourlyC() != nil {
|
|
t.Fatalf("hourlyC returned non-nil channel before enterHourlyMode")
|
|
}
|
|
}
|
|
|
|
func TestICERetryState_EnterHourlyModeArmsTicker(t *testing.T) {
|
|
s := newTestRetryState()
|
|
for i := 0; i < maxICERetries+1; i++ {
|
|
_ = s.shouldRetry()
|
|
}
|
|
|
|
s.enterHourlyMode()
|
|
defer s.reset()
|
|
|
|
if s.hourlyC() == nil {
|
|
t.Fatalf("hourlyC returned nil after enterHourlyMode")
|
|
}
|
|
}
|
|
|
|
func TestICERetryState_ShouldRetryTrueInHourlyMode(t *testing.T) {
|
|
s := newTestRetryState()
|
|
s.enterHourlyMode()
|
|
defer s.reset()
|
|
|
|
if !s.shouldRetry() {
|
|
t.Fatalf("shouldRetry returned false in hourly mode, want true")
|
|
}
|
|
|
|
// Subsequent calls also return true — we keep retrying on each hourly tick.
|
|
if !s.shouldRetry() {
|
|
t.Fatalf("second shouldRetry returned false in hourly mode, want true")
|
|
}
|
|
}
|
|
|
|
func TestICERetryState_ResetRestoresBudget(t *testing.T) {
|
|
s := newTestRetryState()
|
|
for i := 0; i < maxICERetries+1; i++ {
|
|
_ = s.shouldRetry()
|
|
}
|
|
s.enterHourlyMode()
|
|
|
|
s.reset()
|
|
|
|
if s.hourlyC() != nil {
|
|
t.Fatalf("hourlyC returned non-nil channel after reset")
|
|
}
|
|
if s.retries != 0 {
|
|
t.Fatalf("retries = %d after reset, want 0", s.retries)
|
|
}
|
|
|
|
for i := 1; i <= maxICERetries; i++ {
|
|
if !s.shouldRetry() {
|
|
t.Fatalf("shouldRetry returned false on attempt %d after reset, want true", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestICERetryState_ResetIsIdempotent(t *testing.T) {
|
|
s := newTestRetryState()
|
|
s.reset()
|
|
s.reset() // second call must not panic or re-stop a nil ticker
|
|
|
|
if s.hourlyC() != nil {
|
|
t.Fatalf("hourlyC non-nil after double reset")
|
|
}
|
|
}
|