目录
MediaSoup中的 protoo.websocket 建立连接流程
前言
上篇文章对【流媒体服务器Mediasoup】 NodeJs与C++信令通信详解及Linux下管道通信的详解（五），本章节主要对MediaSoup的客户端与服务端 源码中源码中 信令通讯使用的protoo.WebSocket 详解，以及整个信令的处理过程
在下一篇文章中将继续对MediaSoup的源码进行分析和架构的讲解。
介绍protoo.WebSocket
protoo是一个面向多方实时通信应用的最小可扩展Node.js信令框架。
它提供了一个服务器端Node.js模块和一个客户端JavaScript库。其主要目的是为应用程序提供轻松添加群聊、状态和多方多媒体功能的能力。与protoo.WebSocket 一样有着房间管理的有 Socket.IO
Messages protoo消息体介绍
(消息体)
protoo定义了一个基于JSON请求、响应和通知的信令协议。由应用程序定义和扩展信令协议以及这些消息的内容，以实现所需的特性集。
Request （请求格式）
{
request : true,
id : 12345678,
method : 'chatmessage',
data :
{
type : 'text',
value : 'Hi there!'
}
}
Response（响应体）
Success response 成功响应体
{
response : true,
id : 12345678,
ok : true,
data :
{
foo : 'lalala'
}
}
Error response 失败响应体
Notification（通知）
需要进行响应，主动发数据给服务端
{
notification : true,
method : 'chatmessage',
data :
{
foo : 'bar'
}
}
protoo-server 介绍
//nodeJs安装服务端库
npm install --save protoo-server
//代码中引用
const protooServer = require('protoo-server');
WebSocketServer
const options =
{
//允许的最大接收帧大小（以字节为单位）。单帧消息也将限于此最大值。
maxReceivedFrameSize : 960000, // 960 KBytes.
//允许的最大消息大小（对于分段消息），以字节为单位。
maxReceivedMessageSize : 960000,
//是否对传出消息进行分段。如果为true，则邮件将自动分成最大为fragmentationThreshold字节的块
fragmentOutgoingMessages : true,
//在自动分段之前，帧的最大大小（以字节为单位）。
fragmentationThreshold : 960000
};
const server = new protooServer.WebSocketServer.Room(httpServer, options);
当WebSocket客户端尝试连接到WebSocket服务器时触发事件。
server.on('connectionrequest', (info, accept, reject) =>
{
// info 是属于一个连链接的所有信息，可以根据info获取如一些url或者其他信息来判断处理相对应的业务逻辑
if (something in info)
{
const transport = accept();
// 创建一个房间和房间用户
const peer = async room.createPeer('bob', transport);
}
else
{
reject(403, 'Not Allowed');
}
});
函数接收的参数:
| 参数 | 描述 |
|---|---|
| info | 具有有关连接尝试信息的对象。 |
| accept | 如果接受连接将调用的函数。 |
| reject | 如果拒绝连接，则调用该函数。 |
info 是属于一个连链接的所有信息，可以根据info获取如一些url或者其他信息来判断处理相对应的业务逻辑
info 对象象具有以下字段：
| 领域 | 描述 |
|---|---|
| request | 代表在Websocket握手期间收到的HTTP请求的Node.js 连接对象的信息。 |
| origin | HTTP请求中基础机地址的值 |
| socket | Node.js net.Socket 对象。 |
WebSocketTransport
accept()在的connectionrequest事件内调用时创建WebSocketServer。它代表与客户端建立的WebSocket连接。如：
server.on('connectionrequest', (info, accept, reject) =>
{
//建立和远程客户端的连接
const protooWebSocketTransport = accept();
});
Room(房间)
创建一个新的房间
const room = new protooServer.Room();
返回房间里 多有的Peer（成员）
for (let peer of room.peers)
{
console.log('peer id: %s', peer.id);
}
//------------------------
if(room.closed){
//房间关闭了
}else{
//房间没有关闭了
}
在此房间内创建用户。它解析为用户实例。如果给出了错误的参数，或者房间中已经有一个具有相同ID的用户，则它会拒绝。
close关闭房间并发出关闭事件。这个房间内的所有人也将被关闭，他们的关闭事件将被触发。
const peer = await room.createPeer('alice', transport);
//hasPeer如果存在会返回PeerId
if(room.hasPeer(peerId)){
//房间内有这个人
}else{
// 房间内没有这个人
}
//返回房间的为pereID的用户对象
const user= room.getPeer(peerId);
//关闭房间时触发的回调函数
room.on('close', () =>
{
//DO SOMETINGS
}
);
//关闭房间
room.close();
Peer(房间成员)
代表远端的一个连接实例，其实也可以理解成一个成员用户。
perr对象中主要有2个字段
id 唯一标识
data 可自定义数据
发送信令数据给 指定的peer客户端
//请求信令
try
{
const data = await peer.request('chicken', { foo: 'bar' });
console.log('got response data:', data);
}
catch (error)
{
console.error('request failed:', error);
}
//服务端主动下发 通知的信令
peer.notify('lalala', { foo: 'bar' });
接收来自peer客户端的信令消息
peer.on('request', (request, accept, reject) =>
{
if (根据 request 的一些信息做一些判断)
accept({ foo: 'bar' });
else
reject(400, 'Not Here');
});
//关闭对等方及其底层传输，并发出关闭事件。
peer.close();
| 参数 | 描述 |
|---|---|
| 请求 | 一个protoo请求。 |
| 接受 | 如果接受请求，则调用该函数。 |
| 拒绝 | 如果拒绝请求，则调用该函数。 |
accept函数具有以下参数：
| Parameter | Default | Description |
|---|---|---|
| [data] | {} |
响应的数据体 |
rejuct函数具有以下参数：
| Parameter | Default | Description |
|---|---|---|
| errorCode | 错误码 | |
| [errorReason] | 错误原因 |
or:
| Parameter | Default | Description |
|---|---|---|
| error | 错误的对象实例 |
收到通知时 以及 关闭时
通过对对等方调用close（）关闭peer、远程关闭基础传输或关闭时时激发的事件。
//接收到服务端通知
peer.on('notification', (notification) =>
{
// Do something.
});
//客户端关闭时触发
peer.on('close', fn())
protoo-client 介绍
//安装依赖库
npm install --save protoo-client
//nodejs使用库
const protooServer = require('protoo-server');
WebSocketTransport
WebSocketTransport创建WebSocket连接。
const transport = new protooClient.WebSocketTransport('wss://example.org');
| Parameter | Description |
|---|---|
| url | WebSocket 连接的地址 |
| [options] | 包括websocket.W3CWebSocket的选项（除了requestUrl之外的所有选项）和一个retry参数 |
retry参数与给retry.operation（）的options对象匹配，并控制连接和重新连接尝试，如果options.retry未给出，则默认为以下值
{
forever : true //是否一直重连，默认为false。
retries : 10, //重试连接该操作的最大时间。默认值为10
factor : 2, //重练的的次数
minTimeout : 1 * 1000, //开始第一次连接之前的毫秒数。默认值为1000
maxTimeout : 8 * 1000 //两次重连之间的最大毫秒数。默认值为Infinity。
};
Peer(房间的参与者，客户端用户)
创建本地peer
const peer = new protooClient.Peer(transport);
| 参数 | 描述 |
|---|---|
| transport | 一个WebSocketTransport实例。 |
Peer对象中有data参数 ，可写的自定义对象，直到应用程序为止。
peer.data.bar = 1234;
console.log(peer.data.bar);
在客户端中 Peer的 close、notify、request 函数等 和服务端的一样，这里不做过多讲解
peer.connected 字段标识对 客户端是否已连接到服务端。
连接传输时激发的事件
on('open', fn())
与服务器的连接失败时激发的事件（由于网络错误、未运行服务器、无法访问服务器地址等）。
客户端将尝试连接其重试选项中定义的次数。重试之后，关闭事件将触发。
on('failed', fn(currentAttempt))
| 参数 | 描述 |
|---|---|
| currentAttempt | 重新连接尝试（从1开始）。 |
当已建立的连接突然关闭时激发的事件。peer将启动在其重试选项中定义的重新连接过程。
peer将尝试重新连接其重试选项中定义的次数。重试之后，关闭事件将触发
on('disconnected', fn())
如果
close()是在服务器端中触发，服务器端peer或此客户端中的peer，则不会进行任何重新连接尝试。
MediaSoup中的 protoo.websocket 建立连接流程
下面将简单介绍源码中使用到的创建连接、创建房间。创建peer的地方
WebSocket的连接
文件定位： mediasoup-demo/server/server.js
runProtooWebSocketServer() 方法中主要对protoo socket的初始化，具体看源码
方法中体现了创建socket server的实例，并监听客户端来的连接
/** 创建ProtooWebSocket地服务*/
async function runProtooWebSocketServer()
{
// 创建实例 option参数参见上面的讲解
protooWebSocketServer = new protoo.WebSocketServer(httpsServer,
{
maxReceivedFrameSize : 960000, // 960 KBytes.
maxReceivedMessageSize : 960000,
fragmentOutgoingMessages : true,
fragmentationThreshold : 960000
});
// 监听客户端连接
protooWebSocketServer.on('connectionrequest', (info, accept, reject) =>
{
...省略部分代码
//这里使用了一个同步队列，为了防止同一时刻创建相同的房间
queue.push(async () =>
{
const room = await getOrCreateRoom({ roomId, forceH264, forceVP9 });
// 确定客户端的请求，并生成一个连接Transport
const protooWebSocketTransport = accept();
room.handleProtooConnection({ peerId, protooWebSocketTransport });
})
.catch((error) =>
{
logger.error('room creation or room joining failed:%o', error);
reject(error);
});
});
}
room的创建
文件定位： mediasoup-demo/server/lib/Room.js
在上述的 runProtooWebSocketServer() 方法中，调用 const room = await getOrCreateRoom({ roomId, forceH264, forceVP9 });
最后再getOrCreateRoom中调用了Room类中的create 方法具体看下部分源码，
当一个客户端连接首先会查看房间是否已经创建，如果没有创建那么就调用create 方法最后实例化了一个房间。
static async create({ mediasoupWorker, roomId, forceH264 = false, forceVP9 = false })
{
// 创建 protoo room 实例
const protooRoom = new protoo.Room();
....省略部分代码
//并实例化一个封装的Room
return new Room(
{
roomId,
protooRoom,
mediasoupRouter,
audioLevelObserver,
bot
});
}
Peer（成员）的创建
文件定位： mediasoup-demo/server/lib/Room.js
在上述的 runProtooWebSocketServer() 方法中，监听事件
protooWebSocketServer.on('connectionrequest', (info, accept, reject) => {}
方法中，当有一个客户端连接，先去判断房间是否存在，如果不存在则创建，走上面讲述的创建房间流程，
这时候客户端连接相当于一个成员加入，当房间创建好的时候，需要在房间中添加这个连接进来的成员
最后调到 room.handleProtooConnection({ peerId, protooWebSocketTransport }); 具体源码：
从源码以及源码注释中可以看出整个清晰的逻辑
handleProtooConnection({ peerId, consume, protooWebSocketTransport })
{
//查看房间是否存在这个用户
const existingPeer = this._protooRoom.getPeer(peerId);
//如果存在则关闭此用户
if (existingPeer)
{
existingPeer.close();
}
let peer;
// 在此房间创建一个peer 成员
try
{
peer = this._protooRoom.createPeer(peerId, protooWebSocketTransport);
}
catch (error)
{
....省略部分代码
peer.on('request', (request, accept, reject) =>
{
//接收信令数据
this._handleProtooRequest(peer, request, accept, reject)
.catch((error) =>
{
logger.error('request failed:%o', error);
reject(error);
});
});
peer.on('close', () =>
{
// 通知其他用户 此用户已经退出
if (peer.data.joined)
{
for (const otherPeer of this._getJoinedPeers({ excludePeer: peer }))
{
otherPeer.notify('peerClosed', { peerId: peer.id })
.catch(() => {});
}
}
// 遍历关闭用户所有的数据连接通道
for (const transport of peer.data.transports.values())
{
transport.close();
}
// 退出去为房间最后一个人，则关闭此房间
if (this._protooRoom.peers.length === 0)
{
this.close();
}
});
}
信令的接收与处理
文件定位： mediasoup-demo/server/lib/Room.js
async _handleProtooRequest(peer, request, accept, reject)
源码中的信令不多，也可以自己添加自定义的信令
针对目前demo，一个用户进入房间，信令的执行顺序为：
/* 信令执行的顺序
getRouterRtpCapabilities
createWebRtcTransport （收 传输通道）
createWebRtcTransport （发 传输通道）
join
connectWebRtcTransport
connectWebRtcTransport
produce
produceData
produceData
*/
async _handleProtooRequest(peer, request, accept, reject)
{
switch (request.method)
{
...省略处理信令过程
}
}
小结
上述主要对protoo socket的一些Api进行简单的讲解，熟悉Api带入源码去分析显得更容易一些，protoo对node的支持是相当的好，在源码中的整个执行顺序也是比较明朗，对于定制源码也起到了关键的作用。
在往后的博文中，将对信令的处理从上层到C++ 进行一些系统的分析，包括整个流程的走向，调试等。