owt-server 的集群管理者、集群工作站、消息队列(一)

转载请注明:

原始地址: https://www.jianshu.com/p/9f2fb27062cb

原作者:wonder


1、写在前面

owt-server使用node.js开发,涉及node.js c++混合开发。

owt-server的目录结构如下:


root@ubuntu:/home/wonder/OWT/owt-server-master# ls

build  cert  doc  docker  LICENSE  node_modules  README.md  scripts  source  test  third_party

各种环境安装脚本在 scripts/ 下,参考README.md进行编译、安装、运行、测试即可


2、owt-server简要介绍

owt-server是集群式的媒体服务。每种功能模块可以是集群(cluster)的一个工作站(worker),多个worker由中心管理者(manager)管理,管理者有主(master)/备(slave)/候选者(candidate)之分。有些模块可以复用同一个worker。

worker、manager之间通过消息队列进行 任务传递/rpc调用。owt-server使用了node.js中的amqp库模块连接宿主机中运行的rabbitmq,以此作为消息队列的底层实现。


3、clusterManager集群管理者模块概述

查看目录 source/cluster_manager/


root@ubuntu:/home/wonder/OWT/owt-server-master# ls source/cluster_manager/

clusterManager.js  cluster_manager.toml  dist.json  index.js  log4js_configuration.json  matcher.js  package.json  scheduler.js  strategy.js

其中index.js,为该模块的启动入口。**index.js **代码前段是引用必要的库,重点库有:

1)amqp_client (库实现位于source/common/amqp_client.js):主要用是owt-server的 rpc 封装(利用amqp实现RPC角色的封装定义,如rpcClient、rpcServer等),后文会介绍

2)clusterManager(位于source/cluster_manager/clusterManager.js):主要定义了集群管理中心之管理者(manager)、候选者(candidate)自荐竞选、主(master)/备(slave)、同步、保活等方法。


3.1 clusterManager模块详细分解

clusterManager.js定义了主要的4内部函数变量(var ClusterManager、var runAsSlave、var runAsMaster和var runAsCandidate)和一个导出函数变量(exports.run)

下面就是 clusterManager.js,源码没有注释,笔者在走读源码后根据自己的理解添加了注释。涉及到对专业术语有疑问的,如rpc、主\备\候选者(master/slave/candidate)、以及 js 语法,请自行百度。

    推荐两篇介绍消息队列的网址,个人觉得很不错:

        【推荐看这篇,全面且有拓展】:[https://www.jianshu.com/p/a4d92d0d7e19](https://www.jianshu.com/p/a4d92d0d7e19)

          rabbitmq 对于AMQP的介绍:[https://www.rabbitmq.com/tutorials/amqp-concepts.html#message-acknowledge]

var ClusterManager = function (clusterName, selfId, spec) { //集群管理者定义**

     //省略一些定义

    ......

    //   var  ClusterManager  定义了集群管理中心(manager)的内部函数变量和返回值:**

    //    以下为内部函数变量,函数体均省略,请查看源码**

    var createScheduler = function (purpose);    /*创建某一类任务的调度器(Scheduler,记录\管理\执行)*/

    var checkAlive = function ();    /*检查该manager 所管理的工作站 (worker)的存活情况*/

    var workerJoin = function (purpose, worker, info);    /*执行某一类任务的worker加入该manager */

    var workerQuit = function (worker);    /*一个 worker 从该manager 退出该*/

    var keepAlive = function (worker, on_result);    /*一个 worker 向该 manager  申请保活*/

    var reportState = function (worker, state);    /* 该 manager  报告某 worker 的状态*/

    var reportLoad = function (worker, load);    /*该 manager 报告某 woker 的负载*/

    var pickUpTasks = function (worker, tasks);    /*令某 worker 执行某些任务*/

    var layDownTask = function (worker, task);    /*令某 worker 放弃执行某任务*/

    var schedule = function (purpose, task, preference, reserveTime, on_ok, on_error);    /*对某类型(purpose) 的任务 (task) 按照指定配置 (preference,reserveTime) 分配worker*/

    var unschedule = function (worker, task);    /*撤销某 worker 下分配的任务*/

    var getWorkerAttr = function (worker, on_ok, on_error);    /*获取某 worker 的属性*/

    var getWorkers = function (purpose, on_ok);    /*获取某类 workers*/

    var getTasks = function (worker, on_ok);    /*获取某 worker 的任务*/

    var getScheduled = function (purpose, task, on_ok, on_error);    /*获取某类型任务的 worker*/

    //    以下为返回值:

    var that = {name: clusterName,  id: selfId};    /*ClusterManager(...)的返回值that*/

    that.getRuntimeData = function (on_data);    /*收集该 manager 管理的每类Scheduler、每个 worker 、每个 task*/

    that.registerDataUpdate = function (on_updated_data);    /*向该 manager 注册消息同步实例*/

    that.setRuntimeData = function (data);    /*向该 manager 配置 data 中记录的 Scheduler、worker和 task*/

    that.setUpdatedData = function (data);    /*向该 manager 更新信息,data.type∈{"worker_join "," worker_quit"," worker_state"," worker_load","worker_pickup "," worker_laydown"," scheduled"," unscheduled" },data具体数据结构,请查看源码*/

    that.serve = function (monitoringTgt);    /*启用 manager 服务,并注册管理目标*/

     that.rpcAPI = {    /*rpc接口函数,以下函数体均省略,请查看源码。它们与内部函数变量是对应的*/

                join: function (purpose, worker, info, callback) { ...},

                quit: function (worker) { ...},

                keepAlive: function (worker, callback) { ...},

                reportState: function (worker, state) { ...},

                reportLoad: function (worker, load) { ...},

                pickUpTasks: function (worker, tasks) { ...},

               layDownTask: function (worker, task) { ...},

               schedule: function (purpose, task, preference, reserveTime, callback) { ...},

               unschedule: function (worker, task) { ...},

               getWorkerAttr: function (worker, callback) { ...},

                getWorkers: function (purpose, callback) {  ...},

               getTasks: function (worker, callback) {  ...},

                getScheduled: function (purpose, task, callback) { ...}

    }

}

var runAsSlave= function(topicChannel, manager) {    //集群管理者作为 “备份”(salve) 的身份运行**

    //省略一些定义 

    ......

    **//以下为内部函数变量,函数体均省略,请查看源码**

    var requestRuntimeData = function ();     /*向首要集群管理者 (master)  请求运行期间的数据,数据内容参阅上文var ClusterManager 返回值中的 getRuntimeData  函数*/

   var onTopicMessage = function(message);     /*接收到主题消息时的处理函数,message.type∈{ “runtimeData”,“updateData”,“declareMaster” },分别对应着 “收到运行期间的数据”,“收到数据更新”,“收到 master 的角色申明 ” */

    var superviseMaster = function ();    /*监督 master 的定时任务(30ms检查一次),若当前master失联(matster心跳超时大于2次),则该 salve 将进入候选者身份(candidate) 的状态*/

    **//以下为调用 runAsSlave  将执行的函数体**

    topicChannel.subscribe(     //在指定的主题信道下(基于消息队列) 订阅两种主题消息

        ['clusterManager.slave.#', 'clusterManager.*.' + manager.id] ,    //两种主题的关键id

        onTopicMessage ,    //主题消息处理函数

        function () {    //订阅成功后,执行的函数体

            requestRuntimeData();     //向 master 请求运行期间的数据

            superviseMaster();    //监督 master

        }

    )

**}**

**var runAsMaster = function(topicChannel, manager) {**

    //省略一些定义     

    ...... 

     topicChannel.bus.asRpcServer(    //启用远程调用服务

            manager.name,    //master 名称

            manager.rpcAPI,    //master的rpc接口

            function(rpcSvr) {     //rpc服务启用成功后执行的函数体

               topicChannel.bus.asMonitoringTarget(function(monitoringTgt) {     //启用worker监管服务,主要用于在worker远程调用登出master时的消息回传,可类比为消息确认ACK

                        manager.serve(monitoringTgt);     //启用 master 集群管理服务 

                        setInterval( //设置定时器

                                function () {    // 向消息队列的三种主题 发送 “declareMaster ”消息  

                                        topicChannel.publish(    //主题 'clusterManager.slave' 消息

                                            'clusterManager.slave', 

                                            {type: 'declareMaster', data: {id: manager.id, life_time: life_time}}         

                                        ); 

                                        topicChannel.publish(      //主题  'clusterManager.candidate' 消息

                                            'clusterManager.candidate', 

                                            {type: 'declareMaster', data: {id: manager.id, life_time: life_time}}

                                        );                

                                         topicChannel.publish(     //主题   'clusterManager.master' 消息 

                                            'clusterManager.master', 

                                            {type: 'declareMaster', data: {id: manager.id, life_time: life_time}}

                                        );   

                                 },

                                 20     //时间间隔20ms 

                         );

                        var onTopicMessage = function (message);  //消息处理函数

                        topicChannel.subscribe(     //订阅主题消息

                                ['clusterManager.master.#', 'clusterManager.*.' + manager.id],

                                onTopicMessage,    //消息处理函数

                                  function () {     //订阅成功执行的函数体

                                            manager.registerDataUpdate(    //注册通知slave的具体方法

                                                    topicChannel.publish(    //通过消息队列发送主题为 'clusterManager.slave' 的消息

                                                             'clusterManager.slave',

                                                              {type: 'updateData', data: data}  

                                                    )

                                            );

                                    }

                            );

                        },

                        function(reason) { process.exit();}; //asMonitoringTarget 失败

                   },

                    function(reason) {process.exit(); };    //as RPC server 失败

            }

    }

} 

var runAsCandidate = function(topicChannel, manager) {

     //省略一些定义    

     ......  

    var electMaster = function () { ...}     //该候选者决定自身身份:是 master 还是 slave

    var selfRecommend = function () { ...}    //该候选者自荐,每30ms向消息队列发送'clusterManager.candidate'  主题消息“selfRecommend”

      var onTopicMessage = function (message) { ...}    //消息处理函数。初始化后定时160ms决定自身身份;收到“selfRecommend”,若消息中id大于自身id,放弃晋升master;收到“declareMaster”,停止自荐,清除定时,成为slave身份

    topicChannel.subscribe(     //订阅 “clusterManager.candidate.#”主题消息

        ['clusterManager.candidate.#'],

        onTopicMessage,    //消息处理函数

        function () {     

            selfRecommend();      //订阅成功,该参与者开始自荐

        }

    );

} 

exports.run= function (topicChannel, clusterName, id, spec) {

    //该js库的导出函数

    var manager = new ClusterManager(clusterName, id, spec);    //生成一个集群管理者(manager)实例

    runAsCandidate(topicChannel, manager);    //该manager立即作为候选者(candiate)运行

}

思考:主/备方式的好处,在于:一定程度减少了中心式集群管理的风险,即中心管理者宕机造成集群失效的风险。其缺点也是存在的,即调度集中于主管理者,主管理者仅于备管理者进行同步,在调度请求非常频繁时,主管理者性能会成为瓶颈,这也是中心式网络应用的通病。

阅读clusterManager.js文件的总结:

a) 通过源码走读,可以明确管理者(manager)、主(master)/备(slave)/候选者(candidate)的分工以及竞选方式。

b) 这部分仅是对集群管理者(cluster_manager)的定义,对于集群工作站(worker)的定义还没有概念。目前仅知道,master暴露了一下rpc接口供调用。

c) 这部分对rpc的调用是比较高层次的,确实在owt-server的代码中,amqp_client.js文件对node.js中的amqp进行了封装,以amqp为基础实现了底层的消息收发、通知机制。

d) 这部分提到了Scheduler,它是作为某种类型的任务的管理器,供clusterManager.js使用的。它内部实现了task的记录、worker的记录、超时管理、task与worker的关联、task和worker的调度分配细节。对于记录、关联、超时管理等功能,下文不做详细描述,因为相关的接口基本与clusterManager.js 文件中 var ClusterManager 提供的接口一致。

因此,下文将仅对scheduler.js中的任务调度部分做详细分解。

       ( 消息队列重要文件amqp_client.js将在下一篇《owt-server 的集群管理、集群工作站、消息队列(二)》进行分解; 集群工作站(worker)将在《owt-server 的集群管理、集群工作站、消息队列(三)》结合具体应用类型进行分解)

3.2 scheduler模块---任务调度部分详细分解

话不多说,上干货。

首先,放两个scheduler 模块---任务调度部分需要使用的模块。

1) strategy.js

调度策略模块,描述了不同的调度准则:最近使用、最常使用、最少使用、roundRobin(轮询)、随机选取

这里贴两个(最常使用、roundRobin)进行说明


var mostUsed = function () {    

    this.allocate = function (workers, candidates, on_ok, on_error) {    //获取该策略选中的某个 work 在 workers 中的标号,candidates中存放标号

        var most = 0, found = undefined;

        for (var i in candidates) {    //在提前筛选出的候选candidates中搜索,(提前筛选好处是缩小策略算法运算的空间范围)

            var id = candidates[i];

            if (workers[id].load >= most) {    //检查id所对应work的负载,选取最大负载的work的标号

                most = workers[id].load;

                found = id;

            }

        }

        on_ok(found);    //回调选中的标号

    };};


var roundRobin = function () {

    var latest_used = 65536 * 65536;

    this.allocate = function (workers, candidates, on_ok, on_error) {    

        var i = candidates.indexOf(latest_used);    //初始返回-1

        if (i === -1) {

            latest_used = candidates[0];    //初始选第一个候选

        } else {

            latest_used = (i === candidates.length - 1) ? candidates[0] : candidates[i + 1];  //选择下一个candidates[xxx]中存放的标号

        }

        on_ok(latest_used);     //回调选中的标号

    };};

2) matcher.js

条件匹配模块,描述了不同类型work的匹配准则。owt-server提供了多种类型的服务:portal、webrtc、video、audio、analytics、conference、recording、streaming。其中有些服务需要有独特的任务task和工作站worker的匹配准则。

举两个栗子(上干货):


var webrtcMatcher = function () {

    this.match = function (preference, workers, candidates) {    //参数1是配置喜好

        var result = [],

            found_sweet = false;    //找到甜心?!?!?!?!!!,源码作者有点意思的(奸笑~)

        for (var i in candidates) {

            var id = candidates[i];

            var capacity = workers[id].info.capacity;    //每个worker在向master登记时,都会把自身能力带上

            if (is_isp_applicable(capacity.isps, preference.isp)) {    //这个isp是什么作用还不清楚,直译是“运营商”?懂的朋友可以交流一下

                if (is_region_suited(capacity.regions, preference.region)) {    //这个region也不太明确,根据字面直觉上和域控相关

                    if (!found_sweet) {

                        found_sweet = true;

                        result = [id];

                    } else {

                        result.push(id);

                    }

                } else {    //不在region里,并且没有找到甜心,强行指定甜心吗?有点迷

                    if (!found_sweet) {

                        result.push(id);

                    }

                }

            }

        }

        return result;

    };};


var videoMatcher = function () {

    this.match = function (preference, workers, candidates) {

        if (!preference || !preference.video)    

            return candidates;

        var formatContain = function (listA, listB) {    //函数,统计B在A中的数量

            var count = 0;

            listB.forEach((fmtB) => {

                if (listA.indexOf(fmtB) > -1)

                    count++;

            });

            return (count === listB.length);

        };

        var result = candidates.filter(function(cid) {    //筛选结果

            var capacity = workers[cid].info.capacity;

            var encodeOk = false;

            var decodeOk = false;

            if (capacity.video) {    

                encodeOk = formatContain(capacity.video.encode, preference.video.encode);    //判断偏好的视频编码器是否在worker的能力中

                decodeOk = formatContain(capacity.video.decode, preference.video.decode);    //判断偏好的视频解码器是否在worker的能力中

            }

            if (!encodeOk) {    //编码不匹配

                log.warn('No available workers for encoding:', JSON.stringify(preference.video.encode));

            }

            if (!decodeOk) {    //解码不匹配

                log.warn('No available workers for decoding:', JSON.stringify(preference.video.decode));

            }

            return (encodeOk && decodeOk);   //编解码都匹配才行嘛!

        });

        return result;

    };};

终于,

3)scheduler.js

代码不多,就是淦~


exports.Scheduler = function(spec) {

    /*State <- [0 | 1 | 2]*/        //官方注释最为致命,这种魔数是看代码最大的障碍之一,尤其是表示状态的魔数

    /*{WorkerId: {state: State, load: Number, info: info, tasks:[Task]}*/     // Scheduler  中worker表中的属性,以及tasks表属性

    var workers = {};

    /*{Task: {reserve_timer: TimerId,

              reserve_time: Number,

              worker: WorkerId}      }*/

    var tasks = {};

    var matcher = Matcher.create(spec.purpose),     //根据指定的应用类型名称创建对应matcher 

        strategy = Strategy.create(spec.strategy),     //根据指定的策略创建对应matcher 

        schedule_reserve_time = spec.scheduleReserveTime; 

that.schedule = function (task, preference, reserveTime, on_ok, on_error) {    //参数1是需要调度的任务编号,参数2是该任务的偏好配置

        if (tasks[task]) {    //该任务编号在处理记录中

            var newReserveTime = reserveTime && tasks[task].reserve_time < reserveTime ? reserveTime : tasks[task].reserve_time,  //更新保留时长

                worker = tasks[task].worker;    //正在处理该 task 的 worker

            if (workers[worker]) {    // worker还在记录中

                if (isTaskInExecution(task, worker)) {    //该任务正在执行

                    tasks[task].reserve_time = newReserveTime;    //更新任务保留时长

                } else {    //任务没在执行

                    reserveWorkerForTask(task, worker, newReserveTime);    //向worker申请该task执行时长

                }

                return on_ok(worker, workers[worker].info);    //回调指定的 worker 和 它的信息,并返回

            } else {    //如果 worker 没了

                repealTask(task);      //清理该任务记录,准备重新分派

            }

        }

        var candidates = [];

        for (var worker in workers) {

            if (isWorkerAvailable(workers[worker])) {    //衡量worker负载和状态

                candidates.push(worker);    //加入候选

            }

        }

        if (candidates.length < 1) {    

            return on_error('No worker available, all in full load.');

        }

        candidates = matcher.match(preference, workers, candidates);    //matcher它来了,基于任务偏好、matcher类型筛选候选者

        if (candidates.length < 1) {

            return on_error('No worker matches the preference.');

        } else {

            strategy.allocate(workers, candidates, function (worker) {    //strategy它来了,基于strategy 策略选择合适的 worker

                reserveWorkerForTask(task, worker, (reserveTime && reserveTime > 0 ? reserveTime : schedule_reserve_time));    //为该task分配记录

                on_ok(worker, workers[worker].info);    //回调

            }, on_error);

        }

    };

}

总结:scheduler 使用了策略方式,结合strategy 和matcher 模块,将不同配置对应的策略与策略的执行进行解耦,方便扩展,是良好设计模式的体现。


3.3 index.js --- cluster_manager 模块入口

在节3中,提到了该模块下的index.js是入口程序,下面简单介绍一下,以形成模块到进程(程序)的概念。

首先是引用的库


var amqper = require('./amqp_client'));    //amqp封装模块

var logger = require('./logger').logger;    //日志

var log = logger.getLogger('Main');    

var ClusterManager = require('./clusterManager');    //cluster_manager模块

var toml = require('toml');    //配置文件模块

var fs = require('fs');    //文件系统模块

其次,配置文件读取、配置设置


var config;

try {  

config = toml.parse(fs.readFileSync('./cluster_manager.toml'));      //可以读一下配置文件,更加清晰

} catch (e) {

  log.error('Parsing config error on line ' + e.line + ', column ' + e.column + ': ' + e.message);

  process.exit(1);

}

config.manager = config.manager || {};    //manager配置

config.manager.name = config.manager.name || 'owt-cluster';    //manager名字

config.manager.initial_time = config.manager.initial_time || 10 * 1000;    //启动时间

config.manager.check_alive_interval = config.manager.check_alive_interval || 1000;    //manager 检查 worker 失联的时间间隔

config.manager.check_alive_count = config.manager.check_alive_count || 10;    //manager 剔除失联 worker 前的最大检查次数

config.manager.schedule_reserve_time = config.manager.schedule_reserve_time || 60 * 1000;    //调度默认保留时间(仅当调度请求没有该字段时)

config.strategy = config.strategy || {};    //调度策略, 以下为各种应用类型的默认调度策略

config.strategy.general = config.strategy.general || 'round-robin';

config.strategy.portal = config.strategy.portal || 'last-used';

config.strategy.conference = config.strategy.conference || 'last-used';

config.strategy.webrtc = config.strategy.webrtc || 'last-used';

config.strategy.sip = config.strategy.sip || 'round-robin';

config.strategy.streaming = config.strategy.streaming || 'round-robin';

config.strategy.recording = config.strategy.recording || 'randomly-pick';

config.strategy.audio = config.strategy.audio || 'most-used';

config.strategy.video = config.strategy.video || 'least-used';

config.strategy.analytics = config.strategy.analytics || 'least-used';

config.rabbit = config.rabbit || {};    //rabbitmq配置

config.rabbit.host = config.rabbit.host || 'localhost';    //rabbitmq地址

config.rabbit.port = config.rabbit.port || 5672;    //rabbitmq端口

最后,


function startup () {

    var enableService = function () {

        var id = Math.floor(Math.random() * 1000000000);    //生成随机id

        var spec = {initialTime: config.manager.initial_time,

                    checkAlivePeriod: config.manager.check_alive_interval,

                    checkAliveCount: config.manager.check_alive_count,

                    scheduleKeepTime: config.manager.schedule_reserve_time,

                    strategy: config.strategy

                   };

        amqper.asTopicParticipant(config.manager.name + '.management', function(channel) {  //利用amqp封装库加入主题,得到句柄channel

            log.info('Cluster manager up! id:', id);    

            ClusterManager.run(channel, config.manager.name, id, spec);    //使用配置、随机、句柄,启动ClusterManager

        }, function(reason) {

            log.error('Cluster manager initializing failed, reason:', reason);

            process.exit();

        });

    };

    amqper.connect(config.rabbit, function () {    //amqp封装库连接rabbitmq消息队列

        enableService();    //启动上述服务

    }, function(reason) {

        log.error('Cluster manager connect to rabbitMQ server failed, reason:', reason);

        process.exit();

    });

}

startup();    //启动

...    //省略其他系统信号设置


至此,集群管理者模块,即cluster_manager模块以及基本分解完毕。下一步就是需要理清集群工作站,以及二者如何协调工作。此外就是二者所依赖的底层消息队列究竟做了些什么,还有怎么实现的。

image