func CompareDERPMaps(a *tailcfg.DERPMap, b *tailcfg.DERPMap)bool

func DERPMapFromProto(derpMap *proto.DERPMap) *tailcfg.DERPMap

func DERPMapToProto(derpMap *tailcfg.DERPMap) *proto.DERPMap

func DERPNodeFromProto(node *proto.DERPMap_Region_Node) *tailcfg.DERPNode

func DERPNodeToProto(node *tailcfg.DERPNode) *proto.DERPMap_Region_Node

func DERPRegionFromProto(region *proto.DERPMap_Region) *tailcfg.DERPRegion

func DERPRegionToProto(region *tailcfg.DERPRegion) *proto.DERPMap_Region

func IsDRPCUnimplementedError(errerror)bool

func Logger(logger interface {Debug(ctxcontext.Context, strstring, args ...any)},)tslogger.Logf

func NewDERPMap(ctxcontext.Context, region *tailcfg.DERPRegion, stunAddrs []string, remoteURL, localPathstring, disableSTUNbool) (*tailcfg.DERPMap,error)

func NewDRPCClient(connnet.Conn, loggerslog.Logger) (proto.DRPCTailnetClient,error)

func NodeID(uiduuid.UUID)tailcfg.NodeID

func NodeToProto(n *Node) (*proto.Node,error)

func RecvCtx[Aany](ctxcontext.Context, c <-chan A) (a A, errerror)

func STUNRegions(baseRegionIDint, stunAddrs []string) ([]*tailcfg.DERPRegion,error)

func SendCtx[Aany](ctxcontext.Context, c chan<- A, a A) (errerror)

func SingleNodeUpdate(iduuid.UUID, node *Node, reasonstring) (*proto.CoordinateResponse,error)

func UUIDToByteSlice(uuuid.UUID) []byte

func WithStreamID(ctxcontext.Context, streamIDStreamID)context.Context

func WithWebsocketSupport(s *derp.Server, basehttp.Handler) (http.Handler, func())

func WorkspaceStatusToProto(statuscodersdk.WorkspaceStatus)proto.Workspace_Status

type Agent struct {IDuuid.UUIDNamestringWorkspaceIDuuid.UUIDHosts       map[dnsname.FQDN][]netip.Addr}

func (*Agent)Clone¶added inv2.19.0

func (a *Agent) Clone()Agent

type AgentCoordinateeAuth struct {IDuuid.UUID}

func (AgentCoordinateeAuth)Authorize¶added inv2.9.0

func (aAgentCoordinateeAuth) Authorize(_context.Context, req *proto.CoordinateRequest)error

type AuthorizationError struct {Wrappederror}

func (AuthorizationError)Error¶added inv2.22.0

func (eAuthorizationError) Error()string

func (AuthorizationError)Unwrap¶added inv2.22.0

func (eAuthorizationError) Unwrap()error

type BasicCoordination struct {sync.MutexClientCoordinatorClient// contains filtered or unexported fields}

func (*BasicCoordination)Close¶added inv2.18.0

func (c *BasicCoordination) Close(ctxcontext.Context) (retErrerror)

Close the coordination gracefully. If the context expires before the remote API server has hungup on us, we forcibly close the Client connection.

func (*BasicCoordination)SendErr¶added inv2.18.0

func (c *BasicCoordination) SendErr(errerror)

SendErr is not part of the CloserWaiter interface, and is intended to be called internally, orby Controllers that use BasicCoordinationController in composition. It triggers Wait() toreport the error if an error has not already been reported.

func (*BasicCoordination)Wait¶added inv2.18.0

func (c *BasicCoordination) Wait() <-chanerror

Wait for the Coordination to complete

type BasicCoordinationController struct {Loggerslog.LoggerCoordinateeCoordinateeSendAcksbool}

func (*BasicCoordinationController)New¶added inv2.18.0

func (c *BasicCoordinationController) New(clientCoordinatorClient)CloserWaiter

New satisfies the method on the CoordinationController interface

func (*BasicCoordinationController)NewCoordination¶added inv2.18.0

func (c *BasicCoordinationController) NewCoordination(clientCoordinatorClient) *BasicCoordination

NewCoordination creates a BasicCoordination

type BasicTelemetryController struct {sync.Mutex// contains filtered or unexported fields}

funcNewBasicTelemetryController¶added inv2.18.0

func NewBasicTelemetryController(loggerslog.Logger) *BasicTelemetryController

func (*BasicTelemetryController)New¶added inv2.18.0

func (b *BasicTelemetryController) New(clientTelemetryClient)

func (*BasicTelemetryController)SendTelemetryEvent¶added inv2.18.0

func (b *BasicTelemetryController) SendTelemetryEvent(event *proto.TelemetryEvent)

type ClientCoordinateeAuth struct {AgentIDuuid.UUID}

func (ClientCoordinateeAuth)Authorize¶added inv2.9.0

func (cClientCoordinateeAuth) Authorize(_context.Context, req *proto.CoordinateRequest)error

type ClientService struct {Loggerslog.LoggerCoordPtr *atomic.Pointer[Coordinator]// contains filtered or unexported fields}

funcNewClientService¶added inv2.6.0

func NewClientService(optionsClientServiceOptions) (*ClientService,error,)

NewClientService returns a ClientService based on the given Coordinator pointer. The pointer isloaded on each processed connection.

func (*ClientService)ServeClient¶added inv2.6.0

func (s *ClientService) ServeClient(ctxcontext.Context, versionstring, connnet.Conn, streamIDStreamID)error

func (ClientService)ServeConnV2¶added inv2.7.0

func (sClientService) ServeConnV2(ctxcontext.Context, connnet.Conn, streamIDStreamID)error

type ClientServiceOptions struct {Loggerslog.LoggerCoordPtr                 *atomic.Pointer[Coordinator]DERPMapUpdateFrequencytime.DurationDERPMapFn                func() *tailcfg.DERPMapNetworkTelemetryHandler  func(batch []*proto.TelemetryEvent)ResumeTokenProviderResumeTokenProviderWorkspaceUpdatesProviderWorkspaceUpdatesProvider}

type ClientUserCoordinateeAuth struct {AuthTunnelAuthorizer}

func (ClientUserCoordinateeAuth)Authorize¶added inv2.18.0

func (aClientUserCoordinateeAuth) Authorize(ctxcontext.Context, req *proto.CoordinateRequest)error

type CloserWaiter interface {Close(context.Context)errorWait() <-chanerror}

type Conn struct {// contains filtered or unexported fields}

funcNewConn¶

func NewConn(options *Options) (conn *Conn, errerror)

NewConn constructs a new Wireguard server that will accept connections from the addresses provided.

func (*Conn)AwaitReachable¶

func (c *Conn) AwaitReachable(ctxcontext.Context, ipnetip.Addr)bool

AwaitReachable pings the provided IP continually until theaddress is reachable. It's the callers responsibility to providea timeout, otherwise this function will block forever.

func (*Conn)Close¶

func (c *Conn) Close()error

Close shuts down the Wireguard connection.

func (*Conn)Closed¶

func (c *Conn) Closed() <-chan struct{}

Closed is a channel that ends when the connection hasbeen closed.

func (*Conn)DERPMap¶

func (c *Conn) DERPMap() *tailcfg.DERPMap

DERPMap returns the currently set DERP mapping.

func (*Conn)DialContextTCP¶

func (c *Conn) DialContextTCP(ctxcontext.Context, ippnetip.AddrPort) (*gonet.TCPConn,error)

func (*Conn)DialContextUDP¶

func (c *Conn) DialContextUDP(ctxcontext.Context, ippnetip.AddrPort) (*gonet.UDPConn,error)

func (*Conn)GetBlockEndpoints¶added inv2.9.0

func (c *Conn) GetBlockEndpoints()bool

func (*Conn)GetKnownPeerIDs¶added inv2.15.0

func (c *Conn) GetKnownPeerIDs() []uuid.UUID

func (*Conn)GetNetInfo¶added inv2.15.0

func (c *Conn) GetNetInfo() *tailcfg.NetInfo

func (*Conn)GetPeerDiagnostics¶added inv2.9.0

func (c *Conn) GetPeerDiagnostics(peerIDuuid.UUID)PeerDiagnostics

func (*Conn)InstallCaptureHook¶added inv2.8.0

func (c *Conn) InstallCaptureHook(fcapture.Callback)

func (*Conn)Listen¶

func (c *Conn) Listen(network, addrstring) (net.Listener,error)

Listen listens for connections only on the Tailscale network.

func (*Conn)MagicsockServeHTTPDebug¶

func (c *Conn) MagicsockServeHTTPDebug(whttp.ResponseWriter, r *http.Request)

func (*Conn)MagicsockSetDebugLoggingEnabled¶

func (c *Conn) MagicsockSetDebugLoggingEnabled(enabledbool)

func (*Conn)Node¶

func (c *Conn) Node() *Node

Node returns the last node that was sent to the node callback.

func (*Conn)NodeAddresses¶

func (c *Conn) NodeAddresses(publicKeykey.NodePublic) ([]netip.Prefix,bool)

NodeAddresses returns the addresses of a node from the NetworkMap.

func (*Conn)Ping¶

func (c *Conn) Ping(ctxcontext.Context, ipnetip.Addr) (time.Duration,bool, *ipnstate.PingResult,error)

Ping sends a ping to the Wireguard engine.The bool returned is true if the ping was performed P2P.

func (*Conn)SendConnectedTelemetry¶added inv2.14.0

func (c *Conn) SendConnectedTelemetry(ipnetip.Addr, applicationstring)

SendConnectedTelemetry should be called when connection to a peer with the given IP is established.

func (*Conn)SendDisconnectedTelemetry¶added inv2.14.0

func (c *Conn) SendDisconnectedTelemetry()

func (*Conn)SendSpeedtestTelemetry¶added inv2.14.0

func (c *Conn) SendSpeedtestTelemetry(throughputMbitsfloat64)

func (*Conn)SetAddresses¶

func (c *Conn) SetAddresses(ips []netip.Prefix)error

func (*Conn)SetAllPeersLost¶added inv2.7.1

func (c *Conn) SetAllPeersLost()

SetAllPeersLost marks all peers lost; typically used when we disconnect from a coordinator.

func (*Conn)SetBlockEndpoints¶

func (c *Conn) SetBlockEndpoints(blockEndpointsbool)

SetBlockEndpoints sets whether to block P2P endpoints. This settingwill only apply to new peers.

func (*Conn)SetConnStatsCallback¶

func (c *Conn) SetConnStatsCallback(maxPeriodtime.Duration, maxConnsint, dump func(start, endtime.Time, virtual, physical map[netlogtype.Connection]netlogtype.Counts))

SetConnStatsCallback sets a callback to be called after maxPeriod ormaxConns, whichever comes first. Multiple calls overwrites the callback.

func (*Conn)SetDERPForceWebSockets¶added inv2.1.3

func (c *Conn) SetDERPForceWebSockets(vbool)

func (*Conn)SetDERPMap¶

func (c *Conn) SetDERPMap(derpMap *tailcfg.DERPMap)

SetDERPMap updates the DERPMap of a connection.

func (*Conn)SetDERPRegionDialer¶

func (c *Conn) SetDERPRegionDialer(dialer func(ctxcontext.Context, region *tailcfg.DERPRegion)net.Conn)

SetDERPRegionDialer updates the dialer to use for connecting to DERP regions.

func (*Conn)SetDNSHosts¶added inv2.18.0

func (c *Conn) SetDNSHosts(hosts map[dnsname.FQDN][]netip.Addr)error

SetDNSHosts replaces the map of DNS hosts for the connection.

func (*Conn)SetNodeCallback¶

func (c *Conn) SetNodeCallback(callback func(node *Node))

func (*Conn)SetTunnelDestination¶added inv2.11.0

func (c *Conn) SetTunnelDestination(iduuid.UUID)

func (*Conn)Status¶

func (c *Conn) Status() *ipnstate.Status

Status returns the current ipnstate of a connection.

func (*Conn)UpdatePeers¶added inv2.7.1

func (c *Conn) UpdatePeers(updates []*proto.CoordinateResponse_PeerUpdate)error

UpdatePeers connects with a set of peers. This can be constantly updated,and peers will continually be reconnected as necessary.

type ControlProtocolClients struct {Closerio.CloserCoordinatorCoordinatorClientDERPDERPClientResumeTokenResumeTokenClientTelemetryTelemetryClientWorkspaceUpdatesWorkspaceUpdatesClient}

type ControlProtocolDialer interface {// Dial connects to the tailnet control plane and returns clients for the different control// sub-protocols (coordination, DERP maps, resume tokens, and telemetry).  If the// ResumeTokenController is not nil, the dialer should query for a resume token and use it to// dial, if available.Dial(ctxcontext.Context, rResumeTokenController) (ControlProtocolClients,error)}

type Controller struct {DialerControlProtocolDialerCoordCtrlCoordinationControllerDERPCtrlDERPControllerResumeTokenCtrlResumeTokenControllerTelemetryCtrlTelemetryControllerWorkspaceUpdatesCtrlWorkspaceUpdatesController// contains filtered or unexported fields}

funcNewController¶added inv2.18.0

func NewController(loggerslog.Logger, dialerControlProtocolDialer, opts ...ControllerOpt) *Controller

NewController creates a new Controller without running it

func (*Controller)Closed¶added inv2.18.0

func (c *Controller) Closed() <-chan struct{}

func (*Controller)Run¶added inv2.18.0

func (c *Controller) Run(ctxcontext.Context)

Run dials the API and uses it with the provided controllers.

type ControllerOpt func(*Controller)

funcWithGracefulTimeout¶added inv2.18.0

func WithGracefulTimeout(timeouttime.Duration)ControllerOpt

funcWithTestClock¶added inv2.18.0

func WithTestClock(clockquartz.Clock)ControllerOpt

type Coordinatee interface {UpdatePeers([]*proto.CoordinateResponse_PeerUpdate)errorSetAllPeersLost()SetNodeCallback(func(*Node))// SetTunnelDestination indicates to tailnet that the peer id is a// destination.SetTunnelDestination(iduuid.UUID)}

type CoordinateeAuth interface {Authorize(ctxcontext.Context, req *proto.CoordinateRequest)error}

type CoordinationController interface {New(CoordinatorClient)CloserWaiter}

funcNewAgentCoordinationController¶added inv2.18.0

func NewAgentCoordinationController(loggerslog.Logger, coordinateeCoordinatee,)CoordinationController

NewAgentCoordinationController creates a CoordinationController for Coder Agents, which nevercreate tunnels and always send ReadyToHandshake acknowledgements.

type Coordinator interface {CoordinatorV2}

funcNewCoordinator¶

func NewCoordinator(loggerslog.Logger)Coordinator

NewCoordinator constructs a new in-memory connection coordinator. Thiscoordinator is incompatible with multiple Coder replicas as all node data isin-memory.

type CoordinatorClient interface {Close()errorSend(*proto.CoordinateRequest)errorRecv() (*proto.CoordinateResponse,error)}

funcNewInMemoryCoordinatorClient¶added inv2.18.0

func NewInMemoryCoordinatorClient(loggerslog.Logger,clientIDuuid.UUID,authCoordinateeAuth,coordinatorCoordinator,)CoordinatorClient

NewInMemoryCoordinatorClient creates a coordination client that uses channels to connect to alocal Coordinator. (The typical alternative is a DRPC-based client.)

type CoordinatorV2 interface {// ServeHTTPDebug serves a debug webpage that shows the internal state of// the coordinator.ServeHTTPDebug(whttp.ResponseWriter, r *http.Request)// Node returns a node by peer ID, if known to the coordinator.  Returns nil if unknown.Node(iduuid.UUID) *NodeClose()errorCoordinate(ctxcontext.Context, iduuid.UUID, namestring, aCoordinateeAuth) (chan<- *proto.CoordinateRequest, <-chan *proto.CoordinateResponse)}

type DERPClient interface {Close()errorRecv() (*tailcfg.DERPMap,error)}

type DERPController interface {New(DERPClient)CloserWaiter}

funcNewBasicDERPController¶added inv2.18.0

func NewBasicDERPController(loggerslog.Logger, setterDERPMapSetter)DERPController

type DERPFromDRPCWrapper struct {Clientproto.DRPCTailnet_StreamDERPMapsClient}

func (*DERPFromDRPCWrapper)Close¶added inv2.18.0

func (w *DERPFromDRPCWrapper) Close()error

func (*DERPFromDRPCWrapper)Recv¶added inv2.18.0

func (w *DERPFromDRPCWrapper) Recv() (*tailcfg.DERPMap,error)

type DERPMapSetter interface {SetDERPMap(derpMap *tailcfg.DERPMap)}

type DNSHostsSetter interface {SetDNSHosts(hosts map[dnsname.FQDN][]netip.Addr)error}

type DNSNameOptions struct {Suffixstring}

type DRPCService struct {CoordPtr                 *atomic.Pointer[Coordinator]Loggerslog.LoggerDerpMapUpdateFrequencytime.DurationDerpMapFn                func() *tailcfg.DERPMapNetworkTelemetryHandler  func(batch []*proto.TelemetryEvent)ResumeTokenProviderResumeTokenProviderWorkspaceUpdatesProviderWorkspaceUpdatesProvider}

func (*DRPCService)Coordinate¶added inv2.7.0

func (s *DRPCService) Coordinate(streamproto.DRPCTailnet_CoordinateStream)error

func (*DRPCService)PostTelemetry¶added inv2.13.0

func (s *DRPCService) PostTelemetry(_context.Context, req *proto.TelemetryRequest) (*proto.TelemetryResponse,error)

func (*DRPCService)RefreshResumeToken¶added inv2.15.0

func (s *DRPCService) RefreshResumeToken(ctxcontext.Context, _ *proto.RefreshResumeTokenRequest) (*proto.RefreshResumeTokenResponse,error)

func (*DRPCService)StreamDERPMaps¶added inv2.6.0

func (s *DRPCService) StreamDERPMaps(_ *proto.StreamDERPMapsRequest, streamproto.DRPCTailnet_StreamDERPMapsStream)error

func (*DRPCService)WorkspaceUpdates¶added inv2.18.0

func (s *DRPCService) WorkspaceUpdates(req *proto.WorkspaceUpdatesRequest, streamproto.DRPCTailnet_WorkspaceUpdatesStream)error

type HTMLDebug struct {Peers   []HTMLPeerTunnels []HTMLTunnel}

type HTMLPeer struct {IDuuid.UUIDNamestringCreatedAgetime.DurationLastWriteAgetime.DurationOverwritesintNodestring}

type HTMLTunnel struct {Src, Dstuuid.UUID}

type InvalidAddressBitsError struct {Bitsint}

func (InvalidAddressBitsError)Error¶added inv2.22.0

func (eInvalidAddressBitsError) Error()string

type InvalidNodeAddressError struct {Addrstring}

func (InvalidNodeAddressError)Error¶added inv2.22.0

func (eInvalidNodeAddressError) Error()string

type NetworkTelemetryBatcher struct {// contains filtered or unexported fields}

funcNewNetworkTelemetryBatcher¶added inv2.14.0

func NewNetworkTelemetryBatcher(clkquartz.Clock, frequencytime.Duration, maxSizeint, batchFn func(batch []*proto.TelemetryEvent)) *NetworkTelemetryBatcher

func (*NetworkTelemetryBatcher)Close¶added inv2.14.0

func (b *NetworkTelemetryBatcher) Close()error

func (*NetworkTelemetryBatcher)Handler¶added inv2.14.0

func (b *NetworkTelemetryBatcher) Handler(events []*proto.TelemetryEvent)

type Node struct {// ID is used to identify the connection.IDtailcfg.NodeID `json:"id"`// AsOf is the time the node was created.AsOftime.Time `json:"as_of"`// Key is the Wireguard public key of the node.Keykey.NodePublic `json:"key"`// DiscoKey is used for discovery messages over DERP to establish// peer-to-peer connections.DiscoKeykey.DiscoPublic `json:"disco"`// PreferredDERP is the DERP server that peered connections should meet at// to establish.PreferredDERPint `json:"preferred_derp"`// DERPLatency is the latency in seconds to each DERP server.DERPLatency map[string]float64 `json:"derp_latency"`// DERPForcedWebsocket contains a mapping of DERP regions to// error messages that caused the connection to be forced to// use WebSockets. We don't use WebSockets by default because// they are less performant.DERPForcedWebsocket map[int]string `json:"derp_forced_websockets"`// Addresses are the IP address ranges this connection exposes.Addresses []netip.Prefix `json:"addresses"`// AllowedIPs specify what addresses can dial the connection. We allow all// by default.AllowedIPs []netip.Prefix `json:"allowed_ips"`// Endpoints are ip:port combinations that can be used to establish// peer-to-peer connections.Endpoints []string `json:"endpoints"`}

funcOnlyNodeUpdates¶added inv2.4.0

func OnlyNodeUpdates(resp *proto.CoordinateResponse) ([]*Node,error)

funcProtoToNode¶added inv2.4.0

func ProtoToNode(p *proto.Node) (*Node,error)

type Options struct {IDuuid.UUIDAddresses  []netip.PrefixDERPMap    *tailcfg.DERPMapDERPHeader *http.Header// DERPForceWebSockets determines whether websockets is always used for DERP// connections, rather than trying `Upgrade: derp` first and potentially// falling back. This is useful for misbehaving proxies that prevent// fallback due to odd behavior, like Azure App Proxy.DERPForceWebSocketsbool// BlockEndpoints specifies whether P2P endpoints are blocked.// If so, only DERPs can establish connections.BlockEndpointsboolLoggerslog.LoggerListenPortuint16// CaptureHook is a callback that captures Disco packets and packets sent// into the tailnet tunnel.CaptureHookcapture.Callback// ForceNetworkUp forces the network to be considered up. magicsock will not// do anything if it thinks it can't reach the internet.ForceNetworkUpbool// Network Telemetry Client Type: CLI | Agent | coderdClientTypeproto.TelemetryEvent_ClientType// TelemetrySink is optional.TelemetrySinkTelemetrySink// DNSConfigurator is optional, and is passed to the underlying wireguard// engine.DNSConfiguratordns.OSConfigurator// Router is optional, and is passed to the underlying wireguard engine.Routerrouter.Router// TUNDev is optional, and is passed to the underlying wireguard engine.TUNDevtun.Device// WireguardMonitor is optional, and is passed to the underlying wireguard// engine.WireguardMonitor *netmon.Monitor// DNSMatchDomain is the DNS suffix to use as a match domain. Only relevant for TUN connections that configure the// OS DNS resolver.DNSMatchDomainstring}

type PeerDiagnostics struct {// PreferredDERP is 0 if we are not connected to a DERP region. If non-zero, we are connected to// the given region as our home or "preferred" DERP.PreferredDERPintDERPRegionNames map[int]string// SentNode is true if we have successfully transmitted our local Node via the most recently set// NodeCallback.SentNodebool// ReceivedNode is the last Node we received for the peer, or nil if we haven't received the node.ReceivedNode *tailcfg.Node// LastWireguardHandshake is the last time we completed a wireguard handshakeLastWireguardHandshaketime.Time}

type ResumeTokenClient interface {RefreshResumeToken(ctxcontext.Context, in *proto.RefreshResumeTokenRequest) (*proto.RefreshResumeTokenResponse,error)}

type ResumeTokenController interface {New(ResumeTokenClient)CloserWaiterToken() (string,bool)}

funcNewBasicResumeTokenController¶added inv2.18.0

func NewBasicResumeTokenController(loggerslog.Logger, clockquartz.Clock)ResumeTokenController

type ResumeTokenKeyProvider struct {// contains filtered or unexported fields}

func (ResumeTokenKeyProvider)GenerateResumeToken¶added inv2.15.0

func (pResumeTokenKeyProvider) GenerateResumeToken(ctxcontext.Context, peerIDuuid.UUID) (*proto.RefreshResumeTokenResponse,error)

func (ResumeTokenKeyProvider)VerifyResumeToken¶added inv2.15.0

func (pResumeTokenKeyProvider) VerifyResumeToken(ctxcontext.Context, strstring) (uuid.UUID,error)

VerifyResumeToken parses a signed tailnet resume token with the given key andreturns the payload. If the token is invalid or expired, an error isreturned.

type ResumeTokenProvider interface {GenerateResumeToken(ctxcontext.Context, peerIDuuid.UUID) (*proto.RefreshResumeTokenResponse,error)VerifyResumeToken(ctxcontext.Context, tokenstring) (uuid.UUID,error)}

funcNewInsecureTestResumeTokenProvider¶added inv2.15.0

func NewInsecureTestResumeTokenProvider()ResumeTokenProvider

NewInsecureTestResumeTokenProvider returns a ResumeTokenProvider that uses arandom key with short expiry for testing purposes. If any errors occur whilegenerating the key, the function panics.

funcNewResumeTokenKeyProvider¶added inv2.15.0

func NewResumeTokenKeyProvider(keyjwtutils.SigningKeyManager, clockquartz.Clock, expirytime.Duration)ResumeTokenProvider

type ResumeTokenSigningKey [64]byte

funcGenerateResumeTokenSigningKey¶added inv2.15.0

func GenerateResumeTokenSigningKey() (ResumeTokenSigningKey,error)

type ServicePrefix [6]byte

func (ServicePrefix)AddrFromUUID¶added inv2.17.0

func (pServicePrefix) AddrFromUUID(uiduuid.UUID)netip.Addr

AddrFromUUID returns an IPv6 address corresponding to the given UUID in the service prefix.

func (ServicePrefix)AsNetip¶added inv2.18.0

func (pServicePrefix) AsNetip()netip.Prefix

func (ServicePrefix)PrefixFromUUID¶added inv2.17.0

func (pServicePrefix) PrefixFromUUID(uiduuid.UUID)netip.Prefix

PrefixFromUUID returns a single IPv6 /128 prefix corresponding to the given UUID.

func (ServicePrefix)RandomAddr¶added inv2.17.0

func (pServicePrefix) RandomAddr()netip.Addr

RandomAddr returns a random IP address in the service prefix.

func (ServicePrefix)RandomPrefix¶added inv2.17.0

func (pServicePrefix) RandomPrefix()netip.Prefix

RandomPrefix returns a single IPv6 /128 prefix within the service prefix.

type SingleTailnetCoordinateeAuth struct{}

func (SingleTailnetCoordinateeAuth)Authorize¶added inv2.9.0

func (SingleTailnetCoordinateeAuth) Authorize(context.Context, *proto.CoordinateRequest)error

type StreamID struct {NamestringIDuuid.UUIDAuthCoordinateeAuth}

type Subscription interface {io.CloserUpdates() <-chan *proto.WorkspaceUpdate}

type TelemetryClient interface {PostTelemetry(ctxcontext.Context, in *proto.TelemetryRequest) (*proto.TelemetryResponse,error)}

type TelemetryController interface {New(TelemetryClient)}

type TelemetrySink interface {// SendTelemetryEvent sends a telemetry event to some external sink.SendTelemetryEvent(event *proto.TelemetryEvent)}

type TelemetryStore struct {// contains filtered or unexported fields}

type TunnelAllOption func(t *TunnelAllWorkspaceUpdatesController)

funcWithDNS¶added inv2.18.0

func WithDNS(dDNSHostsSetter, ownerUsernamestring, optionsDNSNameOptions)TunnelAllOption

WithDNS configures the tunnelAllWorkspaceUpdatesController to set DNS names for all workspacesand agents it learns about.

funcWithHandler¶added inv2.19.0

func WithHandler(hUpdatesHandler)TunnelAllOption

type TunnelAllWorkspaceUpdatesController struct {// contains filtered or unexported fields}

funcNewTunnelAllWorkspaceUpdatesController¶added inv2.18.0

func NewTunnelAllWorkspaceUpdatesController(loggerslog.Logger, c *TunnelSrcCoordController, opts ...TunnelAllOption,) *TunnelAllWorkspaceUpdatesController

NewTunnelAllWorkspaceUpdatesController creates a WorkspaceUpdatesController that creates tunnels(via the TunnelSrcCoordController) to all agents received over the WorkspaceUpdates RPC. If aDNSHostSetter is provided, it also programs DNS hosts based on the agent and workspace names.

func (*TunnelAllWorkspaceUpdatesController)CurrentState¶added inv2.19.0

func (t *TunnelAllWorkspaceUpdatesController) CurrentState() (WorkspaceUpdate,error)

func (*TunnelAllWorkspaceUpdatesController)New¶added inv2.19.0

func (t *TunnelAllWorkspaceUpdatesController) New(clientWorkspaceUpdatesClient)CloserWaiter

type TunnelAuthorizer interface {AuthorizeTunnel(ctxcontext.Context, agentIDuuid.UUID)error}

type TunnelSrcCoordController struct {*BasicCoordinationController// contains filtered or unexported fields}

funcNewTunnelSrcCoordController¶added inv2.18.0

func NewTunnelSrcCoordController(loggerslog.Logger, coordinateeCoordinatee,) *TunnelSrcCoordController

NewTunnelSrcCoordController creates a CoordinationController for peers that are exclusivelytunnel sources (that is, they create tunnel --- Coder clients not workspaces).

func (*TunnelSrcCoordController)AddDestination¶added inv2.18.0

func (c *TunnelSrcCoordController) AddDestination(destuuid.UUID)

func (*TunnelSrcCoordController)New¶added inv2.18.0

func (c *TunnelSrcCoordController) New(clientCoordinatorClient)CloserWaiter

func (*TunnelSrcCoordController)RemoveDestination¶added inv2.18.0

func (c *TunnelSrcCoordController) RemoveDestination(destuuid.UUID)

func (*TunnelSrcCoordController)SyncDestinations¶added inv2.18.0

func (c *TunnelSrcCoordController) SyncDestinations(destinations []uuid.UUID)

type UpdateKindint

type UpdatesHandler interface {Update(WorkspaceUpdate)error}

type Workspace struct {IDuuid.UUIDNamestringStatusproto.Workspace_Status// contains filtered or unexported fields}

func (*Workspace)Clone¶added inv2.22.0

func (w *Workspace) Clone()Workspace

type WorkspaceUpdate struct {UpsertedWorkspaces []*WorkspaceUpsertedAgents     []*AgentDeletedWorkspaces  []*WorkspaceDeletedAgents      []*AgentKindUpdateKind}

func (*WorkspaceUpdate)Clone¶added inv2.19.0

func (w *WorkspaceUpdate) Clone()WorkspaceUpdate

type WorkspaceUpdatesClient interface {Close()errorRecv() (*proto.WorkspaceUpdate,error)}

type WorkspaceUpdatesController interface {New(WorkspaceUpdatesClient)CloserWaiter}

type WorkspaceUpdatesProvider interface {io.CloserSubscribe(ctxcontext.Context, userIDuuid.UUID) (Subscription,error)}