func AddLBHeader(req *http.Request, nodeKeykey.NodePublic)

type Client struct {// Client is an HTTP client to talk to the coordination server.// It automatically makes a new Noise connection as needed.*http.Client// contains filtered or unexported fields}

funcNewClient¶

func NewClient(optsClientOpts) (*Client,error)

NewClient returns a new noiseClient for the provided server and machine key.

netMon may be nil, if non-nil it's used to do faster interface lookups.dialPlan may be nil

func (*Client)Close¶

func (nc *Client) Close()error

Close closes all the underlying noise connections.It is a no-op and returns nil if the connection is already closed.

func (*Client)DoWithBody¶

func (nc *Client) DoWithBody(ctxcontext.Context, method, pathstring, nodeKeykey.NodePublic, bodyany) (*http.Response,error)

func (*Client)Post¶

func (nc *Client) Post(ctxcontext.Context, pathstring, nodeKeykey.NodePublic, bodyany) (*http.Response,error)

post does a POST to the control server at the given path, JSON-encoding body.The provided nodeKey is an optional load balancing hint.

type ClientOpts struct {// ServerURL is the URL of the server to connect to.ServerURLstring// PrivKey is this node's private key.PrivKeykey.MachinePrivate// ServerPubKey is the public key of the server.// It is of the form https://<host>:<port> (no trailing slash).ServerPubKeykey.MachinePublic// Dialer's SystemDial function is used to connect to the server.Dialer *tsdial.Dialer// Logf is the log function to use.// If nil, log.Printf is used.Logflogger.Logf// NetMon is the network monitor that will be used to get the// network interface state. This field can be nil; if so, the current// state will be looked up dynamically.NetMon *netmon.Monitor// DNSCache is the caching Resolver to use to connect to the server.//// This field can be nil.DNSCache *dnscache.Resolver// HealthTracker, if non-nil, is the health tracker to use.HealthTracker *health.Tracker// DialPlan, if set, is a function that should return an explicit plan// on how to connect to the server.DialPlan func() *tailcfg.ControlDialPlan// ProtocolVersion, if non-zero, specifies an alternate// protocol version to use instead of the default,// of [tailcfg.CurrentCapabilityVersion].ProtocolVersionuint16}

type Conn struct {*controlbase.Conn// contains filtered or unexported fields}

funcNewConn¶

func NewConn(conn *controlbase.Conn, onClose func()) *Conn

NewConn creates a new Conn that wraps the given controlbase.Conn.

h2t is the HTTP/2 transport to use for the connection; a newhttp2.ClientConn will be created that reads from the returned Conn.

connID should be a unique ID for this connection. When the Conn is closed,the onClose function will be called if it is non-nil.

func (*Conn)Close¶

func (c *Conn) Close()error

Close closes the connection.

func (*Conn)GetEarlyPayload¶

func (c *Conn) GetEarlyPayload(ctxcontext.Context) (*tailcfg.EarlyNoise,error)

GetEarlyPayload waits for the early Noise payload to arrive.It may return (nil, nil) if the server begins HTTP/2 without one.

It is safe to call this multiple times; all callers will block until theearly Noise payload is ready (if any) and will return the same result forthe lifetime of the Conn.

func (*Conn)Read¶

func (c *Conn) Read(p []byte) (nint, errerror)

Read is basically the same as controlbase.Conn.Read, but it first reads the"early payload" header from the server which may or may not be present,depending on the server.