protoo.WebSocket

protoo.WebSocket
protoo消息
- protoo request
- protoo response
- protoo notification
protoo-server
- API
- - WebSocketServer
  - WebSocketTransport
  - Room(房间)
  - Peer
protoo-client
- API
- - WebSocketTransport
  - Peer
demo
- server
- client

protoo.WebSocket

protoo-server
protoo-client
官方文档
protoo是用于多方实时通信应用程序的极简且可扩展的 Node.js 信号框架。它提供了服务器端 Node.js 模块和客户端 Javascript 库。其主要目的是为应用程序提供轻松添加群聊、在线状态和多方多媒体功能的能力。
与protoo.WebSocket 一样有着房间管理的有 Socket.IO

protoo消息

protoo定义了基于JSON请求、响应和通知的信令协议。由应用程序来定义和扩展信令协议和这些消息的内容，以实现所需的功能集。

protoo request

    {
      request : true,//必须为true
      id : 12345678,//关联response的数字标识符
      method: 'chatmessage',//请求方法的自定义字符串
      data:{
        type  : 'text',
        value : 'Hi there!'
      }//自定义数据的对象
    }

protoo response

    {
      response : true,//必须是true
      id       : 12345678,//关联request的数字标识符
      ok       : true,//true:成功响应，false:失败
      data     :{
        foo : 'lalala'
      }//自定义数据的对象
    }
    {
      response    : true,//必须是true
      id          : 12345678,//关联request的数字标识符
      ok          : false,//true:成功响应，false:失败
      errorCode   : 123,//数字错误代码
      errorReason : 'Something failed'//描述性错误文本
    }

protoo notification

    {
      notification : true,//必须是true
      method       : 'chatmessage',//通知方法的自定义字符串
      data         :{
        foo : 'bar'
      }//自定义数据的对象
    }

protoo-server

安装：npm install --save protoo-server
const protooServer = require('protoo-server');

API

version（String）
WebSocketServer（class）
WebSocketTransport（class）
Room（class）
Peer（class）

WebSocketServer

侦听来自客户端的 WebSocket 连接

创建

    const options ={
      maxReceivedframeSize     : 960000, // 960 KBytes.允许的最大接收帧大小（以字节为单位）。单帧消息也将限于此最大值。
      maxReceivedMessageSize   : 960000,//允许的最大消息大小（对于分段消息），以字节为单位。
      fragmentOutgoingMessages : true,//是否对传出消息进行分段。如果为true，则邮件将自动分成最大为fragmentationThreshold字节的块
      fragmentationThreshold   : 960000//在自动分段之前，帧的最大大小（以字节为单位）。
    };
    
    const server = new protooServer.WebSocketServer(httpServer, options);

方法：

stop()//卸载WebSocket服务器
on(‘connectionrequest’, fn(info, accept, reject))//当WebSocket客户端尝试连接到WebSocket服务器时触发的事件

    
    server.on('connectionrequest', (info, accept, reject) =>{
      if (something in info){
        const transport = accept();
        const peer = room.createPeer('bob', transport);
      }else{
        reject(403, 'Not Allowed');
      }
    });

WebSocketTransport

代表与客户端建立的WebSocket连接
WebSocketServer的connectionrequest事件accept()方法返回值
没有公开的API

Room(房间)

多方通信上下文
创建一个新的Room对象

const room = new protooServer.Room();

属性：

peers房间中所有人

    for (let peer of room.peers){
      console.log('peer id: %s', peer.id);
    }

closed房间是否关闭的布尔值
```
    room.closed;
```

方法：
- createPeer(peerId, transport);//在这个房间内创建一个Peer
```
    
    const peer = room.createPeer('alice', transport);
```
- hasPeer(peerId)//检测房间中是否有该peer
- getPeer(peerId)//返回给定的Peer，没有返回undefined
- close();//关闭房间并发出close事件,所有peer也会关闭
- on('close', fn());//房间关闭时触发的事件

Peer

表示连接到Room的远程客户端
属性：
- id：唯一标识
- data：自定义对象
- closed：是否已关闭

方法：

async request(method, [data]);//peer给客户端发送protoo request

    
    try{
      const data = await peer.request('chicken', { foo: 'bar' });
      console.log('got response data:', data);
    }catch (error){
      console.error('request failed:', error);
    }

async notify(method, [data]);//peer给客户端发送protoo notification

    
    peer.notify('lalala', { foo: 'bar' });

close();关闭peer及其底层的transport，并触发close事件
on('request', fn(request, accept, reject));//peer收到客户端protoo request时触发的事件

    
    peer.on('request', (request, accept, reject) =>{
      if (something in request)
        accept({ foo: 'bar' });
      else
        reject(400, 'Not Here');
    });

on('notification', fn(notification));//peer收到客户端protoo notification时触发的事件

    
    peer.on('notification', (notification) =>{
      // Do something.
    });

on('close', fn());//当peer通过调用close()时，或者当底层transport远程关闭时，或者当Room.close()时触发的事件。

protoo-client

安装：npm install --save protoo-client
const protooClient = require('protoo-client');

API

version（String）
WebSocketTransport（class）
Peer（class）

WebSocketTransport

创建

    
        const transport = new protooClient.WebSocketTransport('wss://example.org');

Peer

代表远程Room的参与者

创建

    
    const peer = new protooClient.Peer(transport);

属性：
- data:自定义对象
- closed:是否关闭
- connected:是否连接
方法：
- async request(method, [data]);//peer给服务端发送protoo request
```
    
    try{
      const data = await peer.request('chicken', { foo: 'bar' });
      console.log('got response data:', data);
    }catch (error){
      console.error('request failed:', error);
    }
```
- async notify(method, [data]);//peer给服务端发送protoo notification
```
    
    peer.notify('lalala', { foo: 'bar' });
```
- close();//关闭peer及其底层的transport，并触发close事件
- on('open', fn());//连接transport成功时触发的事件
- on('failed', fn(currentAttempt));//与服务器的连接失败时触发的事件（由于网络错误、服务器未运行、服务器地址不可达等）
  - peer将尝试按照其retry选项中定义的次数进行连接。在这些重试之后，close事件将被触发。
  - currentAttempt://当前第几次重连
- on('disconnected', fn());
  - 已建立的连接突然关闭时触发的事件。peer将启动其retry选项中定义的重新连接过程。
  - peer将尝试按照其retry选项中定义的次数进行连接。在这些重试之后，close事件将被触发。
  - 如果close()是在服务器端中触发，服务器端peer或此客户端中的peer，则不会进行任何重新连接尝试。
- on('close', fn());//当peer通过调用close()时，或者当底层transport远程关闭时，或者当服务端Room.close()时触发的事件。
- on('request', fn(request, accept, reject));//peer收到服务端protoo request时触发的事件
```
    
    peer.on('request', (request, accept, reject) =>{
      if (something in request)
        accept({ foo: 'bar' });
      else
        reject(400, 'Not Here');
    });
```
  - on('notification', fn(notification));//peer收到服务端protoo notification时触发的事件
```
    
    peer.on('notification', (notification) =>{
      // Do something.
    });
```

demo server

const http = require('http');
const protooServer = require('protoo-server');
// 创建本地服务器来从其接收数据
const httpServer = http.createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
        data: 'Hello World!'
    }));
});
httpServer.listen(8000);
const options ={
    maxReceivedframeSize     : 960000, // 960 KBytes.允许的最大接收帧大小（以字节为单位）。单帧消息也将限于此最大值。
    maxReceivedMessageSize   : 960000,//允许的最大消息大小（对于分段消息），以字节为单位。
    fragmentOutgoingMessages : true,//是否对传出消息进行分段。如果为true，则邮件将自动分成最大为fragmentationThreshold字节的块
    fragmentationThreshold   : 960000//在自动分段之前，帧的最大大小（以字节为单位）。
};
const server = new protooServer.WebSocketServer(httpServer, options);
const room = new protooServer.Room();
room.on('close', ()=>{
    console.log("close room")
});
server.on('connectionrequest', (info, accept, reject) =>{
    console.log(info.request.url)
    if (info){
        const transport = accept();//返回WebSocketTransport
        const peer = room.createPeer('bob', transport);//在这个房间内创建一个Peer
        peer.on('close', ()=>{
            console.log("close连接peer")
        });
        peer.on('request', (request, accept, reject) =>{
            console.log(request)
            if (request)
                accept({ foo: '我是服务端返回peer' });
            else
                reject(400, 'Not Here');
        });
        peer.on('notification', (notification) =>{
            console.log(notification)
        });
        // console.log(room)
    }else{
        reject(403, 'Not Allowed');
    }
});

client

const protooClient = require('protoo-client');
const transport = new protooClient.WebSocketTransport('ws://localhost:8000?xxx=1&yyy=2');
const peer = new protooClient.Peer(transport);
peer.on('open', ()=>{
    console.log("open连接成功")
    sendRequest();
});
peer.on('failed', (currentAttempt)=>{
    console.log("failed连接失败"+currentAttempt)
});
peer.on('disconnected', ()=>{
    console.log("disconnected断开连接")
});
peer.on('close', ()=>{
    console.log("close连接")
});
peer.on('request', (request, accept, reject) =>{
    console.log(request)
    if (request)
        accept({ foo: 'bar' });
    else
        reject(400, 'Not Here');
});
peer.on('notification', (notification) =>{
    console.log(notification)
});

async function sendRequest() {
    try {
        const data = await peer.request('sendRequest', {XXXX: 'XXXX'});//有响应值
        console.log('got response data:', data);
    } catch (error) {
        console.error('request failed:', error);
    }
}
async function sendNotification() {
    peer.notify('notifyXXX', {XXXX: 'XXXX'});//无响应值
}

protoo.WebSocket

Linux相关栏目本月热门文章