How to use the node-ipc.config function in node-ipc

#!/usr/bin/env node
// LICENSE_CODE ZON ISC
'use strict'; /*jslint node:true, esnext:true*/
const child_process = require('child_process');
const path = require('path');
const ipc = require('node-ipc');
const util_lib = require('../lib/util.js');
const consts = require('../lib/consts.js');
const etask = require('../util/etask.js');
const zerr = require('../util/zerr.js');
const lpm_config = require('../util/lpm_config.js');
const {levels} = require('../lib/logger.js');
const E = module.exports = {};

ipc.config.id = 'lpm_upgrader';
ipc.config.silent = true;
ipc.config.maxRetries = 100;

const emit_message = (msg, data)=>ipc.of.lum_node_index &&
    ipc.of.lum_node_index.emit(msg, data);

const logger = {};
Object.keys(levels).forEach(level=>
    logger[level] = msg=>emit_message('log', {msg, level}));

E.run_script = (script_f, log_f, cb)=>{
    const opt = {name: 'Luminati Proxy Manager'};
    const full_path = path.resolve(__dirname, script_f);
    const cmd = `bash "${full_path}" ${log_f}`;
    child_process.exec(cmd, opt, cb);
};

constructor (options = {}) {
    options = Object.assign({}, DEFAULT_OPTIONS, options)
    ipc.config.id = this.id = options.networkId
    ipc.config.retry = 1500
    ipc.config.silent = true

    this.connected = false
    this.connecting = false
    this.disconnecting = false
    this.queue = null
    this.options = options

    this.listeners = []

    this.disconnectTimeout = 15000
    this.idleTimer = null

    // Prevent forced process exit
    // (or else ipc messages may not be sent before kill)

.command("mremove [nodes...]")
  .description("Removes multiple nodes from this node's cluster. " +
      "If force is passed, the gossip processor on this node " +
      "won't wait for current message streams to be processed " +
      "before executing this command.")
  .option("-f, --force", forceStr)
  .action(function (args, cb) {
    const nodes = parseNodeList(args.nodes);
    client.send("mremove", {
      force: args.options.force,
      nodes: nodes
    }, cb);
  });

console.log("Connecting to IPC server on node: %s, host: %s, port: %s", argv.I, argv.H, argv.p);
ipc.config.silent = true;
ipc.config.sync = true;
ipc.connectToNet(argv.I, argv.H, argv.p, () => {
  client = new Client(ipc, argv.I, argv.H, argv.p, argv.a);
  client.start();
  client.once("connect", () => {
    if (argv._.length === 0) {
      vorpal
        .delimiter("> ")
        .show();
    } else {
      vorpal.exec(argv._, function (err, res) {
        client.stop();
        if (err) {
          process.exit(1);
        } else {
          process.exit(0);

kickstart() {
        ipc.config.id = 'switch-service-channel';
        ipc.config.retry = 1500;
        ipc.config.silent = true;
        ipc.serve(() => ipc.server.on('switch-service-incoming', (message, _socket) => {
            socket = _socket;
            const msg = JSON.parse(message);
            switch (msg.type) {
                case 'update-hot-apps':
                    this.emitter.emit('update-hot-apps', msg.data);
                    break;
                case 'client-pid':
                    this.emitter.emit('client-pid', msg.data);
                    break;
                case 'config-update':
                    this.emitter.emit('config-update', msg.data);
                    this.sendConfigUpdateToDockClient(msg.data);
                    break;
                case 'show-dock':

import { IpcCommunicator, IpcCommunicatorCallback } from "./ipc-communicator";
import { MessengerService } from "../service/messenger-service";
import { RequisitionParser } from "../service/requisition/requisition-parser";
import { Report } from "../report/report";
import { ReportReplierFactory } from "../report/report-replier-factory";
import { ReportReplier } from "../report/report-replier";
import {EnqueuerService} from "../service/enqueuer-service";
import {Requisition} from "../service/requisition/requisition";

const ipc = require('node-ipc');

ipc.config.id = 'enqueuer';
ipc.config.retry = 1500;
ipc.config.silent = true;
export class IpcUds implements IpcCommunicator {
 
    private messengerService: MessengerService | null = null;
    private reportRepliers: ReportReplier[] = [];

    start(ipcCommunicatorCallback: IpcCommunicatorCallback): void {
        console.log("starting ipc-uds");

        ipc.serve(() => this.onConnect());
        ipc.server.start();
    }

    stop(): void {
        ipc.server.end();
    }

import { IpcCommunicator, IpcCommunicatorCallback } from "./ipc-communicator";
import { MessengerService } from "../service/messenger-service";
import { RequisitionParser } from "../service/requisition/requisition-parser";
import { Report } from "../report/report";
import { ReportReplierFactory } from "../report/report-replier-factory";
import { ReportReplier } from "../report/report-replier";
import {EnqueuerService} from "../service/enqueuer-service";
import {Requisition} from "../service/requisition/requisition";

const ipc = require('node-ipc');

ipc.config.id = 'enqueuer';
ipc.config.retry = 1500;
ipc.config.silent = true;
export class IpcUds implements IpcCommunicator {
 
    private messengerService: MessengerService | null = null;
    private reportRepliers: ReportReplier[] = [];

    start(ipcCommunicatorCallback: IpcCommunicatorCallback): void {
        console.log("starting ipc-uds");

        ipc.serve(() => this.onConnect());
        ipc.server.start();
    }

    stop(): void {
        ipc.server.end();

var ipc = require('node-ipc');
var PythonShell = require('python-shell');
var pyshell = new PythonShell('./firmware/rpi/lowlevel-server.py');

pyshell.on('message', (message) => {
    console.log('Python output:', message);
})

var channel = null;
ipc.config.id = 'ipc';
ipc.config.socketRoot = '/tmp/';
ipc.config.appspace = 'app.';
ipc.config.silent = true;
ipc.config.rawBuffer = true;
ipc.config.retry= 1500;

var callback = null;

//TODO: this should be put into an init function
ipc.connectTo(
    'main',
    function(){
        ipc.of.main.on(
            'connect',
            function(){
                ipc.log('## connected to main ##', ipc.config.delay);
                channel = ipc.of.main;

return new Promise(resolve => {
    started = true;
    ipc.config.id = serverID;
    ipc.config.retry = 1500;
    ipc.config.silent = true;

    ipc.serve(() => {
      resolve(ipc.server);
    });

    ipc.server.start();
  });
};

constructor(options) {
    this.logger = options.logger;
    this.socketPath = options.socketPath || fs.dappPath(".embark/embark.ipc");
    this.ipcRole = options.ipcRole;
    ipc.config.silent = true;
    this.connected = false;
  }