@aj-shadow/z-abs-funclayer-engine-server 0.0.0-aj-beta.221

package/project/server/stack/managers/server-manager/server.js

@@ -0,0 +1,384 @@
+
+'use strict';
+
+const NetworkType = require('../../network/network-type');
+const NetworkConnectionShared = require('../../network/network-connection-shared');
+const TcpServer = require('../../network/tcp/tcp-server');
+const UdpServer = require('../../network/udp/udp-server');
+const McServer = require('../../network/mc/mc-server');
+const TlsServer = require('../../network/tls/tls-server');
+const TcpConnectionServer = require('../../network/tcp/tcp-connection-server');
+const TcpConnectionServerShared = require('../../network/tcp/tcp-connection-server-shared');
+const UdpConnectionServer = require('../../network/udp/udp-connection-server');
+const UdpConnectionServerShared = require('../../network/udp/udp-connection-server-shared');
+const McConnectionServer = require('../../network/mc/mc-connection-server');
+const McConnectionServerShared = require('../../network/mc/mc-connection-server-shared');
+const TlsConnectionServer = require('../../network/tls/tls-connection-server');
+const TlsConnectionShared = require('../../network/tls/tls-connection-shared');
+const PendingConst = require('../../pending/pending-const');
+const PendingContext = require('../../pending/pending-context');
+const LogDataAction = require('z-abs-funclayer-engine-cs/clientServer/log/log-data-action');
+const LogMsgServer = require('z-abs-funclayer-engine-cs/clientServer/log/msg/log-msg-server');
+const LogDataStackType = require('z-abs-funclayer-engine-cs/clientServer/log/log-data-stack-type');
+const LogObjectIp = require('z-abs-funclayer-engine-cs/clientServer/log/log-object-ip');
+const FactoryNew = require('z-abs-corelayer-cs/clientServer/factory/factory-new');
+
+
+class Server {
+  static STATE_NONE = 0;
+  static STATE_STARTING = 1;
+  static STATE_STARTED = 2;
+  static STATE_STOPPING = 3;
+  static STATE_STOPPED = 4;
+  static STATES = ['STATE_NONE', 'STATE_STARTING', 'STATE_STARTED', 'STATE_STOPPING', 'STATE_STOPPED'];
+  
+  constructor(id, actor, cbRemove) {
+    this.id = id;
+    this.actor = actor;
+    this.cbRemove = cbRemove;
+    this.connections = new Map();
+    this.pendingStartedConnections = [];
+    this.pendingAcceptedConnections = [];
+    this.acceptingConnectionCallbacks = [];
+    this.stoppingCallbacks = [];
+    this.srvAddress = null;
+    this.dstAddress = null;
+    this.networkServer = null;
+    this.state = Server.STATE_NONE;
+  }
+  
+  start(connection, options) {
+    this.srvAddress = connection.srvAddress;
+    this.dstAddress = connection.dstAddress;
+    connection.init(this);
+    const connectionDataLocal = connection.getConnectionDataLocal();
+    this._createServer(options, connection);
+    const pendingContext = new PendingContext(PendingConst.ACTOR);
+    connection.pendingStartContext(pendingContext, 'serverStart', () => {
+      // TODO: CANCEL PENDING server.start() NOT IMPLEMENTED
+    });
+    this.actor.logIp(() => this.actor.createLogMessage(`STARTING${connection.stackLog} local[${connectionDataLocal.getLog()}]`, null, new LogMsgServer(LogDataAction.STARTING, connection.name, connectionDataLocal), null), 'core', '99006ce3-5816-4a03-b813-220a9ad5a7d9');
+    this._setState(Server.STATE_STARTING);
+    connection.sharedManager.addServer(this.srvAddress, connection.messageSelector);
+    this.networkServer.init(this.srvAddress, this.dstAddress, options.transportLayer.transportProperties, (err) => {
+      if(err) {
+        this._setState(Server.STATE_NONE);
+        this.removeConnection(connection, () => {
+          connection.unlockAddress(this.srvAddress);
+          this.actor.logIp(() => this.actor.createLogMessage(`NOT STARTED${connection.stackLog} local[${connectionDataLocal.getLog()}]`, null, new LogMsgServer(LogDataAction.NOT_STARTED, connection.name, connectionDataLocal), null), 'core', '40b807ca-f7fc-4092-84ca-9450148645b4');
+          connection.pendingErrorContext(pendingContext, 'serverStart', err);
+          while(0 !== this.pendingStartedConnections.length) {
+            const pendingConnection = this.pendingStartedConnections.shift();
+            const pendingConnectionDataLocal = pendingConnection.connection.getConnectionDataLocal();
+            pendingConnection.connection.actor.logIp(() => pendingConnection.connection.actor.createLogMessage(`NOT ATTACHED${pendingConnection.connection.stackLog} local[${pendingConnectionDataLocal.getLog()}]`, undefined, new LogMsgServer(LogDataAction.NOT_ATTACHED, connection.name, pendingConnectionDataLocal), null), 'core', 'afc7033e-2570-4667-8b44-02e52bc986ef');
+            pendingConnection.connection.pendingErrorContext(pendingConnection.pendingContext, 'serverAttach', err);
+          }
+        });
+      }
+      else {
+        this._setState(Server.STATE_STARTED);
+        this.actor.logIp(() => this.actor.createLogMessage(`STARTED${connection.stackLog} local[${connectionDataLocal.getLog()}]`, null, new LogMsgServer(LogDataAction.STARTED, connection.name, connectionDataLocal), null), 'core', '7747f18e-61de-4a41-8cbc-c175bd1a26de');
+        connection.pendingDoneContext(pendingContext, 'serverStart', null);
+        while(0 !== this.pendingStartedConnections.length) {
+          const pendingConnection = this.pendingStartedConnections.shift();
+          const pendingConnectionDataLocal = pendingConnection.connection.getConnectionDataLocal();
+          pendingConnection.connection.actor.logIp(() => pendingConnection.connection.actor.createLogMessage(`ATTACHED${pendingConnection.connection.stackLog} local[${pendingConnectionDataLocal.getLog()}]`, null, new LogMsgServer(LogDataAction.ATTACHED, connection.name, pendingConnectionDataLocal), null), 'core', '768d00e9-600e-43dd-9848-831bda064870');
+          pendingConnection.connection.pendingDoneContext(pendingConnection.pendingContext, 'serverAttach', pendingConnection.connection);
+        }
+      }
+    });
+  }
+  
+  attachConnection(connection) {
+    connection.init(this);
+    let cancel = false;
+    const pendingContext = new PendingContext(PendingConst.ACTOR);
+    connection.pendingStartContext(pendingContext, 'serverAttach', () => {
+      cancel = true;
+    });
+    if(Server.STATE_STARTED === this.state) {
+      process.nextTick((cancel, connection, pendingContext) => {
+        if(!cancel) {
+          connection.pendingDoneContext(pendingContext, 'serverAttach', connection);
+        }
+      }, cancel, connection, pendingContext);
+    }
+    else if(Server.STATE_STARTING === this.state) {
+      this.pendingStartedConnections.push({
+        connection: connection,
+        pendingContext: pendingContext
+      });
+    }
+  }
+  
+  addConnection(connection) {
+    this.connections.set(connection.id, connection);
+  }
+    
+  detachConnection(connection) {
+    this.connections.delete(connection.id);
+  }
+  
+  removeConnection(connection, done) {
+    this.connections.delete(connection.id);
+    connection.logIpStack(() => `DEL STACK: ${connection.name}`, LogDataStackType.DEL, '8622d6d0-1c42-4ebc-9c13-36adaf89ed48');
+    if(0 === this.connections.size) {
+      this._closeServer(connection, () => {
+        this.cbRemove();
+        done(null);
+      });
+    }
+    else {
+      const connectionDataLocal = connection.getConnectionDataLocal();
+      connection.actor.logIp(() => connection.actor.createLogMessage(`DETACHED${connection.stackLog} local[${connectionDataLocal.getLog()}]`, null, new LogMsgServer(LogDataAction.DETACHED, connection.name, connectionDataLocal), null), 'core', 'aa1e6f3e-ae58-48a2-a993-2d2721faa643');
+      done(null);
+    }
+  }
+  
+  _findPendingAccepted(messageSelector) {
+    const foundIndex = this.pendingAcceptedConnections.findIndex((pendingAcceptedConnection) => {
+      return !(pendingAcceptedConnection instanceof NetworkConnectionShared) === !messageSelector;
+    });
+    if(-1 !== foundIndex) {
+      const connection = this.pendingAcceptedConnections[foundIndex];
+      this.pendingAcceptedConnections.splice(foundIndex, 1);
+      return connection
+    }
+    else {
+      return null;
+    }
+  }
+  
+  _findSharedAccepted(messageSelector) {
+    if(messageSelector) {
+      let foundConnection = null;
+      for(let [key, connection] of this.connections) {
+        if(connection.messageSelector && connection.networkConnection) {
+          foundConnection = connection;
+          break;
+        }
+      }
+      return foundConnection;
+    }
+    else {
+      return null;
+    }
+  }
+  
+  accept(connection, done) {
+    if(0 !== this.pendingAcceptedConnections.length) {
+      const foundNetworkConnection = this._findPendingAccepted(connection.messageSelector);
+      if(null !== foundNetworkConnection) {
+        if(foundNetworkConnection instanceof NetworkConnectionShared) {
+          foundNetworkConnection.ref();
+        }
+        done(foundNetworkConnection);
+      }
+      else {
+        this.acceptingConnectionCallbacks.push({
+          connection: connection,
+          done: done
+        });
+      }
+    }
+    else {
+      const foundConnection = this._findSharedAccepted(connection.messageSelector);
+      if(null !== foundConnection) {
+        connection.messageSelector._setId(foundConnection.networkConnection.ref());
+        done(foundConnection.networkConnection);
+      }
+      else {
+        this.acceptingConnectionCallbacks.push({
+          connection: connection,
+          done: done
+        });
+      }
+    }
+  }
+  
+  close(cbClose) {
+    let connections = this.connections.size;
+    if(0 === connections) {
+      let pendingAcceptedConnections = this.pendingAcceptedConnections.length;
+      if(0 === this.pendingAcceptedConnections.length) {
+        this._closeServer(null, () => {
+          cbClose();
+        });        
+      }
+      else {
+        this.pendingAcceptedConnections.forEach((connection) => {
+          if(0 === --pendingAcceptedConnections) {
+            this._closeServer(connection, () => {
+              cbClose();
+            });
+          }
+        });
+      }
+    }
+    else {
+      this.connections.forEach((connection) => {
+        connection.closeForgottenConnections(() => {
+          if(0 === --connections) {
+            this._closeServer(connection, () => {
+              this.connections.clear();
+              cbClose();
+            });
+          }
+        });
+      });
+    }
+  }
+  
+  _handleIncommingConnection(connection, networkConnection) {
+    if(0 !== this.acceptingConnectionCallbacks.length) {
+      const foundIndex = this.acceptingConnectionCallbacks.findIndex((acceptingConnectionCallback) => {
+        return !acceptingConnectionCallback.connection.messageSelector === !connection.messageSelector;
+      });
+      if(-1 !== foundIndex) {
+        const callbackData = this.acceptingConnectionCallbacks[foundIndex];
+        this.acceptingConnectionCallbacks.splice(foundIndex, 1);
+        if(callbackData.connection._shared()) {
+          const ref = networkConnection.ref();
+          if(callbackData.connection.messageSelector) {
+            callbackData.connection.messageSelector._setId(ref);
+          }
+          const callbackDatas = [];
+          for(let i = 0; i < this.acceptingConnectionCallbacks.length;) {
+            const acceptingConnectionCallback = this.acceptingConnectionCallbacks[i];
+            if(!!acceptingConnectionCallback.connection.messageSelector) {
+              callbackDatas.push(acceptingConnectionCallback);
+              acceptingConnectionCallback.connection.messageSelector._setId(networkConnection.ref());
+              this.acceptingConnectionCallbacks.splice(i, 1);
+            }
+            else {
+              ++i;
+            }
+          }
+          callbackDatas.forEach((callbackData) => {
+            process.nextTick(callbackData.done, networkConnection);
+          });
+        }
+        callbackData.done(networkConnection);
+      }
+      else {
+        this.pendingAcceptedConnections.push(networkConnection);
+      }
+    }
+    else {
+      this.pendingAcceptedConnections.push(networkConnection);
+    }
+  }
+  
+  _createServer(options, connection) {
+    switch(options.transportLayer.transportType) {
+      case NetworkType.UDP:
+        this.networkServer = FactoryNew.create(UdpServer, connection, (socket, remote) => {
+          let udpConnection = null;
+          const con = FactoryNew.create(UdpConnectionServer, connection.srvAddress, connection.dstAddress, this.networkServer, options.transportLayer.transportProperties, connection);
+          if(!connection._shared()) {
+            udpConnection = con;
+          }
+          else {
+            udpConnection = FactoryNew.create(UdpConnectionServerShared, con, 'udp server');  
+          }
+          udpConnection.attach(socket);
+          udpConnection.setRemoteAddress(remote);
+          this._handleIncommingConnection(connection, udpConnection);
+          return udpConnection;
+        });
+        break;
+      case NetworkType.MC:
+        this.networkServer = FactoryNew.create(McServer, connection, (socket, remote) => {
+          let mcConnection = null;
+          const con = FactoryNew.create(McConnectionServer, connection.srvAddress, connection.dstAddress, this.networkServer, options.transportLayer.transportProperties, connection);
+          if(!connection._shared()) {
+            mcConnection = con;
+          }
+          else {
+            mcConnection = FactoryNew.create(McConnectionServerShared, con, 'mc server');  
+          }
+          mcConnection.attach(socket);
+          mcConnection.setRemoteAddress(remote);
+          this._handleIncommingConnection(connection, mcConnection);
+          return mcConnection;
+        });
+        break;
+      case NetworkType.TLS:
+        this.networkServer = FactoryNew.create(TlsServer, connection, (socket) => {
+          let tlsConnection = null;
+          const con = FactoryNew.create(TlsConnectionServer, connection.srvAddress, connection.dstAddress, options.transportLayer.transportProperties, connection);
+          if(!connection._shared()) {
+            tlsConnection = con;
+          }
+          else {
+            tlsConnection = FactoryNew.create(TlsConnectionShared, con, 'tls server');  
+          }
+          tlsConnection.attach(socket);
+          this._handleIncommingConnection(connection, tlsConnection);
+        });
+        break;
+      case NetworkType.TCP:
+      default:
+        this.networkServer = FactoryNew.create(TcpServer, connection, (socket) => {
+          let tcpConnection = null;
+          const con = FactoryNew.create(TcpConnectionServer, connection.srvAddress, connection.dstAddress, options.transportLayer.transportProperties, connection);
+          if(!connection._shared()) {
+            tcpConnection = con;
+          }
+          else {
+            tcpConnection = FactoryNew.create(TcpConnectionServerShared, con, 'tcp server');
+          }
+          tcpConnection.attach(socket);
+          this._handleIncommingConnection(connection, tcpConnection);
+        });
+        break;
+    }
+  }
+  
+  _closeNetworkServer(connection, done) {
+    this.networkServer.close(() => {
+      this._setState(Server.STATE_STOPPED);
+      const connectionDataLocal = connection.getConnectionDataLocal();
+      connection.actor.logIp(() => connection.actor.createLogMessage(`STOPPED${connection.stackLog} local[${connectionDataLocal.getLog()}]`, null, new LogMsgServer(LogDataAction.STOPPED, connection.name, connectionDataLocal), null), 'core', 'de9ce489-08bb-44b4-bf31-9aa41a178c7d');
+      this.networkServer = null;
+      done();
+      this.stoppingCallbacks.forEach((cbDone) => {
+        cbDone();
+      });
+      this.stoppingCallbacks = [];
+    });
+    /*this.pendingAcceptedConnections.forEach((connection) => {
+      connection.close((done) => {
+      });
+    });*/
+  }
+  
+  _closeServer(connection, done) {
+    //ddb.info('STATE[' + this.actor.logName + ']:', Server.STATES[this.state]);
+    if(Server.STATE_STOPPING === this.state) {
+      this.stoppingCallbacks.push(done);
+      return;
+    }
+    else if(Server.STATE_STARTED !== this.state) {
+      done();
+      return;
+    }
+    const connectionDataLocal = connection.getConnectionDataLocal();
+    connection.actor.logIp(() => connection.actor.createLogMessage(`STOPPING${connection.stackLog} local[${connectionDataLocal.getLog()}]`, null, new LogMsgServer(LogDataAction.STOPPING, connection.name, connectionDataLocal), null), 'core', 'd5caafe5-e17f-4825-9620-4bffc2402c15');
+    this._setState(Server.STATE_STOPPING);
+    this.pendingAcceptedConnections.forEach((connection) => {
+      connection.close((done) => {
+      });
+    });
+    this._closeNetworkServer(connection, done);
+  }
+  
+  _setState(state) {
+    const currentState = this.state;
+    this.state = state;
+    //ddb.info('STATE[' + this.actor.logName + ']:', Server.STATES[currentState], '=>', Server.STATES[state]);
+  }
+}
+
+
+module.exports = Server;

package/project/server/stack/managers/shared-manager.js

@@ -0,0 +1,117 @@
+
+'use strict';
+
+
+class SharedManager {
+  constructor() {
+    this.connections = new Map();
+    this.servers = [];
+  }
+  
+  hasServer(connectionType) {
+    let has = false;
+    this.servers.forEach((server) => {
+      if(server.messageSelector) {
+        has = has || (connectionType === server.messageSelector.type);
+      }
+    });
+    return has;
+  }
+  
+  getServers(connectionType, interceptor=false) {
+    const servers = [];
+    this.servers.forEach((server) => {
+      if(server.messageSelector) {
+        if(connectionType === server.messageSelector.type && (!interceptor || interceptor && server.messageSelector.interceptor)) {
+          if(server.messageSelector.onSelect) {
+            servers.push({
+              dstAddress: server.srvAddress,
+              members: JSON.stringify(server.messageSelector),
+              onSelectFunction: server.messageSelector.onSelect.toString()
+            });
+          }
+        }
+      }
+    });
+    return servers;
+  }
+  
+  reset() {
+    this.connections = new Map();
+    this.servers = [];
+  }
+  
+  addClient(actorName, local, remote, messageSelector) {
+    const key = this._makeKey('client', local.transportType, actorName, local, remote);
+    if(this.connections.has(key)) {
+      const data = this.connections.get(key);
+      data.clients.set(actorName, {
+        local: local,
+        remote: remote,
+        messageSelector: messageSelector
+      });
+    }
+    else {
+      const clients = new Map();
+      clients.set(actorName, {
+        local: local,
+        remote: remote,
+        messageSelector: messageSelector
+      });
+      this.connections.set(key, {
+        clients: clients,
+        servers: new Map()
+      });
+    }
+  }
+  
+  addServer(srvAddress, messageSelector) {
+    this.servers.push({
+      srvAddress: srvAddress,
+      messageSelector: messageSelector
+    });      
+  }
+  
+  updateServerConnection(actorName, local, remote, messageSelector) {
+    if(messageSelector) {
+      const key = this._makeKey('server', local.transportType, actorName, local, remote);
+      if(this.connections.has(key)) {
+        const data = this.connections.get(key);
+        data.servers.set(actorName, {
+          local: local,
+          remote: remote,
+          messageSelector: messageSelector
+        });
+      }
+      else {
+        const servers = new Map();
+        servers.set(actorName, {
+          local: local,
+          remote: remote,
+          messageSelector: messageSelector
+        });
+        this.connections.set(key, {
+          clients: new Map(),
+          servers: servers
+        });
+      }
+    }
+  }
+  
+  _makeKey(type, transportType, actorName, local, remote) {
+    if("client" === type) {
+      if('mc' === transportType) {
+        return `c_${actorName}_${local.host}:${local.port}_s_${remote.host}:${remote.port}`;
+      }
+      else {
+        return `c_${local.host}:${local.port}_s_${remote.host}:${remote.port}`;
+      }
+    }
+    else if("server" === type) {
+      return `c_${remote.host}:${remote.port}_s_${local.host}:${local.port}`;
+    }
+  }
+}
+
+
+module.exports = SharedManager;

package/project/server/stack/network/buffer-manager.js

@@ -0,0 +1,190 @@
+
+'use strict';
+
+
+class BufferManager {
+  static LF = '\n'.charCodeAt(0);
+  static CR = '\r'.charCodeAt(0);
+  static CRLF = '\r\n';
+  
+  constructor(id) {
+    this.id = id;
+    this.buffers = [];
+    this.length = 0;
+    this.searchBufferIndex = 0;
+    this.bufferStartPos = 0;
+    this.bufferStopIndex = 0;
+    this.bufferStopPos = 0;
+    this.crEnding = false;
+  }
+  
+  _restore() {
+    this.buffers = [];
+    this.length = 0;
+    this.searchBufferIndex = 0;
+    this.bufferStartPos = 0;
+    this.bufferStopIndex = 0;
+    this.bufferStopPos = 0;
+    this.crEnding = false;
+  }
+  
+  getLine() {
+    let line = '';
+    if(0 === this.bufferStopIndex) {
+      const totalLength = this.bufferStopPos + 2;
+      line = this.buffers[0].toString('utf8', this.bufferStartPos, this.bufferStopPos);
+      if(this.buffers[0].length === totalLength) {
+        this.bufferStartPos = 0;
+        this.buffers.shift();
+      }
+      else {
+        this.bufferStartPos = totalLength;
+      }
+      this.bufferStopPos = -1;
+      this.length -= (line.length + 2);
+    }
+    else {
+      let buffersLength = 0;
+      for(let i = 0; i <= this.bufferStopIndex; ++i) { 
+        buffersLength += this.buffers[i].length;
+      }
+      const contentLength = buffersLength - this.bufferStartPos - (this.buffers[this.bufferStopIndex].length - this.bufferStopPos);
+      line = Buffer.concat(this.buffers, buffersLength).toString('utf8', this.bufferStartPos, this.bufferStartPos + contentLength);
+      if(buffersLength === line.length + 2) {
+        this.bufferStartPos = 0;
+        this.buffers.splice(0, this.bufferStopIndex + 1);
+      }
+      else {
+        this.bufferStartPos = this.bufferStopPos + 2;
+        this.buffers.splice(0, this.bufferStopIndex);
+      }
+      this.searchBufferIndex = 0;
+      this.bufferStopPos = -1;
+      this.length -= (contentLength + 2);
+    }
+    return line;
+  }
+  
+  findLine() {
+    if(0 === this.length) {
+      return false;
+    }
+    // SEARCH FIRST BUFFER
+    const currentBuffer = this.buffers[this.searchBufferIndex];
+    if(0 === this.searchBufferIndex) {
+      const posEnd = currentBuffer.indexOf(BufferManager.CRLF, this.bufferStartPos);
+      if(-1 !== posEnd) {
+        this.bufferStopIndex = this.searchBufferIndex;
+        this.bufferStopPos = posEnd;
+        return true;
+      } 
+      this.crEnding = BufferManager.CR === currentBuffer[currentBuffer.length - 1];
+      ++this.searchBufferIndex;
+    }
+    for(; this.searchBufferIndex < this.buffers.length; ++this.searchBufferIndex) {
+      if(this.crEnding) {
+        if(BufferManager.LF === currentBuffer[0]) {
+          this.bufferStopIndex = this.searchBufferIndex;
+          this.bufferStopPos = -1;
+          return true;
+        }
+      }
+      const posEnd = currentBuffer.indexOf(BufferManager.CRLF);
+      if(-1 !== posEnd) {
+        this.bufferStopIndex = this.searchBufferIndex;
+        this.bufferStopPos = posEnd;
+        return true;
+      }
+      this.crEnding = BufferManager.CR === currentBuffer[currentBuffer.length - 1];
+    }
+    return false;
+  }
+    
+  receiveSize(size) {
+    if(0 === this.length || this.length < size) {
+      return;
+    }
+    this.length -= size;
+    const firstBufferLength = this.buffers[0].length;
+    if(firstBufferLength - this.bufferStartPos === size) {
+      if(0 === this.bufferStartPos) {
+        const b = this.buffers.shift();
+        return b;
+      }
+      else {
+        const pos = this.bufferStartPos;
+        this.bufferStartPos = 0;
+        const buffer = this.buffers.shift();
+        const b = buffer.slice(pos, pos + size);
+        return b;
+      }
+    }
+    else if(firstBufferLength - this.bufferStartPos > size) {
+      const pos = this.bufferStartPos;
+      this.bufferStartPos = 0;
+      if(0 === pos) {
+        const b = this.buffers[0].slice(pos, pos + size);
+        this.buffers[0] = this.buffers[0].subarray(pos + size);
+        return b;
+      }
+      else {
+        const resultBuffer = this.buffers[0].slice(pos, pos + size);
+        this.buffers[0] = this.buffers[0].subarray(pos + size, firstBufferLength);
+        return resultBuffer;
+      }
+    }
+    else {
+      let totalSize = firstBufferLength - this.bufferStartPos;
+      if(totalSize < 0) {
+        ddb.warning(totalSize, firstBufferLength, this.bufferStartPos);
+      }
+      let index = 0;
+      let previusTotalSize = 0;
+      while(totalSize < size) {
+        previusTotalSize = totalSize;
+        totalSize += this.buffers[++index].length;
+      }
+      if(0 !== this.bufferStartPos) {
+        this.buffers[0] = this.buffers[0].subarray(this.bufferStartPos, firstBufferLength);
+      }
+      const restSize = size - previusTotalSize;
+      if(this.buffers[index].length === restSize) {
+        this.bufferStartPos = 0;
+      }
+      else {
+        this.buffers.splice(index, 0, this.buffers[index].slice(0, restSize));
+        this.bufferStartPos = restSize;
+      }
+      const buffer = Buffer.concat(this.buffers, size);
+      this.buffers.splice(0, index + 1);
+      return buffer;
+    }
+  }
+  
+  receive() {
+    if(0 === this.length) {
+      return;
+    }
+    else {
+      const buffers = this.buffers;
+      this._restore();
+      if(1 === buffers.length) {
+        return buffers[0];
+      }
+      else {
+        return Buffer.concat(buffers);
+      }
+    }
+  } 
+  
+  addBuffer(buffer) {
+    if(buffer.length === 0) {
+      throw new Error('');
+    }
+    this.buffers.push(buffer);
+    this.length += buffer.length;
+  }
+}
+
+
+module.exports = BufferManager;