before(function(done) {
ipc.serve(function(){
ipc.server.on('message', function(msg) {});
});
ipc.server.start();
rmrf('.unpacks', function(err) {
done();
});
});
cncserver.ipc.initServer = function(options, callback) {
runnerInitCallback = callback;
// Initialize and start the IPC Server...
ipc.serve(function(){
ipc.server.on('app.message', ipcGotMessage);
});
ipc.server.start();
console.log('Starting IPC server, waiting for runner client to start...');
if (options.localRunner) {
// Register an event callback to shutdown the runner if we're exiting.
process.on('SIGTERM', cncserver.ipc.runner.shutdown);
process.on('SIGINT', cncserver.ipc.runner.shutdown);
cncserver.ipc.runner.init();
}
};
} catch (err) {
errors.push('toggleMain')
}
if (!config.silent) {
if (errors.length === 0) {
mainWindow.webContents.send('APP_SETTING_DONE', {})
} else {
mainWindow.webContents.send('APP_SETTING_ERROR', {
message: 'Failed to apply hotkey: ' + errors.join(' ')
})
}
}
})
nodeIpc.serve(
path.join(app.getPath('userData'), 'boostnote.service'),
function () {
nodeIpc.server.on('connect', function (socket) {
nodeIpc.log('ipc server >> socket joinned'.rainbow)
socket.on('close', function () {
nodeIpc.log('ipc server >> socket closed'.rainbow)
})
})
nodeIpc.server.on('error', function (err) {
nodeIpc.log('Node IPC error'.rainbow, err)
})
}
)
module.exports = nodeIpc
bot.getMe().then(function (me) {
console.log('Hi my name is %s!', me.username);
});
ipc.serve(
function(){
ipc.server.on(
'app.message.error',
function(data,socket){
ipc.log('got a message from'.debug, (data.id).variable, (data.message).data);
//notfify my "670216"
//bot.sendMessage("670216", data.message);
}
);
ipc.server.on(
'app.message.log',
function(data,socket){
ipc.log('got a message from'.debug, (data.id).variable, (data.message).data);
console.log('got a message from'.debug, (data.id).variable, (data.message).data);
bot.sendMessage("670216", data.message);
}
);
}
);
ipc.server.start();
before(function() {
ipc.serve(function(){
ipc.server.on('message', function(msg) {});
});
ipc.server.start();
});
let count = mult * max_ticket;
let response_count = 0;
let errors = 0;
let slaves_count = 2;
let processes = [];
let cursor = 0;
let time;
ipc.config.id = 'world';
ipc.config.retry = 1500;
ipc.config.silent = true;
ipc.serve(
function () {
console.log('Start!');
for (let i = 0; i < slaves_count; i++) {
let chprocess = child_process.fork(__dirname + '/ipcclient.js');
}
}
);
ipc.server.start();
ipc.server.on(
'app.ready',
function (data, socket) {
ipc.server.emit(
socket,
'app.settings', {
server: 'couchbase://192.168.1.36'
});
}
import ipc from 'node-ipc';
import { SYMBOL, STRING } from 'r6rs';
import { Library } from 'r6rs-async-io';
ipc.config.id = 'r6rsasync';
ipc.config.retry = 1500;
ipc.config.silent = true;
ipc.serve();
export default new Library('remote', {
'remote/start': () => {
ipc.server.start();
/* return () => {
ipc.server.stop();
}; */
},
'remote/listen': (params, callback) => {
if (params == null || (params.type != SYMBOL && params.type != STRING)) {
throw new Error('String or symbol expected');
}
let eventName = params.value;
let listener = (data, socket) => {
if (Array.isArray(data)) {
callback(data);
} else {
callback([]);
}
ipc.server.emit(socket, 'ack');
};
ipc.server.on(eventName, listener);
exports.write = (image, drive, options) => {
const emitter = new EventEmitter()
const argv = cli.getArguments({
entryPoint: rendererUtils.getApplicationEntryPoint(),
image,
device: drive.device,
validateWriteOnSuccess: options.validateWriteOnSuccess,
unmountOnSuccess: options.unmountOnSuccess
})
// There might be multiple Etcher instances running at
// the same time, therefore we must ensure each IPC
// server/client has a different name.
process.env.IPC_SERVER_ID = `etcher-server-${process.pid}`
process.env.IPC_CLIENT_ID = `etcher-client-${process.pid}`
ipc.config.id = process.env.IPC_SERVER_ID
ipc.config.silent = true
ipc.serve()
/**
* @summary Safely terminate the IPC server
* @function
* @private
*
* @example
* terminateServer();
*/
const terminateServer = () => {
// Turns out we need to destroy all sockets for
// the server to actually close. Otherwise, it
// just stops receiving any further connections,
// but remains open if there are active ones.
_.each(ipc.server.sockets, (socket) => {
socket.destroy()
})
ipc.server.stop()
}
/**
* @summary Emit an error to the client
* @function
* @private
*
* @param {Error} error - error
*
* @example
* emitError(new Error('foo bar'));
*/
const emitError = (error) => {
terminateServer()
emitter.emit('error', error)
}
/**
* @summary Bridge robot message to the child writer caller
* @function
* @private
*
* @param {String} message - robot message
*
* @example
* bridgeRobotMessage(robot.buildMessage('foo', {
* bar: 'baz'
* }));
*/
const bridgeRobotMessage = (message) => {
const parsedMessage = _.attempt(() => {
if (robot.isMessage(message)) {
return robot.parseMessage(message)
}
// Don't be so strict. If a message doesn't look like
// a robot message, then make the child writer log it
// for debugging purposes.
return robot.parseMessage(robot.buildMessage(robot.COMMAND.LOG, {
message
}))
})
if (_.isError(parsedMessage)) {
emitError(parsedMessage)
return
}
try {
// These are lighweight accessor methods for
// the properties of the parsed message
const messageCommand = robot.getCommand(parsedMessage)
const messageData = robot.getData(parsedMessage)
// The error object is decomposed by the CLI for serialisation
// purposes. We compose it back to an `Error` here in order
// to provide better encapsulation.
if (messageCommand === robot.COMMAND.ERROR) {
emitError(robot.recomposeErrorMessage(parsedMessage))
} else if (messageCommand === robot.COMMAND.LOG) {
// If the message data is an object and it contains a
// message string then log the message string only.
if (_.isPlainObject(messageData) && _.isString(messageData.message)) {
console.log(messageData.message)
} else {
console.log(messageData)
}
} else {
emitter.emit(messageCommand, messageData)
}
} catch (error) {
emitError(error)
}
}
ipc.server.on('error', emitError)
ipc.server.on('message', bridgeRobotMessage)
ipc.server.on('start', () => {
const child = childProcess.fork(CONSTANTS.WRITER_PROXY_SCRIPT, argv, {
silent: true,
env: process.env
})
child.stdout.on('data', (data) => {
console.info(`WRITER: ${data.toString()}`)
})
child.stderr.on('data', (data) => {
bridgeRobotMessage(data.toString())
// This function causes the `close` event to be emitted
child.kill()
})
child.on('error', emitError)
child.on('close', (code) => {
terminateServer()
if (code === EXIT_CODES.CANCELLED) {
return emitter.emit('done', {
cancelled: true
})
}
// We shouldn't emit the `done` event manually here
// since the writer process will take care of it.
if (code === EXIT_CODES.SUCCESS || code === EXIT_CODES.VALIDATION_ERROR) {
return null
}
return emitError(new Error(`Child process exited with error code: ${code}`))
})
})
ipc.server.start()
return emitter
}