[[347927]]

本文轉(zhuǎn)載自微信公眾號(hào)「編程雜技」，作者theanarkh。轉(zhuǎn)載本文請(qǐng)聯(lián)系編程雜技公眾號(hào)。    

對(duì)于有繼承關(guān)系的進(jìn)程，nodejs本身為我們提供了進(jìn)程間通信的方式，但是對(duì)于沒有繼承關(guān)系的進(jìn)程，比如兄弟進(jìn)程，想要通信最簡單的方式就是通過主進(jìn)程中轉(zhuǎn)，類似前端框架中子組件通過更新父組件的數(shù)據(jù)，然后父通知其他子組件。因?yàn)閚odejs的進(jìn)程間通信需要經(jīng)過序列化和反序列化，所以這種方式可能會(huì)帶來一定的性能損耗，而且在實(shí)現(xiàn)上也比較麻煩。今天介紹的是兄弟進(jìn)程直接通信的方式。在windows上使用tcp，在非windows上使用unix域，本機(jī)通信，unix域性能上會(huì)更好，因?yàn)閠cp通信需要經(jīng)過協(xié)議棧的封包和解包。下面具體介紹一下這個(gè)ipc庫的設(shè)計(jì)和實(shí)現(xiàn)。

設(shè)計(jì)思想主要是一個(gè)進(jìn)程啟動(dòng)一個(gè)服務(wù)，然后其他客戶端進(jìn)程可以通過地址信息去和服務(wù)器建立長連接。這里沒有使用短連接，短連接雖然在實(shí)現(xiàn)上會(huì)變得容易，但是頻繁通信的進(jìn)程，不斷地創(chuàng)建和銷毀數(shù)據(jù)結(jié)構(gòu)會(huì)帶來一定的開銷，長連接雖然會(huì)一直占用內(nèi)存，但是這是非常小的，而長連接帶來的效率明顯會(huì)更好。不過長連接會(huì)帶來一個(gè)難點(diǎn)，那就是對(duì)數(shù)據(jù)的解析，比如對(duì)于tcp來說，我們從中拿到的是一串字節(jié)流，這一串字節(jié)流中可能有幾個(gè)數(shù)據(jù)包的數(shù)據(jù)，我們需要從這一串字節(jié)流中解析出一個(gè)個(gè)數(shù)據(jù)包。這就涉及到協(xié)議的設(shè)計(jì)。所以首先我們要定義一個(gè)應(yīng)用層協(xié)議。

1 應(yīng)用層協(xié)議的設(shè)計(jì)和實(shí)現(xiàn)

null應(yīng)用層協(xié)議的設(shè)計(jì)非常簡單

1. 總長度是除了開頭標(biāo)記之外的其他數(shù)據(jù)長度。因?yàn)閿?shù)據(jù)部分是變長的，所以我們需要一個(gè)總長度來判斷后續(xù)的數(shù)據(jù)長度是多少。
2. 序列號(hào)是用于關(guān)聯(lián)請(qǐng)求和響應(yīng)，因?yàn)槲覀冊(cè)谝粋€(gè)連接上可能會(huì)串行發(fā)送多個(gè)數(shù)據(jù)包，當(dāng)我們收到一個(gè)回包的時(shí)候，我們不知道是來自哪個(gè)請(qǐng)求的響應(yīng)，通過響應(yīng)體中的seq，我們就知道是來自哪個(gè)請(qǐng)求的響應(yīng)。設(shè)計(jì)了通信協(xié)議后，我們就需要對(duì)協(xié)議進(jìn)行封包解包。首先我們看一下封包邏輯。

function seq() { 
   return ~~(Math.random() * Math.pow(2, 31)) 
} 
function packet(data, sequnce) { 
    // 轉(zhuǎn)成buffer 
    const bufferData = Buffer.from(data, 'utf-8'); 
    // 開始標(biāo)記長度 
    const startFlagLength = Buffer.from([PACKET_START]).byteLength; 
    // 序列號(hào) 
    const seq = sequnce || seq(); 
    // 分配一個(gè)buffer存儲(chǔ)數(shù)據(jù) 
    let buffer = Buffer.allocUnsafe(startFlagLength + TOTAL_LENGTH + SEQ_LEN); 
    // 設(shè)計(jì)開始標(biāo)記 
    buffer[0] = 0x3; 
    // 寫入總長度字段的值 
    buffer.writeUIntBE(TOTAL_LENGTH + SEQ_LEN + bufferData.byteLength, 1, TOTAL_LENGTH); 
    // 寫入序列號(hào)的值 
    buffer.writeUIntBE(seq, startFlagLength + TOTAL_LENGTH, SEQ_LEN); 
    // 把協(xié)議元數(shù)據(jù)和數(shù)據(jù)組裝到一起 
    buffer = Buffer.concat([buffer, bufferData], buffer.byteLength + bufferData.byteLength); 
    return buffer; 
} 

接著我們看一下解包的邏輯，因?yàn)閿?shù)據(jù)的傳輸是字節(jié)流，所以有可能多個(gè)數(shù)據(jù)包的數(shù)據(jù)會(huì)粘在一起，所以我們第一步首先要根據(jù)協(xié)議解析出一個(gè)個(gè)數(shù)據(jù)包，然后再解析每一個(gè)數(shù)據(jù)包。我們通過有限狀態(tài)機(jī)實(shí)現(xiàn)數(shù)據(jù)的解析。下面是狀態(tài)機(jī)的狀態(tài)集。

const PARSE_STATE = { 
  PARSE_INIT: 0, 
  PARSE_HEADER: 1, 
  PARSE_DATA: 2, 
  PARSE_END: 3, 
}; 

接著我們定義狀態(tài)集的轉(zhuǎn)換規(guī)則。

class StateSwitcher { 
    constructor(options) { 
        this.options = options; 
    } 
 
    [PARSE_STATE.PARSE_INIT](data) { 
        // 數(shù)據(jù)不符合預(yù)期 
        if (data[0] !== PACKET_START) { 
            // 跳過部分?jǐn)?shù)據(jù)，找到開始標(biāo)記 
            const position = data.indexOf(PACKET_START); 
            // 沒有開始標(biāo)記，說明這部分?jǐn)?shù)據(jù)無效，丟棄 
            if (position === -1) { 
                return [NEED_MORE_DATA, null]; 
            } 
            // 否則返回有效數(shù)據(jù)部分，繼續(xù)解析 
            return [PARSE_STATE.PACKET_START, data.slice(position)]; 
        } 
        // 保存當(dāng)前正在解析的數(shù)據(jù)包 
        this.packet = new Packet(); 
        // 跳過開始標(biāo)記的字節(jié)數(shù)，進(jìn)入解析協(xié)議頭階段 
        return [PARSE_STATE.PARSE_HEADER, data.slice(Buffer.from([PACKET_START]).byteLength)]; 
    }  
 
    [PARSE_STATE.PARSE_HEADER](data) { 
        // 數(shù)據(jù)不夠頭部的大小則等待數(shù)據(jù)到來 
        if (data.length < TOTAL_LENGTH + SEQ_LEN) { 
          return [NEED_MORE_DATA, data]; 
        } 
        // 有效數(shù)據(jù)包的長度 = 整個(gè)數(shù)據(jù)包長度 - 頭部長度 
        this.packet.set('length', data.readUInt32BE() - (TOTAL_LENGTH + SEQ_LEN)); 
        // 序列號(hào) 
        this.packet.set('seq', data.readUInt32BE(TOTAL_LENGTH)); 
        // 解析完頭部了，跳過去 
        data = data.slice(TOTAL_LENGTH + SEQ_LEN); 
        // 進(jìn)入解析數(shù)據(jù)階段 
        return [PARSE_STATE.PARSE_DATA, data]; 
    } 
 
    [PARSE_STATE.PARSE_DATA](data) { 
        const len = this.packet.get('length'); 
        // 數(shù)據(jù)部分的長度小于協(xié)議頭中定義的長度，則繼續(xù)等待 
        if (data.length < len) { 
            return [NEED_MORE_DATA, data]; 
        } 
        // 截取數(shù)據(jù)部分 
        this.packet.set('data', data.slice(0, len)); 
        // 解析完數(shù)據(jù)了，完成一個(gè)包的解析，跳過數(shù)據(jù)部分 
        data = data.slice(len); 
        typeof this.options.cb === 'function' && this.options.cb(this.packet); 
        this.packet = null; 
        // 解析完一個(gè)數(shù)據(jù)包，進(jìn)入結(jié)束標(biāo)記階段 
        return [PARSE_STATE.PARSE_INIT, data]; 
    } 
} 

我們?cè)倏匆幌聽顟B(tài)機(jī)的實(shí)現(xiàn)

class FSM { 
    constructor(options) { 
        this.options = options; 
        // 狀態(tài)處理機(jī)，定義了狀態(tài)轉(zhuǎn)移集合 
        this.stateSwitcher = new StateSwitcher({cb: options.cb}); 
        // 當(dāng)前狀態(tài) 
        this.state = PARSE_STATE.PARSE_INIT; 
        // 結(jié)束狀態(tài) 
        this.endState = PARSE_STATE.PARSE_END; 
        // 當(dāng)前待解析的數(shù)據(jù) 
        this.buffer = null; 
    } 
 
    run(data) { 
        // 沒有數(shù)據(jù)或者解析結(jié)束了直接返回 
        if (this.state === this.endState || !data || !data.length) { 
            return; 
        } 
        // 保存待解析的數(shù)據(jù) 
        this.buffer = this.buffer ? Buffer.concat([this.buffer, data]) : data; 
        // 還沒結(jié)束，并且還有數(shù)據(jù)可以處理則繼續(xù)執(zhí)行 
        while(this.state !== this.endState && this.buffer && this.buffer.length) { 
            // 執(zhí)行狀態(tài)處理函數(shù)，返回[下一個(gè)狀態(tài), 剩下的數(shù)據(jù)] 
            const result = this.stateSwitcher[this.state](this.buffer); 
            // 如果下一個(gè)狀態(tài)是NEED_MORE_DATA則說明需要更多的數(shù)據(jù)才能繼續(xù)解析，并保持當(dāng)前狀態(tài) 
            if (result[0] === NEED_MORE_DATA) { 
                return; 
            } 
            // 記錄下一個(gè)狀態(tài)和數(shù)據(jù) 
            [this.state, this.buffer] = result; 
        } 
 
    } 
} 

狀態(tài)機(jī)就是對(duì)開始狀態(tài)、結(jié)束狀態(tài)、狀態(tài)轉(zhuǎn)換集的封裝。實(shí)現(xiàn)了協(xié)議的封包和解析后我們看一下如何使用。

2 IPC服務(wù)器的設(shè)計(jì)與實(shí)現(xiàn)

首先我們實(shí)現(xiàn)一個(gè)Client類表示和客戶端通信的實(shí)例。

// Client代表一個(gè)和server建立連接的客戶端 
class Client extends EventEmitter { 
  constructor(options) { 
    super(); 
    this.options = options; 
  } 
  send(data) { 
    this.options.client.write(data); 
  } 
  end(data) { 
    this.options.client.end(data); 
  } 
} 

然后我們開始實(shí)現(xiàn)真正的IPC服務(wù)器

class Server extends EventEmitter { 
    constructor(options, connectionListener) { 
      super(); 
      this.options = { ...options }; 
      // 根據(jù)平臺(tái)處理參數(shù) 
      if (os.platform() === 'win32') { 
        !~~this.options.port && (this.options.port = port); 
        delete this.options.path; 
      } else { 
        !this.options.path && (this.options.path = path);  
        delete this.options.host; 
        delete this.options.port; 
        fs.existsSync(this.options.path) && fs.unlinkSync(this.options.path); 
        process.on('exit', () => { 
          fs.existsSync(this.options.path) && fs.unlinkSync(this.options.path); 
        }); 
      } 
      this.server = net.createServer({allowHalfOpen: true}, (client) => { 
        const _client = new Client({client}); 
        typeof connectionListener === 'function' && connectionListener(_client); 
        const fsm = new FSM({ 
            cb: function(packet) { 
              _client.emit('message', packet); 
            } 
        }) 
        client.on('data', fsm.run.bind(fsm)); 
        client.on('end', () => { 
          // 觸發(fā)end事件 
          _client.emit('end'); 
          // 用戶側(cè)沒有關(guān)閉寫端，則默認(rèn)關(guān)閉 
          !client.writableEnded && this.options.autoEnd !== false && client.end(); 
        }); 
        client.on('error', (error) => { 
          _client.listenerCount('error') > 0 && _client.emit('error', error); 
        }); 
      }); 
      this.server.listen(this.options, () => { 
        this.emit('listen'); 
      }); 
      this.server.on('error', (error) => { 
        this.listenerCount('error') > 0 && this.emit('error', error); 
      }); 
    } 
} 

服務(wù)器是對(duì)tcp和unix域服務(wù)器的封裝，基于tcp或者unix域傳輸?shù)臄?shù)據(jù)由狀態(tài)機(jī)進(jìn)行處理，狀態(tài)機(jī)解析完數(shù)據(jù)包后，通知調(diào)用方。

3 IPC客戶端的設(shè)計(jì)與實(shí)現(xiàn)

class Client extends EventEmitter { 
  constructor(options) { 
    super(); 
    this.options = { ...options }; 
    this.socket = null; 
    this.fsm = new FSM({ 
        cb: (packet) => { 
            this.emit('message', packet); 
        } 
    }) 
  } 
  initOnce() { 
    if (!this.socket) { 
      if (os.platform() === 'win32') { 
        !~~this.options.port && (this.options.port = port); 
        delete this.options.path; 
      } else { 
        !this.options.path && (this.options.path = path);  
        delete this.options.host; 
        delete this.options.port; 
      } 
      this.socket = net.connect({allowHalfOpen: true, ...this.options}); 
      this.socket.on('data', this.fsm.run.bind(this.fsm)); 
      this.socket.on('end', () => { 
        // 觸發(fā)end事件 
        this.emit('end'); 
        // 用戶側(cè)沒有關(guān)閉寫端，則默認(rèn)關(guān)閉 
        !this.socket.writableEnded && this.options.autoEnd !== false && this.socket.end(); 
      }); 
      this.socket.on('error', (e) => { 
        this.listenerCount('error') > 0 && this.emit('error', e); 
      }); 
    } 
  } 
  send(data) { 
    this.initOnce(); 
    this.socket.write(data); 
    return this; 
  } 
  end(data) { 
    this.initOnce(); 
    this.socket.end(data); 
  } 
} 

客戶端和服務(wù)器類似，也是對(duì)tcp和unix域客戶端的封裝。其中數(shù)據(jù)也是由狀態(tài)機(jī)處理。

4 使用

接下來我們看一下如何使用。server.js

const { Server, packet, seq } = require('../../'); 
// window下使用tcp，非window使用unix域，即使傳了port  
new Server({port: 80, path: '/tmp/unix.sock'}, function(client) { 
    client.on('message', (data) => { 
        console.log('receive', data); 
        client.send(packet('world', data.seq)); 
        client.send(packet('world', data.seq)); 
    }); 
    client.on('end', (data) => { 
        client.end(); 
    }); 
}); 

client.js

const { Client, packet, seq } = require('../../'); 
const client = new Client({port: 80, path: '/tmp/unix.sock'}) 
client.send(packet('hello', seq())); 
client.send(packet('hello', seq())); 
client.on('message', function(res) { 
  console.log('receive', res); 
}) 

服務(wù)器輸出

客戶端輸出

5 拓展

我們實(shí)現(xiàn)了數(shù)據(jù)的傳輸和解析，但是如何我們希望數(shù)據(jù)的請(qǐng)求和響應(yīng)是一一對(duì)應(yīng)的怎么辦呢?比如像http在tcp上可以并發(fā)發(fā)起多個(gè)請(qǐng)求一樣，響應(yīng)是否可以亂序返回，我們又如何知道某個(gè)響應(yīng)對(duì)應(yīng)的是哪個(gè)請(qǐng)求?接下來介紹如何解決這個(gè)問題。首先我們實(shí)現(xiàn)一個(gè)請(qǐng)求管理的類。

class RequestManager { 
    constructor(options) { 
        this.options = { timeout: 10000, ...options }; 
        this.map = {}; 
        this.timerId = null; 
        this.startPollTimeout(); 
    } 
    set(key, context) { 
        if (typeof context.cb !== 'function') { 
            throw new Error('cb is required'); 
        } 
        this.map[key] = { 
            startTime: Date.now(), 
            ...context, 
        }; 
    } 
    get(key) { 
        return this.map[key]; 
    } 
    del(key) { 
        return delete this.map[key]; 
    } 
    // 執(zhí)行上下文 
    exec(key, data) { 
        const context = this.get(key); 
        if (context) { 
            this.del(key); 
            context.cb(data); 
        } 
    }  
    // 定時(shí)輪詢是否超時(shí) 
    startPollTimeout() { 
        this.timerId = setTimeout(() => { 
            if (!this.timerId) { 
                return; 
            } 
            const nextMap = {}; 
            for (const [key, context] of Object.entries(this.map)) { 
                if (Date.now() - context.startTime < (context.timeout || this.options.timeout)) { 
                    nextMap[key] = context; 
                } else { 
                    context.cb(new Error('timeout')); 
                } 
            } 
            this.map = nextMap; 
            this.startPollTimeout(); 
        }, 1000); 
    } 
} 

該類的邏輯主要是請(qǐng)求的seq保存對(duì)應(yīng)的上下文，然后收到響應(yīng)的時(shí)候，我們根據(jù)響應(yīng)的seq拿到對(duì)應(yīng)的上下文，從而執(zhí)行對(duì)應(yīng)的回調(diào)。我們看看如何使用該類。server.js

const { Server, packet, seq } = require('../../'); 
new Server({port: 80, path: '/tmp/unix.sock'}, function(client) { 
    client.on('message', (data) => { 
        console.log('receive', data); 
        // setTimeout測試超時(shí)場景 
        //setTimeout(() => { 
            client.send(packet('world', data.seq)); 
        // }, 2000) 
    }); 
    client.on('end', (data) => { 
        client.end(); 
    }); 
}); 

client.js

const { Client, packet, seq, RequestManager } = require('../../'); 
const requestManager = new RequestManager({timeout: 3000}); 
const client = new Client({port: 80, path: '/tmp/unix.sock'}); 
const _seq = seq();  
// 保存seq對(duì)應(yīng)的上下文 
requestManager.set(_seq, { 
  cb: function() { 
    console.log(...arguments); 
  } 
}) 
// 發(fā)送數(shù)據(jù)包 
client.send(packet('hello', _seq)); 
client.on('message', function(packet) { 
  // 根據(jù)響應(yīng)的seq執(zhí)行對(duì)應(yīng)的上下文 
  requestManager.exec(packet.seq, packet); 
})