mirror of
https://github.com/tailscale/tailscale.git
synced 2026-11-20 08:41:19 -08:00
Since edcc2c94, tailscaled closes the watch when a subscriber falls
behind. That doesn't work well for GUIs where closing the watch has side
effects. On Windows, the last client disconnecting can reset the backend
state unless unattended or always-on mode is enabled. On Android and
Apple platforms, nothing restarts a watch that ended this way, so the
UI silently stops updating.
Add ipn.NotifySuspendWhenBehind. A watcher that sets it stays connected
when it falls behind, but gets a Notify with Suspended set and nothing
else until the client resumes the session via the new resume-ipn-bus
LocalAPI endpoint or LocalBackend.ResumeWatchNotifications. Resuming
replays the initial Notify and new notifications follow from there.
Updates tailscale/corp#51067
Updates tailscale/corp#50256
Updates tailscale/corp#50907
Signed-off-by: Nick Khyl <[email protected]>
273 lines
6.8 KiB
Go
273 lines
6.8 KiB
Go
// Copyright (c) Tailscale Inc & contributors
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
package ipn
|
|
|
|
import (
|
|
"encoding/json"
|
|
"go/types"
|
|
"maps"
|
|
"math/bits"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"golang.org/x/tools/go/packages"
|
|
|
|
"tailscale.com/health"
|
|
"tailscale.com/types/empty"
|
|
"tailscale.com/util/mak"
|
|
)
|
|
|
|
func TestNotifyString(t *testing.T) {
|
|
for _, tt := range []struct {
|
|
name string
|
|
value Notify
|
|
expected string
|
|
}{
|
|
{
|
|
name: "notify-empty",
|
|
value: Notify{},
|
|
expected: "Notify{}",
|
|
},
|
|
{
|
|
name: "notify-with-login-finished",
|
|
value: Notify{LoginFinished: &empty.Message{}},
|
|
expected: "Notify{LoginFinished}",
|
|
},
|
|
{
|
|
name: "notify-with-multiple-fields",
|
|
value: Notify{LoginFinished: &empty.Message{}, Health: &health.State{}},
|
|
expected: "Notify{LoginFinished Health{...}}",
|
|
},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
actual := tt.value.String()
|
|
if actual != tt.expected {
|
|
t.Fatalf("expected=%q, actual=%q", tt.expected, actual)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPeerWireGuardStateJSON(t *testing.T) {
|
|
tests := []struct {
|
|
state PeerWireGuardState
|
|
json string
|
|
}{
|
|
{PeerWireGuardStateNone, `"none"`},
|
|
{PeerWireGuardStateHandshake, `"handshake"`},
|
|
{PeerWireGuardStateEstablished, `"established"`},
|
|
{PeerWireGuardStateExpired, `"expired"`},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.state.String(), func(t *testing.T) {
|
|
got, err := json.Marshal(tt.state)
|
|
if err != nil {
|
|
t.Fatalf("Marshal: %v", err)
|
|
}
|
|
if string(got) != tt.json {
|
|
t.Errorf("Marshal(%v) = %s; want %s", tt.state, got, tt.json)
|
|
}
|
|
var back PeerWireGuardState
|
|
if err := json.Unmarshal(got, &back); err != nil {
|
|
t.Fatalf("Unmarshal: %v", err)
|
|
}
|
|
if back != tt.state {
|
|
t.Errorf("round-trip = %v; want %v", back, tt.state)
|
|
}
|
|
})
|
|
}
|
|
|
|
var bad PeerWireGuardState
|
|
if err := json.Unmarshal([]byte(`"bogus"`), &bad); err == nil {
|
|
t.Errorf("Unmarshal of bogus value did not return an error")
|
|
}
|
|
}
|
|
|
|
func TestValidateNotifyWatchOpt(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mask NotifyWatchOpt
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "peer-changes",
|
|
mask: NotifyPeerChanges | NotifyPeerPatches | NotifyNoNetMap | NotifyInitialStatus,
|
|
},
|
|
{
|
|
name: "in-process-no-disconnect",
|
|
mask: NotifyInProcessNoDisconnect | NotifyPeerChanges,
|
|
},
|
|
{
|
|
name: "suspend-when-behind",
|
|
mask: NotifySuspendWhenBehind | NotifyInitialState | NotifyPeerChanges,
|
|
},
|
|
{
|
|
name: "suspend-when-behind-without-initial-state",
|
|
mask: NotifySuspendWhenBehind | NotifyPeerChanges,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "suspend-when-behind-with-in-process-no-disconnect",
|
|
mask: NotifySuspendWhenBehind | NotifyInitialState | NotifyInProcessNoDisconnect,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "obsolete-rate-limit-only",
|
|
mask: ObsoleteNotifyRateLimit,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "obsolete-rate-limit-with-peer-changes",
|
|
mask: ObsoleteNotifyRateLimit | NotifyPeerChanges,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "obsolete-initial-netmap",
|
|
mask: ObsoleteNotifyInitialNetMap,
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := ValidateNotifyWatchOpt(tt.mask)
|
|
if gotErr := err != nil; gotErr != tt.wantErr {
|
|
t.Fatalf("ValidateNotifyWatchOpt(%v) error = %v; wantErr %v", tt.mask, err, tt.wantErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNotifyWatchOptString(t *testing.T) {
|
|
consts := findNotifyWatchOptConstants(t)
|
|
t.Logf("consts = %#v", consts)
|
|
|
|
t.Run("zero", func(t *testing.T) {
|
|
var zero NotifyWatchOpt
|
|
want := "ipn.NotifyWatchOpt(0x0)"
|
|
if got := zero.String(); got != want {
|
|
t.Errorf("NotifyWatchOpt(%#v).String() = %q, want %q", zero, got, want)
|
|
}
|
|
})
|
|
|
|
t.Run("unknown", func(t *testing.T) {
|
|
msb := NotifyWatchOpt(1 << 63)
|
|
want := "ipn.NotifyWatchOpt(0x8000000000000000)"
|
|
if got := msb.String(); got != want {
|
|
t.Errorf("NotifyWatchOpt(%#v).String() = %q, want %q", msb, got, want)
|
|
}
|
|
})
|
|
|
|
t.Run("simple", func(t *testing.T) {
|
|
for _, c := range slices.Sorted(maps.Keys(consts)) {
|
|
if bits.OnesCount64(uint64(c)) > 1 {
|
|
continue // multiple bits comes later
|
|
}
|
|
want := "ipn." + consts[c]
|
|
if got := c.String(); got != want {
|
|
t.Errorf("NotifyWatchOpt(%#v).String() = %q, want %q", c, got, want)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("composite", func(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
value NotifyWatchOpt
|
|
want string
|
|
}{
|
|
{
|
|
name: "single",
|
|
value: NotifyWatchEngineUpdates,
|
|
want: "ipn.NotifyWatchEngineUpdates",
|
|
},
|
|
{
|
|
name: "double",
|
|
value: NotifyWatchEngineUpdates | NotifyInitialState,
|
|
want: "(ipn.NotifyWatchEngineUpdates | ipn.NotifyInitialState)",
|
|
},
|
|
{
|
|
name: "triple",
|
|
value: NotifyWatchEngineUpdates | NotifyInitialState | NotifyInitialPrefs,
|
|
want: "(ipn.NotifyWatchEngineUpdates | ipn.NotifyInitialState | ipn.NotifyInitialPrefs)",
|
|
},
|
|
{
|
|
name: "unknown",
|
|
value: NotifyWatchEngineUpdates | NotifyWatchOpt(1<<63),
|
|
want: "(ipn.NotifyWatchEngineUpdates | ipn.NotifyWatchOpt(0x8000000000000000))",
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
if got := tc.value.String(); got != tc.want {
|
|
t.Errorf("NotifyWatchOpt(%#v).String() = %q, want %q", tc.value, got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
// Check that every named NotifyWatchOpt value is mapped inside [NotifyWatchOpt.String].
|
|
t.Run("all", func(t *testing.T) {
|
|
var all NotifyWatchOpt
|
|
var names []string // names are sorted and only contain simple consts
|
|
for _, c := range slices.Sorted(maps.Keys(consts)) {
|
|
all |= c
|
|
if bits.OnesCount64(uint64(c)) == 1 {
|
|
names = append(names, "ipn."+consts[c])
|
|
}
|
|
}
|
|
want := "(" + strings.Join(names, " | ") + ")"
|
|
if got := all.String(); got != want {
|
|
t.Errorf("all.String() = %q, want %q", got, want)
|
|
}
|
|
})
|
|
}
|
|
|
|
func findNotifyWatchOptConstants(t *testing.T) map[NotifyWatchOpt]string {
|
|
t.Helper()
|
|
|
|
// Load the current package.
|
|
cfg := &packages.Config{
|
|
Mode: packages.NeedTypes,
|
|
}
|
|
pkgs, err := packages.Load(cfg, ".")
|
|
if err != nil {
|
|
t.Fatalf("failed to load packages: %v", err)
|
|
}
|
|
|
|
// Find all the [NotifyWatchOpt] constants that represent this enum.
|
|
var found map[NotifyWatchOpt]string
|
|
for _, pkg := range pkgs {
|
|
if len(pkg.Errors) > 0 {
|
|
t.Fatalf("package %s has errors: %v", pkg.Name, pkg.Errors)
|
|
}
|
|
|
|
wantType := pkg.Types.Path() + ".NotifyWatchOpt"
|
|
scope := pkg.Types.Scope()
|
|
for _, name := range scope.Names() {
|
|
obj := scope.Lookup(name)
|
|
if obj == nil || obj.Type().String() != wantType {
|
|
continue
|
|
}
|
|
c, ok := obj.(*types.Const)
|
|
if !ok {
|
|
continue
|
|
}
|
|
s := c.Val().ExactString()
|
|
val, err := strconv.ParseUint(s, 10, 64)
|
|
if err != nil {
|
|
t.Fatalf("cannot parse %q: %v", s, err)
|
|
}
|
|
mak.Set(&found, NotifyWatchOpt(val), name)
|
|
}
|
|
}
|
|
|
|
if len(found) == 0 {
|
|
t.Fatal("could not find NotifyWatchOpt constants")
|
|
}
|
|
|
|
return found
|
|
}
|