server

package
v0.0.0-...-b09c24f Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 9, 2023 License: Apache-2.0 Imports: 44 Imported by: 0

Documentation

Index

Constants

View Source 
const IOSH264Fmtp = "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f"

Variables

View Source 
var ErrDuplicateClientID = errors.New("duplicate client id")

Functions

func InitConfig 

func InitConfig(c *Config)

func NewInterceptorRegistry 

func NewInterceptorRegistry(mediaEngine *webrtc.MediaEngine) (*interceptor.Registry, error)

func NewMediaEngine 

func NewMediaEngine() *webrtc.MediaEngine

func NewMeshHandler 

func NewMeshHandler(log logger.Logger, wss *WSS) http.Handler

func NewNetworkTypes 

func NewNetworkTypes(log logger.Logger, networkTypes []string) (ret []webrtc.NetworkType)

func ParseUDPAddr 

func ParseUDPAddr(addr string) (*net.UDPAddr, error)

func ParseUDPAddrs 

func ParseUDPAddrs(addrs []string) ([]*net.UDPAddr, error)

func ReadConfigFile 

func ReadConfigFile(filename string, c *Config) (err error)

func ReadConfigFiles 

func ReadConfigFiles(filenames []string, c *Config) (err error)

func ReadConfigFromEnv 

func ReadConfigFromEnv(prefix string, c *Config)

func ReadConfigYAML 

func ReadConfigYAML(reader io.Reader, c *Config) error

func RegisterCodecs 

func RegisterCodecs(mediaEngine *webrtc.MediaEngine, registry *codecs.Registry)

Types

type Adapter 

type Adapter interface {
	Add(client ClientWriter) error
	Remove(clientID identifiers.ClientID) error
	Broadcast(msg message.Message) error
	Metadata(clientID identifiers.ClientID) (string, bool)
	SetMetadata(clientID identifiers.ClientID, metadata string) bool
	Emit(clientID identifiers.ClientID, msg message.Message) error
	Clients() (map[identifiers.ClientID]string, error)
	Size() (int, error)
	Close() error
}

type AdapterFactory 

type AdapterFactory struct {
	NewAdapter func(room identifiers.RoomID) Adapter
	// contains filtered or unexported fields
}

func NewAdapterFactory 

func NewAdapterFactory(log logger.Logger, c StoreConfig) *AdapterFactory

func (*AdapterFactory) Close 

func (a *AdapterFactory) Close() (err error)

type AdapterRoomManager 

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

func NewAdapterRoomManager 

func NewAdapterRoomManager(newAdapter NewAdapterFunc) *AdapterRoomManager

func (*AdapterRoomManager) Enter 

func (r *AdapterRoomManager) Enter(room identifiers.RoomID) (adapter Adapter, isNew bool)

func (*AdapterRoomManager) Exit 

func (r *AdapterRoomManager) Exit(room identifiers.RoomID) (isRemoved bool)

type AuthType 

type AuthType string
const (
	AuthTypeSecret AuthType = "secret"
	AuthTypeNone   AuthType = ""
)

type ByteSerializer 

type ByteSerializer struct{}

func (ByteSerializer) Deserialize 

func (s ByteSerializer) Deserialize(data []byte) (msg message.Message, err error)

func (ByteSerializer) Serialize 

func (s ByteSerializer) Serialize(m message.Message) ([]byte, error)

type ChannelRoomManager 

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

func NewChannelRoomManager 

func NewChannelRoomManager(roomManager RoomManager) *ChannelRoomManager

func (*ChannelRoomManager) AcceptEvent 

func (r *ChannelRoomManager) AcceptEvent() (RoomEvent, error)

func (*ChannelRoomManager) Close 

func (r *ChannelRoomManager) Close()

Close exists for tests. This channel should always stay open IRL.

func (*ChannelRoomManager) Enter 

func (r *ChannelRoomManager) Enter(room identifiers.RoomID) (adapter Adapter, isNew bool)

func (*ChannelRoomManager) Exit 

func (r *ChannelRoomManager) Exit(room identifiers.RoomID) (isRemoved bool)

func (*ChannelRoomManager) RoomEventsChannel 

func (r *ChannelRoomManager) RoomEventsChannel() <-chan RoomEvent

type Client 

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

An abstraction for sending out to websocket using channels.

func NewClient 

func NewClient(conn WSReadWriter) *Client

Creates a new websocket client.

func NewClientWithID 

func NewClientWithID(conn WSReadWriter, id identifiers.ClientID) *Client

func (*Client) Close 

func (c *Client) Close(statusCode websocket.StatusCode, reason string) error

Close invokes Close on the underlying websocket connection.

func (*Client) Err 

func (c *Client) Err() error

Err returns the read error that might have occurred. It should be called after the Messages channel is closed.

func (*Client) ID 

func (c *Client) ID() identifiers.ClientID

func (*Client) Messages 

func (c *Client) Messages() <-chan message.Message

Messages returns the read messages.

func (*Client) Metadata 

func (c *Client) Metadata() string

func (*Client) SetMetadata 

func (c *Client) SetMetadata(metadata string)

func (*Client) Write 

func (c *Client) Write(msg message.Message) error

Write writes a message to client socket with the default timeout.

func (*Client) WriteCtx 

func (c *Client) WriteCtx(ctx context.Context, msg message.Message) error

Writes a message to websocket.

type ClientConfig 

type ClientConfig struct {
	BaseURL    string      `json:"baseUrl"`
	Nickname   string      `json:"nickname"`
	CallID     string      `json:"callId"`
	PeerID     string      `json:"peerId"`
	PeerConfig PeerConfig  `json:"peerConfig"`
	Network    NetworkType `json:"network"`
}

type ClientWriter 

type ClientWriter interface {
	ID() identifiers.ClientID
	Write(msg message.Message) error
	Metadata() string
	SetMetadata(metadata string)
}

type Config 

type Config struct {
	BaseURL  string `yaml:"base_url"`
	BindHost string `yaml:"bind_host"`
	BindPort int    `yaml:"bind_port"`

	// When FS is non empty, it will be used as a root path to the resource files.
	FS         string           `yaml:"fs"`
	ICEServers []ICEServer      `yaml:"ice_servers"`
	TLS        TLSConfig        `yaml:"tls"`
	Store      StoreConfig      `yaml:"store"`
	Network    NetworkConfig    `yaml:"network"`
	Prometheus PrometheusConfig `yaml:"prometheus"`

	Frontend Frontend `yaml:"frontend"`
}

func ReadConfig 

func ReadConfig(filenames []string) (c Config, err error)

type DataTransceiver 

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

func NewDataTransceiver 

func NewDataTransceiver(
	log logger.Logger,
	clientID identifiers.ClientID,
	dataChannel *webrtc.DataChannel,
	peerConnection *webrtc.PeerConnection,
) *DataTransceiver

func (*DataTransceiver) Close 

func (d *DataTransceiver) Close()

func (*DataTransceiver) MessagesChannel 

func (d *DataTransceiver) MessagesChannel() <-chan webrtc.DataChannelMessage

func (*DataTransceiver) Send 

func (d *DataTransceiver) Send(message webrtc.DataChannelMessage) <-chan error

type Deserializer 

type Deserializer interface {
	Deserialize([]byte) (message.Message, error)
}

type Doner 

type Doner interface {
	Done()
}

type Embed 

type Embed struct {
	Templates fs.FS
	Static    fs.FS
	Resources fs.FS
}

type Frontend 

type Frontend struct {
	EncodedInsertableStreams bool `yaml:"encodedInsertableStreams"`
}

type ICEAuthServer 

type ICEAuthServer struct {
	URLs       []string `json:"urls"`
	Username   string   `json:"username,omitempty"`
	Credential string   `json:"credential,omitempty"`
}

func GetICEAuthServers 

func GetICEAuthServers(servers []ICEServer) (result []ICEAuthServer)

type ICEServer 

type ICEServer struct {
	URLs       []string `yaml:"urls"`
	AuthType   AuthType `yaml:"auth_type"`
	AuthSecret struct {
		Username string `yaml:"username"`
		Secret   string `yaml:"secret"`
	} `yaml:"auth_secret"`
}

type JSONMessage 

type JSONMessage struct {
	Type    string `json:"type"`
	Payload string `json:"payload"`
}

type LocalTrack 

type LocalTrack struct {
	*webrtc.TrackLocalStaticRTP
	// contains filtered or unexported fields
}

func (LocalTrack) Track 

func (t LocalTrack) Track() transport.Track

type MemoryAdapter 

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

func NewMemoryAdapter 

func NewMemoryAdapter(room identifiers.RoomID) *MemoryAdapter

func (*MemoryAdapter) Add 

func (m *MemoryAdapter) Add(client ClientWriter) (err error)

Add a client to the room. Will return an error on duplicate client ID.

func (*MemoryAdapter) Broadcast 

func (m *MemoryAdapter) Broadcast(msg message.Message) error

Send a message to all sockets

func (*MemoryAdapter) Clients 

func (m *MemoryAdapter) Clients() (clientIDs map[identifiers.ClientID]string, err error)

Returns clients with metadata

func (*MemoryAdapter) Close 

func (m *MemoryAdapter) Close() error

func (*MemoryAdapter) Emit 

func (m *MemoryAdapter) Emit(clientID identifiers.ClientID, msg message.Message) error

Sends a message to specific socket.

func (*MemoryAdapter) Metadata 

func (m *MemoryAdapter) Metadata(clientID identifiers.ClientID) (metadata string, ok bool)

func (*MemoryAdapter) Remove 

func (m *MemoryAdapter) Remove(clientID identifiers.ClientID) (err error)

Remove a client from the room

func (*MemoryAdapter) SetMetadata 

func (m *MemoryAdapter) SetMetadata(clientID identifiers.ClientID, metadata string) (ok bool)

func (*MemoryAdapter) Size 

func (m *MemoryAdapter) Size() (value int, err error)

type MultiErrorHandler 

type MultiErrorHandler = multierr.MultiErr

type Mux 

type Mux struct {
	BaseURL string
	// contains filtered or unexported fields
}

func NewMux 

func NewMux(
	log logger.Logger,
	baseURL string,
	version string,
	network NetworkConfig,
	iceServers []ICEServer,
	encodedInsertableStreams bool,
	rooms RoomManager,
	tracks TracksManager,
	prom PrometheusConfig,
	embed Embed,
) *Mux

func (*Mux) ServeHTTP 

func (mux *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request)

type Negotiator 

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

func NewNegotiator 

func NewNegotiator(
	log logger.Logger,
	initiator bool,
	peerConnection *webrtc.PeerConnection,
	onOffer func(webrtc.SessionDescription, error),
	onRequestNegotiation func(),
) *Negotiator

func (*Negotiator) AddTransceiverFromKind 

func (n *Negotiator) AddTransceiverFromKind(t TransceiverRequest)

func (*Negotiator) Done 

func (n *Negotiator) Done() <-chan struct{}

func (*Negotiator) Negotiate 

func (n *Negotiator) Negotiate() (done <-chan struct{})

type NetworkConfig 

type NetworkConfig struct {
	Type NetworkType      `yaml:"type"`
	SFU  NetworkConfigSFU `yaml:"sfu"`
}

type NetworkConfigSFU 

type NetworkConfigSFU struct {
	Interfaces []string `yaml:"interfaces"`
	// JitterBuffer is disabled for now.
	JitterBuffer  bool            `yaml:"jitter_buffer"`
	Protocols     []string        `yaml:"protocols"`
	TCPBindAddr   string          `yaml:"tcp_bind_addr"`
	TCPListenPort int             `yaml:"tcp_listen_port"`
	Transport     TransportConfig `yaml:"transport"`
	UDP           struct {
		PortMin uint16 `yaml:"port_min"`
		PortMax uint16 `yaml:"port_max"`
	} `yaml:"udp"`
}

type NetworkType 

type NetworkType string
const (
	NetworkTypeMesh NetworkType = "mesh"
	NetworkTypeSFU  NetworkType = "sfu"
)

type NewAdapterFunc 

type NewAdapterFunc func(room identifiers.RoomID) Adapter

type NodeManager 

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

func NewNodeManager 

func NewNodeManager(params NodeManagerParams) (*NodeManager, error)

func (*NodeManager) Close 

func (nm *NodeManager) Close() error

type NodeManagerParams 

type NodeManagerParams struct {
	Log           logger.Logger
	RoomManager   *ChannelRoomManager
	TracksManager TracksManager
	ListenAddr    *net.UDPAddr
	Nodes         []*net.UDPAddr
}

type PageHandler 

type PageHandler func(
	w http.ResponseWriter,
	r *http.Request,
) (templateName string, data interface{}, err error)

type Params 

type Params struct {
	TLSCertFile string
	TLSKeyFile  string
}

type PeerConfig 

type PeerConfig struct {
	ICEServers               []ICEAuthServer `json:"iceServers"`
	EncodedInsertableStreams bool            `json:"encodedInsertableStreams"`
}

type Pinger 

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

Pinger is a component that sends pings to clients on a regular interval and receives pongs back.

func NewPinger 

func NewPinger(ctx context.Context, dur time.Duration, ping func()) *Pinger

NewPinger creates a new instance of Pinger and starts a ticker whose duration is set to dur. The ping callback is called on every interval. The main event loop will be closed when ctx is done.

func (*Pinger) ReceivePong 

func (p *Pinger) ReceivePong()

ReceivePong notifies the main event loop of a new pong response in a non-blocking manner.

type PrometheusConfig 

type PrometheusConfig struct {
	AccessToken string `yaml:"access_token"`
}

type ReadyMessage 

type ReadyMessage struct {
	PeerID string `json:"peerId"`
	Room   string `json:"room"`
}

type RedisAdapter 

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

func NewRedisAdapter 

func NewRedisAdapter(
	log logger.Logger,
	pubRedis *redis.Client,
	subRedis *redis.Client,
	prefix string,
	room identifiers.RoomID,
) *RedisAdapter

func (*RedisAdapter) Add 

func (a *RedisAdapter) Add(client ClientWriter) (err error)

func (*RedisAdapter) Broadcast 

func (a *RedisAdapter) Broadcast(msg message.Message) error

func (*RedisAdapter) Clients 

func (a *RedisAdapter) Clients() (map[identifiers.ClientID]string, error)

Returns IDs of all known clients connected to this room

func (*RedisAdapter) Close 

func (a *RedisAdapter) Close() error

Close closes the subscription, but not the redis clients

func (*RedisAdapter) Emit 

func (a *RedisAdapter) Emit(clientID identifiers.ClientID, msg message.Message) error

func (*RedisAdapter) Metadata 

func (a *RedisAdapter) Metadata(clientID identifiers.ClientID) (metadata string, ok bool)

func (*RedisAdapter) Remove 

func (a *RedisAdapter) Remove(clientID identifiers.ClientID) error

func (*RedisAdapter) SetMetadata 

func (a *RedisAdapter) SetMetadata(clientID identifiers.ClientID, metadata string) (ok bool)

func (*RedisAdapter) Size 

func (a *RedisAdapter) Size() (size int, err error)

Returns count of all known clients connected to this room

type RedisConfig 

type RedisConfig struct {
	Host   string `yaml:"host"`
	Port   int    `yaml:"port"`
	Prefix string `yaml:"prefix"`
}

type RemoteTrack 

type RemoteTrack struct {
	*webrtc.TrackRemote
	// contains filtered or unexported fields
}

func (RemoteTrack) Track 

func (t RemoteTrack) Track() transport.Track

type Renderer 

type Renderer struct {
	Version string
	BaseURL string
	// contains filtered or unexported fields
}

func NewRenderer 

func NewRenderer(log logger.Logger, templates Templates, baseURL string, version string) *Renderer

func (*Renderer) Render 

func (tr *Renderer) Render(h PageHandler) http.HandlerFunc

type RoomEvent 

type RoomEvent struct {
	RoomName identifiers.RoomID
	Type     RoomEventType
}

type RoomEventType 

type RoomEventType int
const (
	RoomEventTypeAdd RoomEventType = iota + 1
	RoomEventTypeRemove
)

type RoomManager 

type RoomManager interface {
	Enter(room identifiers.RoomID) (adapter Adapter, isNew bool)
	Exit(room identifiers.RoomID) (isRemoved bool)
}

type RoomManagerFactory 

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

func NewRoomManagerFactory 

func NewRoomManagerFactory(params RoomManagerFactoryParams) *RoomManagerFactory

func (*RoomManagerFactory) NewRoomManager 

func (rmf *RoomManagerFactory) NewRoomManager(c NetworkConfig) (RoomManager, *NodeManager)

type RoomManagerFactoryParams 

type RoomManagerFactoryParams struct {
	AdapterFactory *AdapterFactory
	TracksManager  TracksManager
	Log            logger.Logger
}

type SFU 

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

func NewSFUHandler 

func NewSFUHandler(
	log logger.Logger,
	wss *WSS,
	iceServers []ICEServer,
	sfuConfig NetworkConfigSFU,
	tracksManager TracksManager,
) *SFU

func (*SFU) ServeHTTP 

func (sfu *SFU) ServeHTTP(w http.ResponseWriter, r *http.Request)

type Serializer 

type Serializer interface {
	Serialize(message.Message) ([]byte, error)
}

type Server 

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

func New 

func New(params Params, handler http.Handler) *Server

func NewPProf 

func NewPProf() *Server

func (Server) Start 

func (s Server) Start(ctx context.Context, l net.Listener) error

type Signaller 

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

func NewSignaller 

func NewSignaller(
	log logger.Logger,
	initiator bool,
	peerConnection *webrtc.PeerConnection,
) (*Signaller, error)

func (*Signaller) Close 

func (s *Signaller) Close() (err error)

func (*Signaller) Done 

func (s *Signaller) Done() <-chan struct{}

This does not close any channel, but returns a channel that can be used for signalling closing of peer connection

func (*Signaller) Initiator 

func (s *Signaller) Initiator() bool

func (*Signaller) Negotiate 

func (s *Signaller) Negotiate() <-chan struct{}

Create an offer and send it to remote peer

func (*Signaller) NegotiationDone 

func (s *Signaller) NegotiationDone() <-chan struct{}

NegotiationDone returns the channel that will be closed as soon as the current negotiation is done. If there is no negotiation in progress, it returns a closed channel. If there is a negotiation in progress, and the negotiation was initiated by a call to Negotiate(), it will return the same channel as Negotiate.

func (*Signaller) SendTransceiverRequest 

func (s *Signaller) SendTransceiverRequest(kind webrtc.RTPCodecType, direction webrtc.RTPTransceiverDirection)

Sends a request for a new transceiver, only if the peer is not the initiator.

func (*Signaller) Signal 

func (s *Signaller) Signal(signal message.Signal) error

func (*Signaller) SignalChannel 

func (s *Signaller) SignalChannel() <-chan message.Signal

type SocketHandler 

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

func NewSocketHandler 

func NewSocketHandler(
	ctx context.Context,
	log logger.Logger,
	tracksManager TracksManager,
	webRTCTransportFactory *WebRTCTransportFactory,
	clientID identifiers.ClientID,
	room identifiers.RoomID,
	adapter Adapter,
) *SocketHandler

func (*SocketHandler) HandleMessage 

func (sh *SocketHandler) HandleMessage(msg message.Message) error

func (*SocketHandler) HangUp 

func (sh *SocketHandler) HangUp()

type StoreConfig 

type StoreConfig struct {
	Type  StoreType   `yaml:"type"`
	Redis RedisConfig `yaml:"redis"`
}

type StoreType 

type StoreType string
const (
	StoreTypeMemory StoreType = "memory"
	StoreTypeRedis  StoreType = "redis"
)

type TLSConfig 

type TLSConfig struct {
	Cert string `yaml:"cert"`
	Key  string `yaml:"key"`
}

type Templates 

type Templates map[string]*template.Template

func ParseTemplates 

func ParseTemplates(templatesFS fs.FS) Templates

func (Templates) Get 

func (t Templates) Get(name string) (tpl *template.Template, ok bool)

type TracksManager 

type TracksManager interface {
	Add(room identifiers.RoomID, transport transport.Transport) (<-chan pubsub.PubTrackEvent, error)
	Sub(params sfu.SubParams) error
	Unsub(params sfu.SubParams) error
}

type TransceiverRequest 

type TransceiverRequest struct {
	CodecType webrtc.RTPCodecType
	Init      webrtc.RtpTransceiverInit
}

type TransportConfig 

type TransportConfig struct {
	ListenAddr string `yaml:"listen_addr"`
	Nodes      []string
}

type WSCloser 

type WSCloser interface {
	Close(statusCode websocket.StatusCode, reason string) error
}

type WSReadWriter 

type WSReadWriter interface {
	WSReader
	WSWriter
	WSCloser
}

type WSReader 

type WSReader interface {
	Read(ctx context.Context) (websocket.MessageType, []byte, error)
}

type WSS 

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

func NewWSS 

func NewWSS(log logger.Logger, rooms RoomManager) *WSS

func (*WSS) NewWebsocketContext 

func (wss *WSS) NewWebsocketContext(w http.ResponseWriter, r *http.Request) (*WebsocketContext, error)

NewWebsocketContext initializes a new websocket connection. Users must remember to call WebsocketContext.Close after they are done with the connection.

type WSWriter 

type WSWriter interface {
	Write(ctx context.Context, typ websocket.MessageType, msg []byte) error
}

type WebRTCTransport 

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

func NewWebRTCTransport 

func NewWebRTCTransport(
	log logger.Logger,
	roomID identifiers.RoomID,
	clientID identifiers.ClientID,
	peerID identifiers.PeerID,
	initiator bool,
	peerConnection *webrtc.PeerConnection,
	codecRegistry *codecs.Registry,
) (*WebRTCTransport, error)

func (*WebRTCTransport) AddTrack 

func (p *WebRTCTransport) AddTrack(t transport.Track) (transport.TrackLocal, transport.RTCPReader, error)

func (*WebRTCTransport) ClientID 

func (p *WebRTCTransport) ClientID() identifiers.ClientID

func (*WebRTCTransport) Close 

func (p *WebRTCTransport) Close() error

func (*WebRTCTransport) Done 

func (p *WebRTCTransport) Done() <-chan struct{}

func (*WebRTCTransport) LocalTracks 

func (p *WebRTCTransport) LocalTracks() []transport.TrackWithMID

LocalTracks returns info about sending tracks

func (*WebRTCTransport) MessagesChannel 

func (p *WebRTCTransport) MessagesChannel() <-chan webrtc.DataChannelMessage

func (*WebRTCTransport) RemoteTracksChannel 

func (p *WebRTCTransport) RemoteTracksChannel() <-chan transport.TrackRemoteWithRTCPReader

func (*WebRTCTransport) RemoveTrack 

func (p *WebRTCTransport) RemoveTrack(trackID identifiers.TrackID) error

func (*WebRTCTransport) Send 

func (p *WebRTCTransport) Send(message webrtc.DataChannelMessage) <-chan error

func (*WebRTCTransport) Signal 

func (p *WebRTCTransport) Signal(signal message.Signal) error

func (*WebRTCTransport) SignalChannel 

func (p *WebRTCTransport) SignalChannel() <-chan message.Signal

func (*WebRTCTransport) Type 

func (p *WebRTCTransport) Type() transport.Type

func (*WebRTCTransport) WriteRTCP 

func (p *WebRTCTransport) WriteRTCP(packets []rtcp.Packet) error

type WebRTCTransportFactory 

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

func NewWebRTCTransportFactory 

func NewWebRTCTransportFactory(
	log logger.Logger,
	iceServers []ICEServer,
	sfuConfig NetworkConfigSFU,
) *WebRTCTransportFactory

func (WebRTCTransportFactory) NewWebRTCTransport 

func (f WebRTCTransportFactory) NewWebRTCTransport(
	roomID identifiers.RoomID,
	clientID identifiers.ClientID,
	peerID identifiers.PeerID,
) (*WebRTCTransport, error)

type WebsocketContext 

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

func NewWebsocketContext 

func NewWebsocketContext(
	adapter Adapter, client *Client, roomID identifiers.RoomID, onClose func(),
) *WebsocketContext

NewWebsocketContext initializes the new websocket context. Users must call the Close method once they are done.

func (*WebsocketContext) Adapter 

func (w *WebsocketContext) Adapter() Adapter

Adapter returns the websocket adapter.

func (*WebsocketContext) ClientID 

func (w *WebsocketContext) ClientID() identifiers.ClientID

ClientID return sthe client identifier.

func (*WebsocketContext) Close 

func (w *WebsocketContext) Close(statusCode websocket.StatusCode, reason string) error

Close invokes the Close method on the underlying connection. It also invokes the onClose handler.

func (*WebsocketContext) Messages 

func (w *WebsocketContext) Messages() <-chan message.Message

Messages returns the parsed messages channel.

func (*WebsocketContext) RoomID 

func (w *WebsocketContext) RoomID() identifiers.RoomID

RoomID returns the room identifier.

Source Files

View all Source files

Directories

Path Synopsis
cli
play
sfu
The SFU package contains the building blocks for building a selective forwarding unit powered by pion/webrtc.
 The SFU package contains the building blocks for building a selective forwarding unit powered by pion/webrtc.
stats

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.