Top 10 Examples of "node-ipc in functional component" in JavaScript

import fs from 'fs-extra'
import named from 'named-regexp'
import S from 'string'
import util from 'util'
import got from 'got'
import request from 'request'
import rp from 'request-promise'
import FormData from 'form-data'
import crypto from 'crypto'
import through2 from 'through2'
import shelljs from 'shelljs'
Promise.promisifyAll(fs)
import ipc from 'node-ipc'


const ipcDaemon = new ipc.IPC()

// process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0"
//
// let options = {
//   method: "POST",
//   url: "https://localhost:8443/engine/job/1468042466879",
//   form: {
//     action: "launch"
//   },
//   auth: {
//     username: "lorem",
//     password: "ipsum",
//     sendImmediately: false
//   },
//   rejectUnauthorized: false,
//   resolveWithFullResponse: true,

const ipc = new Promise((resolve) => {
    const ipc = require('node-ipc');
    ipc.config.id = 'storybook-specifications-middleware';
    ipc.config.retry = 1500;
    ipc.config.silent = true;
    ipc.serve(() => {
      console.log('🌱', 'started ipc server');
      resolve(ipc);
    });
    ipc.server.start();

    ipc.server.on('message', (data, socket) => {
      console.log('🥁', 'message', data);
      // ipc.server.emit(socket, 'message', data); // WORKS
    });
    ipc.server.on('custom', (data, socket) => {
      console.log('💅🏻', 'custom', data);
      // ipc.server.emit(socket, 'message', data); // WORKS
    });
    ipc.server.on('connect', (socket) => {
      console.log('💡', 'connect');
    });
    ipc.server.on('error', (data, socket) => {
      console.log('🚨', 'error', data);
      // ipc.server.emit(socket, 'error', error);
    });

kickstart() {
        // Config IPC
        ipc.config.id = 'switch-service-channel';
        ipc.config.retry = 1500;
        ipc.config.silent = true;

        // Serve, then listen to incoming events
        ipc.serve(() => ipc.server.on('switch-service-incoming', (message, _socket) => {
            socket = _socket;
            const msg: ProcessMessage = 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);
                    // send config update to client..
                    this.sendConfigUpdateToDockClient(msg.data);
                    break;
                case 'show-dock':
                    console.log('[info] Show dock');

#!/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);
};

return new Promise((res, rej) => {
    // Note: we give pushpin a couple seconds to handle the message
    const timer = setTimeout(() => {
      ipc.disconnect('renderer')
      res({ type: 'Failed', details: 'Timed out.' })
    }, 2500)
    ipc.connectTo('renderer', WEBCLIPPER_SOCKET_LOCATION, () => {
      ipc.of.renderer.on('connect', () => {
        ipc.of.renderer.emit('clipper', msg)

        ipc.of.renderer.on('renderer', (msg) => {
          res(msg)
          ipc.disconnect('renderer')
          clearTimeout(timer)
        })
      })
    })
  })
}

return new Promise((resolve, reject) => {
      const serverName = ipc.config.id;

      ipc.connectTo(serverName, () => {
        const server = ipc.of[serverName];

        // connected and emit method
        server.on('connect', () => {
          ipc.log(`connected to "${serverName}"`);
          // call method on server
          server.emit(method, input);
        });

        // listen for method response
        server.on(method, ({ error, response }) => {
          // receive server respons
          ipc.disconnect(serverName); // disconnect client to server
          ipc.log(`${serverName}@${method}:response`, error, response);
          resolve(response); // return response
        });

constructor(config: Config, methodsMap: MethodsMap) {
    // setup config
    ipc.config.id = config.serverName;
    ipc.config.silent = !config.debug;
    ipc.config.logInColor = true;

    // create socket
    ipc.serve(() => {
      ipc.log('server started');
    });

    ipc.server.on('ping', (input, socket) => {
      ipc.server.emit(socket, 'ping', { response: true });
    });

    ipc.server.on('stop', () => {
      ipc.server.stop();
    });

    // register rpc methods
    // TODO: somehow listen for events which are not registered
    _forEach(methodsMap, (methodFunc, methodName) => {
      ipc.log('register', methodName);
      ipc.server.on(methodName, (input, socket) => {

import store from 'browser/main/store'
import ConfigManager from 'browser/main/lib/ConfigManager'

const nodeIpc = require('node-ipc')
const { remote, ipcRenderer } = require('electron')
const { app, Menu } = remote
const path = require('path')

nodeIpc.config.id = 'node'
nodeIpc.config.retry = 1500
nodeIpc.config.silent = true
console.log('Initializing IPC Server')

// TODO: IPC SERVER WILL BE MOVED TO MAIN PROCESS FROM MAIN WINDOW PROCESS(RENDERER)
nodeIpc.serve(
  path.join(app.getPath('userData'), 'boostnote.service'),
  function () {
    console.log('IPC Server Started')
    ipcRenderer.on('open-finder', function () {
      console.log('Open finder')
      nodeIpc.server.broadcast('open-finder')
    })

    /** Quit Sequence
    1. `quit-app` Main process -> Main window by Electron IPC
    2. `quit-finder-app` Main window -> Finder window by Node IPC(socket)
    3. Finder window (and Finder main process: OSX only) killed by remote API
    4. `quit-finder-app-confirm` Finder window -> Main window by NodeIPC
    5. `quit-app-confirm` Main window -> Main process by Electron IPC
    6. Main process discard close preventer and terminate Main window and itself.

module.exports = fp((fastify, options, next) => {
    fastify.decorate('cache', new DacCache());

    const ipc = new IPC();
    ipc.config.appspace = 'eosdac.';
    ipc.connectTo('eosdacprocessor', () => {
        ipc.of.eosdacprocessor.on('action', async (a) => {
            // console.log(dac_directory.msig_accounts());

            if (a.action && a.action.name === 'stprofile'){
                // invalidate profile cache
                let cache_name = `/v1/eosdac/profile?account=${a.action.data.cand}`;

                fastify.cache.set(a.action.data.dac_id, cache_name);
            }
            else if (a.action && a.action.account === 'dacmultisigs' && a.action.data.dac_id){
                fastify.cache.removePrefix(a.action.data.dac_id, `/v1/eosdac/msig_proposals`);
            }
        });
    });

}
	
	
});

// Quit when all windows are closed.
app.on('window-all-closed', () => {
	// On macOS it is common for applications and their menu bar
	// to stay active until the user quits explicitly with Cmd + Q
	if (process.platform !== 'darwin') {
		app.quit()
	}
});


const sub = new IPC();
sub.config.silent = true;
sub.config.maxRetries = 1;
sub.connectTo('crosscode-map-editor', () => {
	sub.of['crosscode-map-editor'].on('connect', () => {
		sub.disconnect('crosscode-map-editor');
		app.quit();
	});
	sub.of['crosscode-map-editor'].on('error', () => {
		sub.disconnect('crosscode-map-editor');

		const master = new IPC();
		master.config.silent = true;
		master.config.id = 'crosscode-map-editor'
		master.serve(() => {
			master.server.on('connect', () => openWindow());
		});