【流媒体服务器Mediasoup】 NodeJs与C++信令通信详解及Linux下管道通信的详解（五）

目录

 

前言

匿名管道进程间通信

进程间管道 的创建与图解

MediaSoup中的管道创建

MediaSoup Channel的创建

NodeJs和 C++ 管道通信的过程

MediaSoup 消息确认与事件通知

小结

---

前言

上篇文章对MediaSoup源码的调试方法  以及运行时分析、调试、查看核心信息  【流媒体服务器Mediasoup】 源码中重要类基本概念 、上层代码作用详解、底层C++类关系详解(四)，本章节主要对MediaSoup的源码中源码中NodeJs与C++信令通信详解，以及讲解在Linux下管道通信的使用

      在下一篇文章中将继续对MediaSoup的源码进行分析和架构的讲解。
 

匿名管道进程间通信

Linux下常见的进程间通讯方式(IPC)

1：管道:匿名管道，有名管道

     匿名管道需要有关联如父子进程时间的联系

2：Socket:unixsocket,普通的socket

3：共享内存

4：信号 (kill命令)

    管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。

    对管道的具体概念不进行详解，如需可以参考网上资料。

进程间管道 的创建与图解

    

 

        前三个是固定的特殊的管道，标准输入，标准输出，标准错误，最后两个由两个文件描述符引用，一个表示读端，一个表示          写端。  

对于fd[0]=3 或者4来说 既可以读也可以写为全双工通信。fd[0]=4 写入的数据需要 fd[0]=3 来读取，反之fd[0]=3 写入的数据需要fd[0]= 4 来读取 ，这是只有一个进程的情况下创建的socketpair。但fork了子进程后，子进程的fd[0]=3和fd[0]=4 一样指向了 读和写管道，这样很容易造成混乱。

        那么父进程fork子进程后，显然 如果同时写和读会造成混乱，下图改进方案为

                                                   

          父进程发送信息给子进程，则就父写子读，就形成半双工的父进程到子进程的通信

         Mediasoup底层使用的是Unixsocket全双工进程间通讯.那么要想实现全双工， 修改后的方案如下

                                                    

               最后实现的原理：

              父进程关掉3，子进程关闭掉4，父进程用4去接收或者发送管道,子进程用3去接收或者发送管道

     代码实战

       代码中给出了明显的注释，阅读后来看下最后运行的结果

#include 
#include 
#include 
#include  
#include 
const char* str = "SOCKET PAIR TEST.";
int main(int argc, char* argv[]){	
	int    socket_pair[2];
	pid_t  id;
	//创建socketpair
	if(socketpair(AF_UNIX, SOCK_STREAM, 0, socket_pair) == -1){		
		printf("Error, socketpair create failed, errno(%d): %s\n", errno, strerror(errno));
        return EXIT_FAILURE;
	}	
	//创建子进程
	id =fork();	
	if(id == 0){
		//子进程
		char buffer[512]={0, };
		//子进程关闭管道4
		close(socket_pair[1]);
		while(1){
			//发送数据给父进程
			printf("childer send \n");
			write(socket_pair[0], str , strlen(str));
			sleep(1);			
			//接收父进程数据
			ssize_t len = read(socket_pair[0], buffer, sizeof(buffer));
			if(len > 0 ){
				buffer[len] = '\0';
				printf("childer: recv from parent : %s \n",buffer);	
			}
		}		
	}else if(id > 0){
		//父进程
		char buffer[512]={0, };
		//父进程关闭管道3
		close(socket_pair[0]);		
		while(1){
			
			//接收子进程数据
			ssize_t len = read(socket_pair[1], buffer, sizeof(buffer));
			if(len > 0 ){
				buffer[len] = '\0';
				printf("father: recv from childer : %s \n",buffer);				
			}
			sleep(1);
			//发送数据给父进程
			printf("father send \n");
			write(socket_pair[1], str , strlen(str));
		}		
	}else{		
		printf("Error, fork failed, errno(%d): %s\n", errno, strerror(errno));
        return EXIT_FAILURE;
	}	
	return 0;	
}

  root@ubuntu:/work/guo#   g++ hello.cpp -o hello  //编译

  root@ubuntu:/work/guo#   ./hello                          //运行

 

 最后运行结果查看:

       从结果中可以看到父进程发子进程收，子进程发父进程收，这样就达到了父子进程的通讯效果。

       在MediaSoup中在NodeJs层  根据CPU核心数量 用spawn 创建了这么多数量的创建了Woker(子进程)，那么NodeJs层和C++层的子进程这个是通过这种管道通信方式进行信令的传输。

                                    

MediaSoup中的管道创建

管道在源码中 哪里创建，怎么创建？

        前面了解那么多我们知道Worker 在底层实际上是一个进程或者说子进程，那么管道是用来进程间通讯的，可以猜测到创建

管道的地方在和woker有关的类中，那么根据源码一层层剖析下去。

 首先定位  mediasoup-demo/server/server.js

/**
 * Launch as many mediasoup Workers as given in the configuration file.
 */
async function runMediasoupWorkers()
{
	const { numWorkers } = config.mediasoup;

	logger.info('running %d mediasoup Workers...', numWorkers);

	for (let i = 0; i < numWorkers; ++i)
	{     //服务启动后开始创建worker
		const worker = await mediasoup.createWorker(
			{
				logLevel   : config.mediasoup.workerSettings.logLevel,
				logTags    : config.mediasoup.workerSettings.logTags,
				rtcMinPort : Number(config.mediasoup.workerSettings.rtcMinPort),
				rtcMaxPort : Number(config.mediasoup.workerSettings.rtcMaxPort)
			});

        ....省略
    }
  }

 const worker = await mediasoup.createWorker   最后实际调用到MediaSoup库中的Woker.js

 继续定位到 mediasoup-demo\server\node_modules\mediasoup\lib\Worker.js

class Worker extends EnhancedEventEmitter_1.EnhancedEventEmitter {
    /**
     * @private
     * @emits died - (error: Error)
     * @emits @success
     * @emits @failure - (error: Error)
     */
    constructor({ logLevel, logTags, rtcMinPort, rtcMaxPort, dtlsCertificateFile, dtlsPrivateKeyFile, appData }) {
        super();
        ...省略
        //启动核心文件 实际上新建woker即线程
        this._child = child_process_1.spawn(
        // command
        spawnBin, 
        // args
        spawnArgs,   
        // options
        {
            env: {
                MEDIASOUP_VERSION: '3.4.11'
            },
            detached: false,
            // fd 0 (stdin)   : Just ignore it.
            // fd 1 (stdout)  : Pipe it for 3rd libraries that log their own stuff.
            // fd 2 (stderr)  : Same as stdout.
            // fd 3 (channel) : Producer Channel fd.
            // fd 4 (channel) : Consumer Channel fd.
            stdio: ['ignore', 'pipe', 'pipe', 'pipe', 'pipe']
        });
        this._pid = this._child.pid;
        // 创建的管道交给channel处理
        this._channel = new Channel_1.Channel({
            producerSocket: this._child.stdio[3],
            consumerSocket: this._child.stdio[4],
            pid: this._pid
        });
        this._appData = appData;
        let spawnDone = false;
        // Listen for 'ready' notification.
        this._channel.once(String(this._pid), (event) => {
             ...省略
        });
        this._child.on('exit', (code, signal) => {
            ...省略
        });
        this._child.on('error', (error) => {
            ...省略
        });
        // Be ready for 3rd party worker libraries logging to stdout.
        this._child.stdout.on('data', (buffer) => {
            ...省略
        });
        // In case of a worker bug, mediasoup will log to stderr.
        this._child.stderr.on('data', (buffer) => {
            ...省略
        });
    }

首先对node child_process模块 spawn 的使用不了解的话可以搜索网上的资料，这里简单的介绍下 

  child_process 模块Api :  https://nodejs.org/api/child_process.html

//spawn 实际上是执行Linux系统下的命令 

const ls = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', (data) => { console.log(`输出：${data}`); });

ls.stderr.on('data', (data) => { console.log(`错误：${data}`); });

ls.on('close', (code) => { console.log(`子进程退出码：${code}`); });

最后实际执行的结果会回调在 stdout这个文件描述符  data的内容就是/usr 下的所有目录和文件打印。

• spawn ： 子进程中执行的是非node程序，提供一组参数后，执行的结果以流的形式返回。

默认情况下，Node.js 的父进程与衍生的子进程之间会建立 stdin、stdout 和 stderr 的管道 

在源码使用spawn中，来详解一些参数，其中

    command  为 spawnBin 实际上是一个MediaSoup编译完的一个可执行库的路径

           args 是一些执行时的参数，主要是一些 config.js中mediasoup节点下的值拼接成字符串作为参数 来启动核心文件。

    option 可以有很多选项，这边只列举了上述代码中使用到的,具体参数意义如下图所示

 child_process.spawn(command[, args][, options])

• command  The command to run.       //要运行的命令
• args  List of string arguments.     //字符串参数列表

• options