mirror of
https://github.com/livekit/livekit.git
synced 2026-09-25 13:24:13 +00:00
Paul WellsandClaude Opus 5
36966911ed
StartWebTransport built the node's only HTTP/3 listener from inside AgentService: it minted the TLS config, bound the UDP socket, assembled an h3 mux and returned a stop closure LivekitServer held in agentWTStop. Every other listener is constructed in NewLivekitServer and delegates to a service, and agents are the first consumer of HTTP/3 rather than the last. webtransport.go now carries the transport with no agent references: WebTransportTLS, NewWebTransportServer, NewWebTransportHandler, ListenWebTransport, and WithWebTransportServer/GetWebTransportServer, which put the serving server in the request context so a route that upgrades is a conventional http.Handler instead of a closure over the server. The listener is built in NewLivekitServer beside the prometheus and debug servers, bound in Start with the other listeners, and stopped once doneChan unblocks, so no stop closure is held on LivekitServer. /agent is a route on its mux, as it is on the API mux. UpgradeWebTransport unwraps the ResponseWriter before upgrading. webtransport-go type-asserts it to http3.Settingser and http3.HTTPStreamer without checking and negroni wraps the writer on every chain, so the h3 listener could not carry a middleware chain at all. It now runs the same recovery, api-key auth and path normalization as the TCP chain. AgentService splits into AgentWSService and AgentWTService over the shared AgentHandler, and the endpoint front becomes AgentEndpointService. wire builds all four and threads one endpoint.Registry into the handler and the front. NewAgentHandler takes the config and builds its own ServerInfo, so endpointsConfig and singleAPIKey are set at construction and the psrpc server is registered against a fully formed handler; it previously bound one whose embedded *AgentHandler was still nil. The listener's port and certificate move to a top-level webtransport config block. The listener no longer reads agents.endpoints.disabled, which continues to refuse endpoint registrations. ListenWebTransport binds one socket per bind address, where the h3 listener ignored bind_addresses that every TCP listener honoured. NewWorkerRegisterer takes a variadic WorkerRegisterHandler, each handler reading the request and filling its part of the response and the registration, replacing the single EndpointSettingsFunc threaded through HandleRegister. EndpointRegisterHandler is the endpoint declaration's turn, and endpoint.NegotiateSettings holds the protocol negotiation the OSS and cloud handshakes each carried a copy of. Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
103 lines
2.8 KiB
Go
103 lines
2.8 KiB
Go
// Copyright 2024 LiveKit, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package service
|
|
|
|
import (
|
|
"net/http"
|
|
"strconv"
|
|
|
|
"github.com/gorilla/websocket"
|
|
|
|
"github.com/livekit/livekit-server/pkg/agent"
|
|
"github.com/livekit/livekit-server/pkg/config"
|
|
"github.com/livekit/livekit-server/pkg/rtc"
|
|
)
|
|
|
|
type AgentSocketUpgrader struct {
|
|
websocket.Upgrader
|
|
}
|
|
|
|
func (u AgentSocketUpgrader) Upgrade(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
responseHeader http.Header,
|
|
) (
|
|
conn *websocket.Conn,
|
|
registration agent.WorkerRegistration,
|
|
ok bool,
|
|
) {
|
|
if u.CheckOrigin == nil {
|
|
// allow connections from any origin, since script may be hosted anywhere
|
|
// security is enforced by access tokens
|
|
u.CheckOrigin = func(r *http.Request) bool {
|
|
return true
|
|
}
|
|
}
|
|
|
|
if !websocket.IsWebSocketUpgrade(r) {
|
|
w.WriteHeader(404)
|
|
return
|
|
}
|
|
|
|
claims := GetGrants(r.Context())
|
|
if claims == nil || claims.Video == nil || !claims.Video.Agent {
|
|
HandleError(w, r, http.StatusUnauthorized, rtc.ErrPermissionDenied)
|
|
return
|
|
}
|
|
|
|
registration = agent.MakeWorkerRegistration()
|
|
registration.ClientIP = GetClientIP(r)
|
|
|
|
conn, err := u.Upgrader.Upgrade(w, r, responseHeader)
|
|
if err != nil {
|
|
HandleError(w, r, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
|
|
if pv, err := strconv.Atoi(r.FormValue("protocol")); err == nil {
|
|
registration.Protocol = agent.WorkerProtocolVersion(pv)
|
|
}
|
|
|
|
return conn, registration, true
|
|
}
|
|
|
|
// AgentWSService serves a worker's WebSocket control connection on /agent:
|
|
// control and job dispatch only, with no data-plane session for HTTP endpoints.
|
|
type AgentWSService struct {
|
|
*AgentHandler
|
|
|
|
upgrader AgentSocketUpgrader
|
|
signalMessageSizeLimit int64
|
|
}
|
|
|
|
func NewAgentWSService(conf *config.Config, h *AgentHandler) *AgentWSService {
|
|
return &AgentWSService{
|
|
AgentHandler: h,
|
|
signalMessageSizeLimit: conf.Limit.AgentSignalMessageSizeLimit,
|
|
}
|
|
}
|
|
|
|
func (s *AgentWSService) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
if conn, registration, ok := s.upgrader.Upgrade(w, r, nil); ok {
|
|
// bound a single signalling frame before it is buffered; 0 disables
|
|
if s.signalMessageSizeLimit > 0 {
|
|
conn.SetReadLimit(s.signalMessageSizeLimit)
|
|
}
|
|
sigConn := NewWSSignalConnection(conn, s.signalMessageSizeLimit)
|
|
defer sigConn.Close()
|
|
s.HandleConnection(r.Context(), sigConn, registration)
|
|
}
|
|
}
|