ipn/ipn{server,test}: extract the LocalAPI test client and server into ipntest
In this PR, we extract the in-process LocalAPI client/server implementation from ipn/ipnserver/server_test.go into a new ipntest package to be used in high‑level black‑box tests, such as those for the tailscale CLI. Updates #15575 Signed-off-by: Nick Khyl <nickk@tailscale.com>
This commit is contained in:
Nick Khyl
Nick Khyl
@@ -0,0 +1,63 @@
|
||||
// Copyright (c) Tailscale Inc & AUTHORS
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
|
||||
package lapitest
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"tailscale.com/control/controlclient"
|
||||
"tailscale.com/ipn/ipnlocal"
|
||||
"tailscale.com/ipn/store/mem"
|
||||
"tailscale.com/types/logid"
|
||||
"tailscale.com/wgengine"
|
||||
)
|
||||
|
||||
// NewBackend returns a new [ipnlocal.LocalBackend] for testing purposes.
|
||||
// It fails the test if the specified options are invalid or if the backend cannot be created.
|
||||
func NewBackend(tb testing.TB, opts ...Option) *ipnlocal.LocalBackend {
|
||||
tb.Helper()
|
||||
options, err := newOptions(tb, opts...)
|
||||
if err != nil {
|
||||
tb.Fatalf("NewBackend: %v", err)
|
||||
}
|
||||
return newBackend(options)
|
||||
}
|
||||
|
||||
func newBackend(opts *options) *ipnlocal.LocalBackend {
|
||||
tb := opts.TB()
|
||||
tb.Helper()
|
||||
|
||||
sys := opts.Sys()
|
||||
if _, ok := sys.StateStore.GetOK(); !ok {
|
||||
sys.Set(&mem.Store{})
|
||||
}
|
||||
|
||||
e, err := wgengine.NewFakeUserspaceEngine(opts.Logf(), sys.Set, sys.HealthTracker(), sys.UserMetricsRegistry(), sys.Bus.Get())
|
||||
if err != nil {
|
||||
opts.tb.Fatalf("NewFakeUserspaceEngine: %v", err)
|
||||
}
|
||||
tb.Cleanup(e.Close)
|
||||
sys.Set(e)
|
||||
|
||||
b, err := ipnlocal.NewLocalBackend(opts.Logf(), logid.PublicID{}, sys, 0)
|
||||
if err != nil {
|
||||
tb.Fatalf("NewLocalBackend: %v", err)
|
||||
}
|
||||
tb.Cleanup(b.Shutdown)
|
||||
b.DisablePortMapperForTest()
|
||||
b.SetControlClientGetterForTesting(opts.MakeControlClient)
|
||||
return b
|
||||
}
|
||||
|
||||
// NewUnreachableControlClient is a [NewControlFn] that creates
|
||||
// a new [controlclient.Client] for an unreachable control server.
|
||||
func NewUnreachableControlClient(tb testing.TB, opts controlclient.Options) (controlclient.Client, error) {
|
||||
tb.Helper()
|
||||
opts.ServerURL = "https://127.0.0.1:1"
|
||||
cc, err := controlclient.New(opts)
|
||||
if err != nil {
|
||||
tb.Fatal(err)
|
||||
}
|
||||
return cc, nil
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
// Copyright (c) Tailscale Inc & AUTHORS
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
|
||||
package lapitest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"tailscale.com/client/local"
|
||||
"tailscale.com/ipn"
|
||||
"tailscale.com/ipn/ipnauth"
|
||||
)
|
||||
|
||||
// Client wraps a [local.Client] for testing purposes.
|
||||
// It can be created using [Server.Client], [Server.ClientWithName],
|
||||
// or [Server.ClientFor] and sends requests as the specified actor
|
||||
// to the associated [Server].
|
||||
type Client struct {
|
||||
tb testing.TB
|
||||
// Client is the underlying [local.Client] wrapped by the test client.
|
||||
// It is configured to send requests to the test server on behalf of the actor.
|
||||
*local.Client
|
||||
// Actor represents the user on whose behalf this client is making requests.
|
||||
// The server uses it to determine the client's identity and permissions.
|
||||
// The test can mutate the user to alter the actor's identity or permissions
|
||||
// before making a new request. It is typically an [ipnauth.TestActor],
|
||||
// unless the [Client] was created with s specific actor using [Server.ClientFor].
|
||||
Actor ipnauth.Actor
|
||||
}
|
||||
|
||||
// Username returns username of the client's owner.
|
||||
func (c *Client) Username() string {
|
||||
c.tb.Helper()
|
||||
name, err := c.Actor.Username()
|
||||
if err != nil {
|
||||
c.tb.Fatalf("Client.Username: %v", err)
|
||||
}
|
||||
return name
|
||||
}
|
||||
|
||||
// WatchIPNBus is like [local.Client.WatchIPNBus] but returns a [local.IPNBusWatcher]
|
||||
// that is closed when the test ends and a cancel function that stops the watcher.
|
||||
// It fails the test if the underlying WatchIPNBus returns an error.
|
||||
func (c *Client) WatchIPNBus(ctx context.Context, mask ipn.NotifyWatchOpt) (*local.IPNBusWatcher, context.CancelFunc) {
|
||||
c.tb.Helper()
|
||||
ctx, cancelWatcher := context.WithCancel(ctx)
|
||||
c.tb.Cleanup(cancelWatcher)
|
||||
watcher, err := c.Client.WatchIPNBus(ctx, mask)
|
||||
name, _ := c.Actor.Username()
|
||||
if err != nil {
|
||||
c.tb.Fatalf("Client.WatchIPNBus(%q): %v", name, err)
|
||||
}
|
||||
c.tb.Cleanup(func() { watcher.Close() })
|
||||
return watcher, cancelWatcher
|
||||
}
|
||||
|
||||
// generateSequentialName generates a unique sequential name based on the given prefix and number n.
|
||||
// It uses a base-26 encoding to create names like "User-A", "User-B", ..., "User-Z", "User-AA", etc.
|
||||
func generateSequentialName(prefix string, n int) string {
|
||||
n++
|
||||
name := ""
|
||||
const numLetters = 'Z' - 'A' + 1
|
||||
for n > 0 {
|
||||
n--
|
||||
remainder := byte(n % numLetters)
|
||||
name = string([]byte{'A' + remainder}) + name
|
||||
n = n / numLetters
|
||||
}
|
||||
return prefix + "-" + name
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
// Copyright (c) Tailscale Inc & AUTHORS
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
|
||||
package lapitest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"tailscale.com/ipn"
|
||||
)
|
||||
|
||||
func TestClientServer(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
ctx := context.Background()
|
||||
|
||||
// Create a server and two clients.
|
||||
// Both clients represent the same user to make this work across platforms.
|
||||
// On Windows we've been restricting the API usage to a single user at a time.
|
||||
// While we're planning on changing this once a better permission model is in place,
|
||||
// this test is currently limited to a single user (but more than one client is fine).
|
||||
// Alternatively, we could override GOOS via envknobs to test as if we're
|
||||
// on a different platform, but that would make the test depend on global state, etc.
|
||||
s := NewServer(t, WithLogging(false))
|
||||
c1 := s.ClientWithName("User-A")
|
||||
c2 := s.ClientWithName("User-A")
|
||||
|
||||
// Start watching the IPN bus as the second client.
|
||||
w2, _ := c2.WatchIPNBus(context.Background(), ipn.NotifyInitialPrefs)
|
||||
|
||||
// We're supposed to get a notification about the initial prefs,
|
||||
// and WantRunning should be false.
|
||||
n, err := w2.Next()
|
||||
for ; err == nil; n, err = w2.Next() {
|
||||
if n.Prefs == nil {
|
||||
// Ignore non-prefs notifications.
|
||||
continue
|
||||
}
|
||||
if n.Prefs.WantRunning() {
|
||||
t.Errorf("WantRunning(initial): got %v, want false", n.Prefs.WantRunning())
|
||||
}
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatalf("IPNBusWatcher.Next failed: %v", err)
|
||||
}
|
||||
|
||||
// Now send an EditPrefs request from the first client to set WantRunning to true.
|
||||
change := &ipn.MaskedPrefs{Prefs: ipn.Prefs{WantRunning: true}, WantRunningSet: true}
|
||||
gotPrefs, err := c1.EditPrefs(ctx, change)
|
||||
if err != nil {
|
||||
t.Fatalf("EditPrefs failed: %v", err)
|
||||
}
|
||||
if !gotPrefs.WantRunning {
|
||||
t.Fatalf("EditPrefs.WantRunning: got %v, want true", gotPrefs.WantRunning)
|
||||
}
|
||||
|
||||
// We can check the backend directly to see if the prefs were set correctly.
|
||||
if gotWantRunning := s.Backend().Prefs().WantRunning(); !gotWantRunning {
|
||||
t.Fatalf("Backend.Prefs.WantRunning: got %v, want true", gotWantRunning)
|
||||
}
|
||||
|
||||
// And can also wait for the second client with an IPN bus watcher to receive the notification
|
||||
// about the prefs change.
|
||||
n, err = w2.Next()
|
||||
for ; err == nil; n, err = w2.Next() {
|
||||
if n.Prefs == nil {
|
||||
// Ignore non-prefs notifications.
|
||||
continue
|
||||
}
|
||||
if !n.Prefs.WantRunning() {
|
||||
t.Fatalf("WantRunning(changed): got %v, want true", n.Prefs.WantRunning())
|
||||
}
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatalf("IPNBusWatcher.Next failed: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
// Copyright (c) Tailscale Inc & AUTHORS
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
|
||||
package lapitest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"tailscale.com/control/controlclient"
|
||||
"tailscale.com/ipn/ipnlocal"
|
||||
"tailscale.com/tsd"
|
||||
"tailscale.com/tstest"
|
||||
"tailscale.com/types/lazy"
|
||||
"tailscale.com/types/logger"
|
||||
)
|
||||
|
||||
// Option is any optional configuration that can be passed to [NewServer] or [NewBackend].
|
||||
type Option interface {
|
||||
apply(*options) error
|
||||
}
|
||||
|
||||
// options is the merged result of all applied [Option]s.
|
||||
type options struct {
|
||||
tb testing.TB
|
||||
ctx lazy.SyncValue[context.Context]
|
||||
logf lazy.SyncValue[logger.Logf]
|
||||
sys lazy.SyncValue[*tsd.System]
|
||||
newCC lazy.SyncValue[NewControlFn]
|
||||
backend lazy.SyncValue[*ipnlocal.LocalBackend]
|
||||
}
|
||||
|
||||
// newOptions returns a new [options] struct with the specified [Option]s applied.
|
||||
func newOptions(tb testing.TB, opts ...Option) (*options, error) {
|
||||
options := &options{tb: tb}
|
||||
for _, opt := range opts {
|
||||
if err := opt.apply(options); err != nil {
|
||||
return nil, fmt.Errorf("lapitest: %w", err)
|
||||
}
|
||||
}
|
||||
return options, nil
|
||||
}
|
||||
|
||||
// TB returns the owning [*testing.T] or [*testing.B].
|
||||
func (o *options) TB() testing.TB {
|
||||
return o.tb
|
||||
}
|
||||
|
||||
// Context returns the base context to be used by the server.
|
||||
func (o *options) Context() context.Context {
|
||||
return o.ctx.Get(context.Background)
|
||||
}
|
||||
|
||||
// Logf returns the [logger.Logf] to be used for logging.
|
||||
func (o *options) Logf() logger.Logf {
|
||||
return o.logf.Get(func() logger.Logf { return logger.Discard })
|
||||
}
|
||||
|
||||
// Sys returns the [tsd.System] that contains subsystems to be used
|
||||
// when creating a new [ipnlocal.LocalBackend].
|
||||
func (o *options) Sys() *tsd.System {
|
||||
return o.sys.Get(func() *tsd.System { return tsd.NewSystem() })
|
||||
}
|
||||
|
||||
// Backend returns the [ipnlocal.LocalBackend] to be used by the server.
|
||||
// If a backend is provided via [WithBackend], it is used as-is.
|
||||
// Otherwise, a new backend is created with the the [options] in o.
|
||||
func (o *options) Backend() *ipnlocal.LocalBackend {
|
||||
return o.backend.Get(func() *ipnlocal.LocalBackend { return newBackend(o) })
|
||||
}
|
||||
|
||||
// MakeControlClient returns a new [controlclient.Client] to be used by newly
|
||||
// created [ipnlocal.LocalBackend]s. It is only used if no backend is provided
|
||||
// via [WithBackend].
|
||||
func (o *options) MakeControlClient(opts controlclient.Options) (controlclient.Client, error) {
|
||||
newCC := o.newCC.Get(func() NewControlFn { return NewUnreachableControlClient })
|
||||
return newCC(o.tb, opts)
|
||||
}
|
||||
|
||||
type loggingOption struct{ enableLogging bool }
|
||||
|
||||
// WithLogging returns an [Option] that enables or disables logging.
|
||||
func WithLogging(enableLogging bool) Option {
|
||||
return loggingOption{enableLogging: enableLogging}
|
||||
}
|
||||
|
||||
func (o loggingOption) apply(opts *options) error {
|
||||
var logf logger.Logf
|
||||
if o.enableLogging {
|
||||
logf = tstest.WhileTestRunningLogger(opts.tb)
|
||||
} else {
|
||||
logf = logger.Discard
|
||||
}
|
||||
if !opts.logf.Set(logf) {
|
||||
return errors.New("logging already configured")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type contextOption struct{ ctx context.Context }
|
||||
|
||||
// WithContext returns an [Option] that sets the base context to be used by the [Server].
|
||||
func WithContext(ctx context.Context) Option {
|
||||
return contextOption{ctx: ctx}
|
||||
}
|
||||
|
||||
func (o contextOption) apply(opts *options) error {
|
||||
if !opts.ctx.Set(o.ctx) {
|
||||
return errors.New("context already configured")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type sysOption struct{ sys *tsd.System }
|
||||
|
||||
// WithSys returns an [Option] that sets the [tsd.System] to be used
|
||||
// when creating a new [ipnlocal.LocalBackend].
|
||||
func WithSys(sys *tsd.System) Option {
|
||||
return sysOption{sys: sys}
|
||||
}
|
||||
|
||||
func (o sysOption) apply(opts *options) error {
|
||||
if !opts.sys.Set(o.sys) {
|
||||
return errors.New("tsd.System already configured")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type backendOption struct{ backend *ipnlocal.LocalBackend }
|
||||
|
||||
// WithBackend returns an [Option] that configures the server to use the specified
|
||||
// [ipnlocal.LocalBackend] instead of creating a new one.
|
||||
// It is mutually exclusive with [WithControlClient].
|
||||
func WithBackend(backend *ipnlocal.LocalBackend) Option {
|
||||
return backendOption{backend: backend}
|
||||
}
|
||||
|
||||
func (o backendOption) apply(opts *options) error {
|
||||
if _, ok := opts.backend.Peek(); ok {
|
||||
return errors.New("backend cannot be set when control client is already set")
|
||||
}
|
||||
if !opts.backend.Set(o.backend) {
|
||||
return errors.New("backend already set")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// NewControlFn is any function that creates a new [controlclient.Client]
|
||||
// with the specified options.
|
||||
type NewControlFn func(tb testing.TB, opts controlclient.Options) (controlclient.Client, error)
|
||||
|
||||
// WithControlClient returns an option that specifies a function to be used
|
||||
// by the [ipnlocal.LocalBackend] when creating a new [controlclient.Client].
|
||||
// It is mutually exclusive with [WithBackend] and is only used if no backend
|
||||
// has been provided.
|
||||
func WithControlClient(newControl NewControlFn) Option {
|
||||
return newControl
|
||||
}
|
||||
|
||||
func (fn NewControlFn) apply(opts *options) error {
|
||||
if _, ok := opts.backend.Peek(); ok {
|
||||
return errors.New("control client cannot be set when backend is already set")
|
||||
}
|
||||
if !opts.newCC.Set(fn) {
|
||||
return errors.New("control client already set")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,324 @@
|
||||
// Copyright (c) Tailscale Inc & AUTHORS
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
|
||||
// Package lapitest provides utilities for black-box testing of LocalAPI ([ipnserver]).
|
||||
package lapitest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"tailscale.com/client/local"
|
||||
"tailscale.com/client/tailscale/apitype"
|
||||
"tailscale.com/envknob"
|
||||
"tailscale.com/ipn"
|
||||
"tailscale.com/ipn/ipnauth"
|
||||
"tailscale.com/ipn/ipnlocal"
|
||||
"tailscale.com/ipn/ipnserver"
|
||||
"tailscale.com/types/logger"
|
||||
"tailscale.com/types/logid"
|
||||
"tailscale.com/types/ptr"
|
||||
"tailscale.com/util/mak"
|
||||
"tailscale.com/util/rands"
|
||||
)
|
||||
|
||||
// A Server is an in-process LocalAPI server that can be used in end-to-end tests.
|
||||
type Server struct {
|
||||
tb testing.TB
|
||||
|
||||
ctx context.Context
|
||||
cancelCtx context.CancelFunc
|
||||
|
||||
lb *ipnlocal.LocalBackend
|
||||
ipnServer *ipnserver.Server
|
||||
|
||||
// mu protects the following fields.
|
||||
mu sync.Mutex
|
||||
started bool
|
||||
httpServer *httptest.Server
|
||||
actorsByName map[string]*ipnauth.TestActor
|
||||
lastClientID int
|
||||
}
|
||||
|
||||
// NewUnstartedServer returns a new [Server] with the specified options without starting it.
|
||||
func NewUnstartedServer(tb testing.TB, opts ...Option) *Server {
|
||||
tb.Helper()
|
||||
options, err := newOptions(tb, opts...)
|
||||
if err != nil {
|
||||
tb.Fatalf("invalid options: %v", err)
|
||||
}
|
||||
|
||||
s := &Server{tb: tb, lb: options.Backend()}
|
||||
s.ctx, s.cancelCtx = context.WithCancel(options.Context())
|
||||
s.ipnServer = newUnstartedIPNServer(options)
|
||||
s.httpServer = httptest.NewUnstartedServer(http.HandlerFunc(s.serveHTTP))
|
||||
s.httpServer.Config.Addr = "http://" + apitype.LocalAPIHost
|
||||
s.httpServer.Config.BaseContext = func(_ net.Listener) context.Context { return s.ctx }
|
||||
s.httpServer.Config.ErrorLog = logger.StdLogger(logger.WithPrefix(options.Logf(), "lapitest: "))
|
||||
tb.Cleanup(s.Close)
|
||||
return s
|
||||
}
|
||||
|
||||
// NewServer starts and returns a new [Server] with the specified options.
|
||||
func NewServer(tb testing.TB, opts ...Option) *Server {
|
||||
tb.Helper()
|
||||
server := NewUnstartedServer(tb, opts...)
|
||||
server.Start()
|
||||
return server
|
||||
}
|
||||
|
||||
// Start starts the server from [NewUnstartedServer].
|
||||
func (s *Server) Start() {
|
||||
s.tb.Helper()
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if !s.started && s.httpServer != nil {
|
||||
s.httpServer.Start()
|
||||
s.started = true
|
||||
}
|
||||
}
|
||||
|
||||
// Backend returns the underlying [ipnlocal.LocalBackend].
|
||||
func (s *Server) Backend() *ipnlocal.LocalBackend {
|
||||
s.tb.Helper()
|
||||
return s.lb
|
||||
}
|
||||
|
||||
// Client returns a new [Client] configured for making requests to the server
|
||||
// as a new [ipnauth.TestActor] with a unique username and [ipnauth.ClientID].
|
||||
func (s *Server) Client() *Client {
|
||||
s.tb.Helper()
|
||||
user := s.MakeTestActor("", "") // generate a unique username and client ID
|
||||
return s.ClientFor(user)
|
||||
}
|
||||
|
||||
// ClientWithName returns a new [Client] configured for making requests to the server
|
||||
// as a new [ipnauth.TestActor] with the specified name and a unique [ipnauth.ClientID].
|
||||
func (s *Server) ClientWithName(name string) *Client {
|
||||
s.tb.Helper()
|
||||
user := s.MakeTestActor(name, "") // generate a unique client ID
|
||||
return s.ClientFor(user)
|
||||
}
|
||||
|
||||
// ClientFor returns a new [Client] configured for making requests to the server
|
||||
// as the specified actor.
|
||||
func (s *Server) ClientFor(actor ipnauth.Actor) *Client {
|
||||
s.tb.Helper()
|
||||
client := &Client{
|
||||
tb: s.tb,
|
||||
Actor: actor,
|
||||
}
|
||||
client.Client = &local.Client{Transport: newRoundTripper(client, s.httpServer)}
|
||||
return client
|
||||
}
|
||||
|
||||
// MakeTestActor returns a new [ipnauth.TestActor] with the specified name and client ID.
|
||||
// If the name is empty, a unique sequential name is generated. Likewise,
|
||||
// if clientID is empty, a unique sequential client ID is generated.
|
||||
func (s *Server) MakeTestActor(name string, clientID string) *ipnauth.TestActor {
|
||||
s.tb.Helper()
|
||||
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
|
||||
// Generate a unique sequential name if the provided name is empty.
|
||||
if name == "" {
|
||||
n := len(s.actorsByName)
|
||||
name = generateSequentialName("User", n)
|
||||
}
|
||||
|
||||
if clientID == "" {
|
||||
s.lastClientID += 1
|
||||
clientID = fmt.Sprintf("Client-%d", s.lastClientID)
|
||||
}
|
||||
|
||||
// Create a new base actor if one doesn't already exist for the given name.
|
||||
baseActor := s.actorsByName[name]
|
||||
if baseActor == nil {
|
||||
baseActor = &ipnauth.TestActor{Name: name}
|
||||
if envknob.GOOS() == "windows" {
|
||||
// Historically, as of 2025-04-15, IPN does not distinguish between
|
||||
// different users on non-Windows devices. Therefore, the UID, which is
|
||||
// an [ipn.WindowsUserID], should only be populated when the actual or
|
||||
// fake GOOS is Windows.
|
||||
baseActor.UID = ipn.WindowsUserID(fmt.Sprintf("S-1-5-21-1-0-0-%d", 1001+len(s.actorsByName)))
|
||||
}
|
||||
mak.Set(&s.actorsByName, name, baseActor)
|
||||
s.tb.Cleanup(func() { delete(s.actorsByName, name) })
|
||||
}
|
||||
|
||||
// Create a shallow copy of the base actor and assign it the new client ID.
|
||||
actor := ptr.To(*baseActor)
|
||||
actor.CID = ipnauth.ClientIDFrom(clientID)
|
||||
return actor
|
||||
}
|
||||
|
||||
// BlockWhileInUse blocks until the server becomes idle (no active requests),
|
||||
// or the context is done. It returns the context's error if it is done.
|
||||
// It is used in tests only.
|
||||
func (s *Server) BlockWhileInUse(ctx context.Context) error {
|
||||
s.tb.Helper()
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if s.httpServer == nil {
|
||||
return nil
|
||||
}
|
||||
return s.ipnServer.BlockWhileInUseForTest(ctx)
|
||||
}
|
||||
|
||||
// BlockWhileInUseByOther blocks while the specified actor can't connect to the server
|
||||
// due to another actor being connected.
|
||||
// It is used in tests only.
|
||||
func (s *Server) BlockWhileInUseByOther(ctx context.Context, actor ipnauth.Actor) error {
|
||||
s.tb.Helper()
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if s.httpServer == nil {
|
||||
return nil
|
||||
}
|
||||
return s.ipnServer.BlockWhileInUseByOtherForTest(ctx, actor)
|
||||
}
|
||||
|
||||
// CheckCurrentUser fails the test if the current user does not match the expected user.
|
||||
// It is only used on Windows and will be removed as we progress on tailscale/corp#18342.
|
||||
func (s *Server) CheckCurrentUser(want ipnauth.Actor) {
|
||||
s.tb.Helper()
|
||||
var wantUID ipn.WindowsUserID
|
||||
if want != nil {
|
||||
wantUID = want.UserID()
|
||||
}
|
||||
lb := s.Backend()
|
||||
if lb == nil {
|
||||
s.tb.Fatalf("Backend: nil")
|
||||
}
|
||||
gotUID, gotActor := lb.CurrentUserForTest()
|
||||
if gotUID != wantUID {
|
||||
s.tb.Errorf("CurrentUser: got UID %q; want %q", gotUID, wantUID)
|
||||
}
|
||||
if hasActor := gotActor != nil; hasActor != (want != nil) || (want != nil && gotActor != want) {
|
||||
s.tb.Errorf("CurrentUser: got %v; want %v", gotActor, want)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Server) serveHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
actor, err := getActorForRequest(r)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusBadRequest)
|
||||
s.tb.Errorf("getActorForRequest: %v", err)
|
||||
return
|
||||
}
|
||||
ctx := ipnserver.NewContextWithActorForTest(r.Context(), actor)
|
||||
s.ipnServer.ServeHTTPForTest(w, r.Clone(ctx))
|
||||
}
|
||||
|
||||
// Close shuts down the server and blocks until all outstanding requests on this server have completed.
|
||||
func (s *Server) Close() {
|
||||
s.tb.Helper()
|
||||
s.mu.Lock()
|
||||
server := s.httpServer
|
||||
s.httpServer = nil
|
||||
s.mu.Unlock()
|
||||
|
||||
if server != nil {
|
||||
server.Close()
|
||||
}
|
||||
s.cancelCtx()
|
||||
}
|
||||
|
||||
// newUnstartedIPNServer returns a new [ipnserver.Server] that exposes
|
||||
// the specified [ipnlocal.LocalBackend] via LocalAPI, but does not start it.
|
||||
// The opts carry additional configuration options.
|
||||
func newUnstartedIPNServer(opts *options) *ipnserver.Server {
|
||||
opts.TB().Helper()
|
||||
lb := opts.Backend()
|
||||
server := ipnserver.New(opts.Logf(), logid.PublicID{}, lb.NetMon())
|
||||
server.SetLocalBackend(lb)
|
||||
return server
|
||||
}
|
||||
|
||||
// roundTripper is a [http.RoundTripper] that sends requests to a [Server]
|
||||
// on behalf of the [Client] who owns it.
|
||||
type roundTripper struct {
|
||||
client *Client
|
||||
transport http.RoundTripper
|
||||
}
|
||||
|
||||
// newRoundTripper returns a new [http.RoundTripper] that sends requests
|
||||
// to the specified server as the specified client.
|
||||
func newRoundTripper(client *Client, server *httptest.Server) http.RoundTripper {
|
||||
return &roundTripper{
|
||||
client: client,
|
||||
transport: &http.Transport{DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
|
||||
var std net.Dialer
|
||||
return std.DialContext(ctx, network, server.Listener.Addr().(*net.TCPAddr).String())
|
||||
}},
|
||||
}
|
||||
}
|
||||
|
||||
// requestIDHeaderName is the name of the header used to pass request IDs
|
||||
// between the client and server. It is used to associate requests with their actors.
|
||||
const requestIDHeaderName = "TS-Request-ID"
|
||||
|
||||
// RoundTrip implements [http.RoundTripper] by sending the request to the [ipnserver.Server]
|
||||
// on behalf of the owning [Client]. It registers each request for the duration
|
||||
// of the call and associates it with the actor sending the request.
|
||||
func (rt *roundTripper) RoundTrip(r *http.Request) (*http.Response, error) {
|
||||
reqID, unregister := registerRequest(rt.client.Actor)
|
||||
defer unregister()
|
||||
r = r.Clone(r.Context())
|
||||
r.Header.Set(requestIDHeaderName, reqID)
|
||||
return rt.transport.RoundTrip(r)
|
||||
}
|
||||
|
||||
// getActorForRequest returns the actor for a given request.
|
||||
// It returns an error if the request is not associated with an actor,
|
||||
// such as when it wasn't sent by a [roundTripper].
|
||||
func getActorForRequest(r *http.Request) (ipnauth.Actor, error) {
|
||||
reqID := r.Header.Get(requestIDHeaderName)
|
||||
if reqID == "" {
|
||||
return nil, fmt.Errorf("missing %s header", requestIDHeaderName)
|
||||
}
|
||||
actor, ok := getActorByRequestID(reqID)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("unknown request: %s", reqID)
|
||||
}
|
||||
return actor, nil
|
||||
}
|
||||
|
||||
var (
|
||||
inFlightRequestsMu sync.Mutex
|
||||
inFlightRequests map[string]ipnauth.Actor
|
||||
)
|
||||
|
||||
// registerRequest associates a request with the specified actor and returns a unique request ID
|
||||
// which can be used to retrieve the actor later. The returned function unregisters the request.
|
||||
func registerRequest(actor ipnauth.Actor) (requestID string, unregister func()) {
|
||||
inFlightRequestsMu.Lock()
|
||||
defer inFlightRequestsMu.Unlock()
|
||||
for {
|
||||
requestID = rands.HexString(16)
|
||||
if _, ok := inFlightRequests[requestID]; !ok {
|
||||
break
|
||||
}
|
||||
}
|
||||
mak.Set(&inFlightRequests, requestID, actor)
|
||||
return requestID, func() {
|
||||
inFlightRequestsMu.Lock()
|
||||
defer inFlightRequestsMu.Unlock()
|
||||
delete(inFlightRequests, requestID)
|
||||
}
|
||||
}
|
||||
|
||||
// getActorByRequestID returns the actor associated with the specified request ID.
|
||||
// It returns the actor and true if found, or nil and false if not.
|
||||
func getActorByRequestID(requestID string) (ipnauth.Actor, bool) {
|
||||
inFlightRequestsMu.Lock()
|
||||
defer inFlightRequestsMu.Unlock()
|
||||
actor, ok := inFlightRequests[requestID]
|
||||
return actor, ok
|
||||
}
|
||||
Reference in New Issue
Block a user