ming_node 3.0.0 → 3.0.1

package/beforeTest/clusterStartTest.js

@@ -0,0 +1,8 @@
+//重启服务器   http://localhost:8091/reload
+require("../utils/nodemon/clusterStart")(
+    __dirname+"/"+ "restartestMain.js",
+    8091,
+    process.env.ENV=="dev" ? "nvm use 15.12":"nvm use 8.12 64",
+    console.log,
+    10000
+)

package/beforeTest/net/TcpClientTest.js

@@ -0,0 +1,10 @@
+const TcpClient= require("../../module/net/TcpClient.js");
+app=new TcpClient("127.0.0.1",8889);
+app.connect()
+
+app.set("data", (req,res)=>{
+    console.log(req)
+    res.send("AAA")
+})
+
+app.send("123")

package/beforeTest/net/TcpServerTest.js

@@ -0,0 +1,16 @@
+const TcpServer=require("../../module/net/TcpServer.js");
+app=new TcpServer()
+app.listen(9999)
+
+app.set("connect",(req,res)=>{
+
+    console.log(req)
+})
+
+app.set("data",(req,res)=>{
+
+    console.log(req.params)
+
+    res.send("123")
+
+})

package/beforeTest/net/UdpClientTest.js

@@ -0,0 +1,10 @@
+const UdpClient= require("../../module/net/UdpClient.js");
+app=new UdpClient("127.0.0.1",8889);
+app.listen(9999)
+
+app.set("message", (req,res)=>{
+    console.log(req.params)
+    res.send("AAA")
+})
+
+app.send("123")

package/beforeTest/net/UdpServerTest.js

@@ -0,0 +1,9 @@
+const UdpServer= require("../../module/net/UdpServer.js");
+app=new UdpServer();
+app.listen(9999)
+
+app.set("message", (req,res)=>{
+    console.log(req.params)
+    res.send("AAA")
+})
+

package/beforeTest/restartest.js

@@ -0,0 +1 @@
+require("../utils/nodemon/restart")("restartestMain.js","restartestMain.js")

package/beforeTest/restartestMain.js

@@ -0,0 +1,7 @@
+M=require("ming_node");
+
+app= M.server()
+app.listen(8090)
+app.get("/a",(req,res)=>{
+    res.send("32224")
+})

package/module/net/TcpClient.js

@@ -0,0 +1,64 @@
+const net = require('net');
+
+class TcpClient {
+    static _EventCallBack={};
+    constructor(remoteIp,remotePort) {
+        this.connected=false;
+        this.remoteIp=remoteIp;
+        this.remotePort=remotePort;
+    }
+    set(url, callback) {
+        TcpClient._EventCallBack[url]=callback;
+    }
+
+    connect(){
+        let that=this;
+        if(that.connected){
+            return
+        }
+        this.client = net.createConnection({
+            port:this.remotePort  ,
+            host:this.remoteIp
+        });
+        this.connected=true;
+        //当套字节与服务端连接成功时触发connect事件
+        this.client.on('connect', () =>{
+            that.connected=true;
+            TcpClient._EventCallBack['connect']? TcpClient._EventCallBack['connect'](): console.log("connect success");
+        });
+        //使用data事件监听服务端响应过来的数据
+        this.client.on('data', (chunk) => {
+            let req={};
+            req.remoteIp=that.remoteIp;
+            req.remotePort=that.remotePort;
+            req.params=chunk;
+            let res={};
+            res.send=function (v){
+                if(Array.isArray(v)){
+                    v=new Buffer(v)
+                }
+                that.client.write(v)
+            }
+            TcpClient._EventCallBack['data'](req,res);
+
+        });
+        this.client.on('error', (err)=>{
+            TcpClient._EventCallBack["error"]?TcpClient._EventCallBack["error"](client): console.error(err);
+        });
+
+
+        this.client.on('close', ()=>{
+            that.connected=false;
+            TcpClient._EventCallBack["error"]?TcpClient._EventCallBack["error"]():console.log("close");
+        });
+    }
+
+    send(buffer){
+        if(this.connected){
+            this.client.write(buffer);
+        }
+    }
+
+}
+
+module.exports = TcpClient;

package/module/net/TcpServer.js

@@ -0,0 +1,108 @@
+const net = require('net');
+const os = require("os");
+class TcpServer {
+    static _EventCallBack={};
+    static socketClientMap={};
+    set(url, callback) {
+        TcpServer._EventCallBack[url]=callback;
+    }
+    constructor() {
+        this.localAddress=this.getIpAddress();
+    }
+    getIpAddress(){
+        /**os.networkInterfaces() 返回一个对象，该对象包含已分配了网络地址的网络接口 */
+        var interfaces = os.networkInterfaces();
+        for (var devName in interfaces) {
+            var iface = interfaces[devName];
+            for (var i = 0; i < iface.length; i++) {
+                var alias = iface[i];
+                if (
+                    alias.family === "IPv4" &&
+                    alias.address !== "127.0.0.1" &&
+                    !alias.internal
+                ) {
+                    return alias.address;
+                }
+            }
+        }
+    }
+
+
+    listen(port){
+        let that=this;
+        this.localPort=port;
+        this.socketServer = net.createServer(function (client) {
+            let endPoint= client.remoteAddress+":"+client.remotePort;
+            TcpServer.socketClientMap[endPoint]=client;
+            let req={};
+            req.remoteIp=client.remoteAddress;
+            req.remotePort=client.remotePort;
+            TcpServer._EventCallBack['connect']? TcpServer._EventCallBack['connect'](req,null): console.log(endPoint+"connected");
+
+            // 接收客户端的数据
+            client.on('data', function (data) {
+                let req={};
+                req.remoteIp=client.remoteAddress;
+                req.remotePort=client.remotePort;
+                req.params=data;
+                let res={};
+                res.send=function (v){
+                    if(Array.isArray(v)){
+                        v=new Buffer(v)
+                    }
+                    client.write(v)
+                }
+                TcpServer._EventCallBack['data'](req,res);
+            });
+
+            // 客户端连接关闭
+            client.on('close', function (err) {
+                delete that.socketClientMap[endPoint];
+                TcpServer._EventCallBack["close"]?TcpServer._EventCallBack["close"](client):"";
+            });
+            // 客户端连接错误
+            client.on('error', function (err) {
+                delete that.socketClientMap[endPoint];
+                TcpServer._EventCallBack["error"]?TcpServer._EventCallBack["error"](client):"";
+            });
+        });
+        this.socketServer.listen(
+            {
+                port: port,
+                host: '0.0.0.0',
+            },
+            function () {
+                //console.log('Tcpserver listen listen on '+that.localPort);
+            }
+        );
+
+        //设置监听时的回调函数
+        this.socketServer.on('listening', function () {
+            const { address, port } =  that.socketServer.address();
+            console.log('Tcpserver listen on '+port);
+        });
+
+        //设置关闭时的回调函数
+        this.socketServer.on('close', function () {
+            console.log('sever closed');
+            that.socketClientMap={};
+        });
+
+        //设置出错时的回调函数
+        this.socketServer.on('error', function () {
+            console.log('sever error');
+            that.socketClientMap={};
+        });
+    }
+
+    send(buffer){
+        let clientEndPointList= Object.keys(this.socketClientMap);
+        for (let i=0;i<clientEndPointList.length;i++){
+            this.socketClientMap[clientEndPointList[i]].write(buffer)
+        }
+
+    }
+
+}
+
+module.exports = TcpServer;

package/module/net/UdpClient.js

@@ -0,0 +1,68 @@
+const dgram = require('dgram');
+class UdpClient {
+    static _EventCallBack={};
+
+    constructor(remoteIp,remotePort) {
+        this.server = dgram.createSocket('udp4');
+        this.remotePort=remotePort ;
+        this.remoteIp=remoteIp;
+        this.port=0;
+        this.install();
+    }
+
+    set(url, callback) {
+        UdpClient._EventCallBack[url]=callback;
+    }
+
+    listen(port){
+        this.port=port;
+        this.server.bind(port);
+
+    }
+    send(v,remoteIp,remotePort) {
+        if(remoteIp){
+            this.remoteIp=remoteIp;
+        }
+        if(remotePort){
+            this.remoteIp=remotePort;
+        }
+        if(Array.isArray(v)){
+            v=new Buffer(v)
+        }
+        this.server.send(v,this.remotePort,this.remoteIp)
+    }
+
+    install(app,server){
+        let that=this;
+        this.server.on('close',()=>{
+            UdpClient._EventCallBack['close']? UdpClient._EventCallBack['close']():console.log('udp close');
+        });
+
+        this.server.on('error',(err)=>{
+            UdpClient._EventCallBack['error']? UdpClient._EventCallBack['error'](): console.log(err);
+        });
+
+        this.server.on('listening',()=>{
+            UdpClient._EventCallBack['listening']? UdpClient._EventCallBack['listening']():  console.log('udp listen on '+that.port);;
+
+        });
+        this.server.on('message',(msg,rinfo)=>{
+            let req={}
+            req.rinfo=rinfo;
+            req.remoteIp=rinfo.address;
+            req.remotePort=rinfo.port;
+            req.params=msg;
+            let res={};
+            res.send=function (v){
+                if(Array.isArray(v)){
+                    v=new Buffer(v)
+                }
+                that.server.send(v,rinfo.port ,rinfo.address)
+            }
+            UdpClient._EventCallBack['message'](req,res)
+        });
+
+    }
+}
+
+module.exports =  UdpClient;

package/module/net/UdpServer.js

@@ -0,0 +1,64 @@
+const dgram = require('dgram');
+class UdpServer {
+    static _EventCallBack={};
+
+    constructor() {
+        this.server = dgram.createSocket('udp4');
+        this.remotePort=0;
+        this.remoteIp=0;
+        this.port=0;
+        this.install();
+    }
+
+    set(url, callback) {
+        UdpServer._EventCallBack[url]=callback;
+    }
+
+    listen(port){
+        this.port=port;
+        this.server.bind(port);
+
+    }
+    send(v,remoteIp,remotePort) {
+        if(remoteIp){
+            this.remoteIp=remoteIp;
+        }
+        if(remotePort){
+            this.remoteIp=remotePort;
+        }
+        if(Array.isArray(v)){
+            v=new Buffer(v)
+        }
+        this.server.send(v,this.remotePort,this.remoteIp)
+    }
+
+    install(app,server){
+        let that=this;
+        this.server.on('close',()=>{
+            UdpServer._EventCallBack['close']? UdpServer._EventCallBack['close']():console.log('udp close');
+        });
+
+        this.server.on('error',(err)=>{
+            UdpServer._EventCallBack['error']? UdpServer._EventCallBack['error'](): console.log(err);
+        });
+
+        this.server.on('listening',()=>{
+            UdpServer._EventCallBack['listening']? UdpServer._EventCallBack['listening']():  console.log('udp listen on '+that.port);;
+
+        });
+        this.server.on('message',(msg,rinfo)=>{
+            that.remoteIp=rinfo.address;
+            that.remotePort=rinfo.port;
+            let req={}
+            req.rinfo=rinfo;
+            req.ip=rinfo.address;
+            req.port=rinfo.port;
+            req.params=msg;
+            let res=that;
+            UdpServer._EventCallBack['message'](req,res)
+        });
+
+    }
+}
+
+module.exports =  UdpServer;

package/package.json

@@ -46,5 +46,5 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "version": "3.0.0"
+  "version": "3.0.1"
 }

package/utils/common/DataConvert.js

@@ -0,0 +1,30 @@
+const DataConvert={};
+
+DataConvert.num2Bytes=(num,length=4)=>{
+    if(length==2){
+        return [(num&(0xFF00))>>8,num&(0x00FF)]
+    }
+    if(length==4){
+        return [(num&(0xFF000000))>>24,(num&(0x00FF0000))>>16,(num&(0x0000FF00))>>8,num&(0x00FF)]
+    }
+}
+
+DataConvert.str2Bytes=(str,length=16)=>{
+    let zeroBuffer=new Buffer(length);
+    let strBuffer=new Buffer(str);
+    for (let i=0;i<16;i++){
+        zeroBuffer[i]=strBuffer[i];
+    }
+    return zeroBuffer;
+}
+
+DataConvert.parseIpToInt=(ip)=> {
+    var buf = ip.split(".")
+    return (parseInt(buf[0]) << 24 |
+        parseInt(buf[1]) << 16 |
+        parseInt(buf[2]) << 8 |
+        parseInt(buf[3]))>>>0;
+}
+
+
+module.exports = DataConvert;

package/utils/nodemon/clusterStart.js

@@ -0,0 +1,72 @@
+const cluster = require('cluster');
+const child_process = require('child_process');
+const http = require('http');
+
+function clusterStart(mainFile,reloadPort,beforeCmd,logFun,logHeatBeat){
+    if (cluster.isMaster) {
+        console.log(`主进程 ${process.pid} 正在运行`);
+        // fork工作进程
+        forkWorkProcess();
+        createReloadServer();
+        cluster.on('exit', work => {
+            console.log(`工作进程 ${work.process.pid} 已退出`);
+        });
+    } else {
+        require(mainFile);
+        console.log(`工作进程 ${process.pid} 已启动`);
+    }
+
+// 创建1个工作进程
+    function forkWorkProcess() {
+        const node_version_cmd=beforeCmd;
+        logFun("===>"+node_version_cmd)
+        child_process.exec(node_version_cmd, (e, stdout) => {
+            logFun(stdout);
+            setTimeout(() => {
+                cluster.fork();
+            }, 2000);
+        });
+    }
+
+    //创建监听重启命令的http服务器
+    function createReloadServer() {
+        http.createServer((req, res) => {
+            if (req.url === '/reload') {
+                if (cluster.isMaster) {
+                    const arr = Object.keys(cluster.workers);
+                    if (arr.length !== 0) {
+                        forkWorkProcess();
+                        setTimeout(() => {
+                            const arr = Object.keys(cluster.workers);
+                            process.kill(cluster.workers[arr[0]].process.pid);
+                        }, 20000);
+                    }
+                }
+                res.end('reloading');
+            } else {
+                res.end('unknow command');
+            }
+        }).listen(reloadPort);
+    }
+
+   // 查看log
+    setInterval(() => {
+        if (cluster.isMaster) {
+            const workerArr = Object.keys(cluster.workers);
+            // 工作进程意外退出时，fork新的工作进程
+            if (workerArr.length === 0) {
+                forkWorkProcess();
+            }
+            logFun(new Date());
+            logFun(workerArr);
+            logFun(`主进程pid：${process.pid}`);
+        } else {
+            logFun(`工作进程pid：${process.pid}`);
+        }
+    }, logHeatBeat);
+
+
+}
+
+
+module.exports =clusterStart;