network-collection/lib/cluster.js

Baseline collection of graphs and network data structures using **socket.io**.

'use strict';

class Cluster {
  constructor(io) {
    if (!io) {
      throw new Error('Must supply a socket.io instance.');
    }
    this.networks = io.sockets.connected;
  }
  _setupListeners(socket) {
    if (!socket) {
      throw new Error('Socket must be defined.');
    }
    let events = this._events(socket);
    Object.keys(events).map((event) => {
      socket.on(event, events[event]);
    });
  }
  _events(socket) {
    return {
      'disconnect': this.handleDisconnect.bind(this, socket),
    };
  }
  /**
   * Perform a function on all sockets connected to the master.
   */
  map(fn) {
    return Promise.all(
      Object.keys(this.networks).map((key, index) => {
        return fn.call(this, key, index);
      })
    );
  }
  find(label, query) {
    return Promise.all(
      Object.keys(this.networks).map((key) => {
        return new Promise((resolve, reject) => {
          this.networks[key].emit('find', label, query);
          this.networks[key].once(`find_response_${key.replace(/[\/\#]/g, '')}`, (res) => {
            if (res.error) {
              reject(res.error);
              return;
            }
            resolve(res);
          });
        });
      })
    );
  }
  connect(socket, callback) {
    this._setupListeners(socket);
    callback();
  }
  addGraph(id, graph) {
    return new Promise((resolve, reject) => {
      this.networks[id].emit('add_graph', graph);
      this.networks[id].once(`add_graph_response_${id.replace(/[\/\#]/g, '')}`, (res) => {
        if (res.error) {
          reject(res.error);
          return;
        }
        resolve(res);
      });
    });
  }
  removeGraph(id, graphId) {
    return new Promise((resolve, reject) => {
      this.networks[id].emit('remove_graph', graphId);
      this.networks[id].once(`remove_graph_response_${id.replace(/[\/\#]/g, '')}`, (res) => {
        if (res.error) {
          reject(res.error);
          return;
        }
        resolve(res);
      });
    });
  }
  getGraph(id, graphId) {
    return new Promise((resolve, reject) => {
      this.networks[id].emit('get_graph', graphId);
      this.networks[id].once(`get_graph_response_${id.replace(/[\/\#]/g, '')}`, (res) => {
        if (res.error) {
          reject(res.error);
          return;
        }
        resolve(res);
      });
    });
  }
  addEdge(id, graphId, fromId, toId) {
    return new Promise((resolve, reject) => {
      this.networks[id].emit('add_edge', graphId, fromId, toId);
      this.networks[id].once(`add_edge_response_${id.replace(/[\/\#]/g, '')}`, (res) => {
        if (res.error) {
          reject(res.error);
          return;
        }
        resolve(res);
      });
    });
  }
  removeEdge(id, graphId, fromId, toId) {
    return new Promise((resolve, reject) => {
      this.networks[id].emit('remove_edge', graphId, fromId, toId);
      this.networks[id].once(`remove_edge_response_${id.replace(/[\/\#]/g, '')}`, (res) => {
        if (res.error) {
          reject(res.error);
          return;
        }
        resolve(res);
      });
    });
  }
  getEdge(id, graphId, fromId, toId) {
    return new Promise((resolve, reject) => {
      this.networks[id].emit('get_edge', graphId, fromId, toId);
      this.networks[id].once(`get_edge_response_${id.replace(/[\/\#]/g, '')}`, (res) => {
        if (res.error) {
          reject(res.error);
          return;
        }
        resolve(res);
      });
    });
  }
  addNode(id, graphId, node) {
    return new Promise((resolve, reject) => {
      this.networks[id].emit('add_node', graphId, node);
      this.networks[id].once(`add_node_response_${id.replace(/[\/\#]/g, '')}`, (res) => {
        if (res.error) {
          reject(res.error);
          return;
        }
        resolve(res);
      });
    });
  }
  removeNode(id, graphId, nodeId) {
    return new Promise((resolve, reject) => {
      this.networks[id].emit('remove_node', graphId, nodeId);
      this.networks[id].once(`remove_node_response_${id.replace(/[\/\#]/g, '')}`, (res) => {
        if (res.error) {
          reject(res.error);
          return;
        }
        resolve(res);
      });
    });
  }
  getNode(id, graphId, nodeId) {
    return new Promise((resolve, reject) => {
      this.networks[id].emit('get_node', graphId, nodeId);
      this.networks[id].once(`get_node_response_${id.replace(/[\/\#]/g, '')}`, (res) => {
        if (res.error) {
          reject(res.error);
          return;
        }
        resolve(res);
      });
    });
  }
  handleDisconnect(socket) {
    console.log(`Socket ${socket.id} disconnected.`);
  }
}

module.exports = Cluster;