2020-08-08 03:44:04 +00:00
|
|
|
// Copyright (c) 2020 Tailscale Inc & AUTHORS All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package controlclient
|
|
|
|
|
|
|
|
import (
|
2021-02-05 23:44:46 +00:00
|
|
|
"encoding/json"
|
2020-08-08 03:44:04 +00:00
|
|
|
"testing"
|
|
|
|
|
tailcfg: add Endpoint, EndpointType, MapRequest.EndpointType
Track endpoints internally with a new tailcfg.Endpoint type that
includes a typed netaddr.IPPort (instead of just a string) and
includes a type for how that endpoint was discovered (STUN, local,
etc).
Use []tailcfg.Endpoint instead of []string internally.
At the last second, send it to the control server as the existing
[]string for endpoints, but also include a new parallel
MapRequest.EndpointType []tailcfg.EndpointType, so the control server
can start filtering out less-important endpoint changes from
new-enough clients. Notably, STUN-discovered endpoints can be filtered
out from 1.6+ clients, as they can discover them amongst each other
via CallMeMaybe disco exchanges started over DERP. And STUN endpoints
change a lot, causing a lot of MapResposne updates. But portmapped
endpoints are worth keeping for now, as they they work right away
without requiring the firewall traversal extra RTT dance.
End result will be less control->client bandwidth. (despite negligible
increase in client->control bandwidth)
Updates tailscale/corp#1543
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2021-04-12 20:24:29 +00:00
|
|
|
"inet.af/netaddr"
|
2020-08-08 03:44:04 +00:00
|
|
|
"tailscale.com/tailcfg"
|
2021-01-08 13:49:29 +00:00
|
|
|
"tailscale.com/types/wgkey"
|
2020-08-08 03:44:04 +00:00
|
|
|
)
|
|
|
|
|
2021-01-08 13:49:29 +00:00
|
|
|
func TestNewDirect(t *testing.T) {
|
|
|
|
hi := NewHostinfo()
|
|
|
|
ni := tailcfg.NetInfo{LinkType: "wired"}
|
|
|
|
hi.NetInfo = &ni
|
|
|
|
|
|
|
|
key, err := wgkey.NewPrivate()
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
2021-03-31 15:51:22 +00:00
|
|
|
opts := Options{
|
|
|
|
ServerURL: "https://example.com",
|
|
|
|
Hostinfo: hi,
|
|
|
|
GetMachinePrivateKey: func() (wgkey.Private, error) {
|
|
|
|
return key, nil
|
|
|
|
},
|
|
|
|
}
|
2021-01-08 13:49:29 +00:00
|
|
|
c, err := NewDirect(opts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if c.serverURL != opts.ServerURL {
|
|
|
|
t.Errorf("c.serverURL got %v want %v", c.serverURL, opts.ServerURL)
|
|
|
|
}
|
|
|
|
|
|
|
|
if !hi.Equal(c.hostinfo) {
|
|
|
|
t.Errorf("c.hostinfo got %v want %v", c.hostinfo, hi)
|
|
|
|
}
|
|
|
|
|
|
|
|
changed := c.SetNetInfo(&ni)
|
|
|
|
if changed {
|
|
|
|
t.Errorf("c.SetNetInfo(ni) want false got %v", changed)
|
|
|
|
}
|
|
|
|
ni = tailcfg.NetInfo{LinkType: "wifi"}
|
|
|
|
changed = c.SetNetInfo(&ni)
|
|
|
|
if !changed {
|
|
|
|
t.Errorf("c.SetNetInfo(ni) want true got %v", changed)
|
|
|
|
}
|
|
|
|
|
|
|
|
changed = c.SetHostinfo(hi)
|
|
|
|
if changed {
|
|
|
|
t.Errorf("c.SetHostinfo(hi) want false got %v", changed)
|
|
|
|
}
|
|
|
|
hi = NewHostinfo()
|
|
|
|
hi.Hostname = "different host name"
|
|
|
|
changed = c.SetHostinfo(hi)
|
|
|
|
if !changed {
|
|
|
|
t.Errorf("c.SetHostinfo(hi) want true got %v", changed)
|
|
|
|
}
|
|
|
|
|
tailcfg: add Endpoint, EndpointType, MapRequest.EndpointType
Track endpoints internally with a new tailcfg.Endpoint type that
includes a typed netaddr.IPPort (instead of just a string) and
includes a type for how that endpoint was discovered (STUN, local,
etc).
Use []tailcfg.Endpoint instead of []string internally.
At the last second, send it to the control server as the existing
[]string for endpoints, but also include a new parallel
MapRequest.EndpointType []tailcfg.EndpointType, so the control server
can start filtering out less-important endpoint changes from
new-enough clients. Notably, STUN-discovered endpoints can be filtered
out from 1.6+ clients, as they can discover them amongst each other
via CallMeMaybe disco exchanges started over DERP. And STUN endpoints
change a lot, causing a lot of MapResposne updates. But portmapped
endpoints are worth keeping for now, as they they work right away
without requiring the firewall traversal extra RTT dance.
End result will be less control->client bandwidth. (despite negligible
increase in client->control bandwidth)
Updates tailscale/corp#1543
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2021-04-12 20:24:29 +00:00
|
|
|
endpoints := fakeEndpoints(1, 2, 3)
|
2021-01-08 13:49:29 +00:00
|
|
|
changed = c.newEndpoints(12, endpoints)
|
|
|
|
if !changed {
|
|
|
|
t.Errorf("c.newEndpoints(12) want true got %v", changed)
|
|
|
|
}
|
|
|
|
changed = c.newEndpoints(12, endpoints)
|
|
|
|
if changed {
|
|
|
|
t.Errorf("c.newEndpoints(12) want false got %v", changed)
|
|
|
|
}
|
|
|
|
changed = c.newEndpoints(13, endpoints)
|
|
|
|
if !changed {
|
|
|
|
t.Errorf("c.newEndpoints(13) want true got %v", changed)
|
|
|
|
}
|
tailcfg: add Endpoint, EndpointType, MapRequest.EndpointType
Track endpoints internally with a new tailcfg.Endpoint type that
includes a typed netaddr.IPPort (instead of just a string) and
includes a type for how that endpoint was discovered (STUN, local,
etc).
Use []tailcfg.Endpoint instead of []string internally.
At the last second, send it to the control server as the existing
[]string for endpoints, but also include a new parallel
MapRequest.EndpointType []tailcfg.EndpointType, so the control server
can start filtering out less-important endpoint changes from
new-enough clients. Notably, STUN-discovered endpoints can be filtered
out from 1.6+ clients, as they can discover them amongst each other
via CallMeMaybe disco exchanges started over DERP. And STUN endpoints
change a lot, causing a lot of MapResposne updates. But portmapped
endpoints are worth keeping for now, as they they work right away
without requiring the firewall traversal extra RTT dance.
End result will be less control->client bandwidth. (despite negligible
increase in client->control bandwidth)
Updates tailscale/corp#1543
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2021-04-12 20:24:29 +00:00
|
|
|
endpoints = fakeEndpoints(4, 5, 6)
|
2021-01-08 13:49:29 +00:00
|
|
|
changed = c.newEndpoints(13, endpoints)
|
|
|
|
if !changed {
|
|
|
|
t.Errorf("c.newEndpoints(13) want true got %v", changed)
|
|
|
|
}
|
|
|
|
}
|
2021-02-05 23:44:46 +00:00
|
|
|
|
tailcfg: add Endpoint, EndpointType, MapRequest.EndpointType
Track endpoints internally with a new tailcfg.Endpoint type that
includes a typed netaddr.IPPort (instead of just a string) and
includes a type for how that endpoint was discovered (STUN, local,
etc).
Use []tailcfg.Endpoint instead of []string internally.
At the last second, send it to the control server as the existing
[]string for endpoints, but also include a new parallel
MapRequest.EndpointType []tailcfg.EndpointType, so the control server
can start filtering out less-important endpoint changes from
new-enough clients. Notably, STUN-discovered endpoints can be filtered
out from 1.6+ clients, as they can discover them amongst each other
via CallMeMaybe disco exchanges started over DERP. And STUN endpoints
change a lot, causing a lot of MapResposne updates. But portmapped
endpoints are worth keeping for now, as they they work right away
without requiring the firewall traversal extra RTT dance.
End result will be less control->client bandwidth. (despite negligible
increase in client->control bandwidth)
Updates tailscale/corp#1543
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2021-04-12 20:24:29 +00:00
|
|
|
func fakeEndpoints(ports ...uint16) (ret []tailcfg.Endpoint) {
|
|
|
|
for _, port := range ports {
|
|
|
|
ret = append(ret, tailcfg.Endpoint{
|
2021-05-15 01:07:28 +00:00
|
|
|
Addr: netaddr.IPPortFrom(netaddr.IP{}, port),
|
tailcfg: add Endpoint, EndpointType, MapRequest.EndpointType
Track endpoints internally with a new tailcfg.Endpoint type that
includes a typed netaddr.IPPort (instead of just a string) and
includes a type for how that endpoint was discovered (STUN, local,
etc).
Use []tailcfg.Endpoint instead of []string internally.
At the last second, send it to the control server as the existing
[]string for endpoints, but also include a new parallel
MapRequest.EndpointType []tailcfg.EndpointType, so the control server
can start filtering out less-important endpoint changes from
new-enough clients. Notably, STUN-discovered endpoints can be filtered
out from 1.6+ clients, as they can discover them amongst each other
via CallMeMaybe disco exchanges started over DERP. And STUN endpoints
change a lot, causing a lot of MapResposne updates. But portmapped
endpoints are worth keeping for now, as they they work right away
without requiring the firewall traversal extra RTT dance.
End result will be less control->client bandwidth. (despite negligible
increase in client->control bandwidth)
Updates tailscale/corp#1543
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2021-04-12 20:24:29 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-02-05 23:44:46 +00:00
|
|
|
func TestNewHostinfo(t *testing.T) {
|
|
|
|
hi := NewHostinfo()
|
|
|
|
if hi == nil {
|
|
|
|
t.Fatal("no Hostinfo")
|
|
|
|
}
|
|
|
|
j, err := json.MarshalIndent(hi, " ", "")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
t.Logf("Got: %s", j)
|
|
|
|
}
|