gen: coderd/database/querier.go peerbroker/proto/peerbroker.pb.go provisionersdk/proto/provisioner.pb.go provisionerd/proto/provisionerd.pb.go site/src/api/typesGenerated.ts

peerbroker/proto/peerbroker.pb.go: peerbroker/proto/peerbroker.proto

protoc \

--go_out=. \

--go_opt=paths=source_relative \

--go-drpc_out=. \

--go-drpc_opt=paths=source_relative \

./peerbroker/proto/peerbroker.proto

"github.com/coder/coder/peer"

"github.com/coder/coder/peerbroker"

WebRTCDialer WebRTCDialer

type WebRTCDialer func(ctx context.Context, logger slog.Logger) (*peerbroker.Listener, error)

webrtcDialer: options.WebRTCDialer,

webrtcDialer WebRTCDialer

logger slog.Logger

if a.webrtcDialer != nil {

go a.runWebRTCNetworking(ctx)

}

func (a *agent) runWebRTCNetworking(ctx context.Context) {

var peerListener *peerbroker.Listener

var err error

// An exponential back-off occurs when the connection is failing to dial.

// This is to prevent server spam in case of a coderd outage.

for retrier := retry.New(50*time.Millisecond, 10*time.Second); retrier.Wait(ctx); {

peerListener, err = a.webrtcDialer(ctx, a.logger)

if err != nil {

if errors.Is(err, context.Canceled) {

return

}

if a.isClosed() {

return

}

a.logger.Warn(context.Background(), "failed to dial", slog.Error(err))

continue

}

a.logger.Info(context.Background(), "connected to webrtc broker")

break

}

select {

case <-ctx.Done():

return

default:

}

for {

conn, err := peerListener.Accept()

if err != nil {

if a.isClosed() {

return

}

a.logger.Debug(ctx, "peer listener accept exited; restarting connection", slog.Error(err))

a.runWebRTCNetworking(ctx)

return

}

a.closeMutex.Lock()

a.connCloseWait.Add(1)

a.closeMutex.Unlock()

go a.handlePeerConn(ctx, conn)

}

}

func (a *agent) handlePeerConn(ctx context.Context, peerConn *peer.Conn) {

go func() {

select {

case <-a.closed:

case <-peerConn.Closed():

}

_ = peerConn.Close()

a.connCloseWait.Done()

}()

for {

channel, err := peerConn.Accept(ctx)

if err != nil {

if errors.Is(err, peer.ErrClosed) || a.isClosed() {

return

}

a.logger.Debug(ctx, "accept channel from peer connection", slog.Error(err))

return

}

conn := channel.NetConn()

switch channel.Protocol() {

case ProtocolSSH:

go a.sshServer.HandleConn(a.stats.wrapConn(conn))

case ProtocolReconnectingPTY:

rawID := channel.Label()

// The ID format is referenced in conn.go.

// <uuid>:<height>:<width>

idParts := strings.SplitN(rawID, ":", 4)

if len(idParts) != 4 {

a.logger.Warn(ctx, "client sent invalid id format", slog.F("raw-id", rawID))

continue

}

id := idParts[0]

// Enforce a consistent format for IDs.

_, err := uuid.Parse(id)

if err != nil {

a.logger.Warn(ctx, "client sent reconnection token that isn't a uuid", slog.F("id", id), slog.Error(err))

continue

}

// Parse the initial terminal dimensions.

height, err := strconv.Atoi(idParts[1])

if err != nil {

a.logger.Warn(ctx, "client sent invalid height", slog.F("id", id), slog.F("height", idParts[1]))

continue

}

width, err := strconv.Atoi(idParts[2])

if err != nil {

a.logger.Warn(ctx, "client sent invalid width", slog.F("id", id), slog.F("width", idParts[2]))

continue

}

go a.handleReconnectingPTY(ctx, reconnectingPTYInit{

ID: id,

Height: uint16(height),

Width: uint16(width),

Command: idParts[3],

}, a.stats.wrapConn(conn))

case ProtocolDial:

go a.handleDial(ctx, channel.Label(), a.stats.wrapConn(conn))

default:

a.logger.Warn(ctx, "unhandled protocol from channel",

slog.F("protocol", channel.Protocol()),

slog.F("label", channel.Label()),

)

}

}

}