knowre-dev/swint-fork

Process behaviour(fork, common/separate execution of code chunk, etc.) manager for Swint

swint-fork's Issues

Fork is not working when after process.nextTick

Issue is when "main process" send message to cluster.fork is called by async.
so worker need to send message "I am ready".
I think there is a API for this which is written by node.js but I can' find.
[https://nodejs.org/api/cluster.html]

please try this, I tested this code.

_.start = function() {
    var that = this;

    if (cluster.isMaster) {
        if (this.options.operator !== null) {
            this.options.operator.start(function() {
                that.startPreProcess();
            });
        } else {
            this.startPreProcess();
        }
    } else if (cluster.isWorker) {
        process.send({
            type: 'workerStart'
        })
    }

    process.on('message', function(msg) {
        switch (msg.type) {
            case 'control':
                switch (msg.data) {
                    case 'healthCheck':
                        that.monitor(function(err, res) {
                            if (err) {
                                print(4, err);
                                process.exit(-1);
                                return;
                            }
                            process.emit('controlEnd', null, res);
                        });
                        break;
                    case 'softReset':
                        that.resetPost(function(err) {
                            if (err) {
                                print(4, err);
                                process.exit(-1);
                                return;
                            }
                            process.emit('controlEnd');
                        });
                        break;
                    case 'hardReset':
                        that.resetAll(function(err) {
                            if (err) {
                                print(4, err);
                                process.exit(-1);
                                return;
                            }
                            process.emit('controlEnd');
                        });
                        break;
                }
                break;
            case 'data':
                that.options.postProcess(that, msg.data, function() {
                    process.send({
                        type: 'complete'
                    });
                });
                break;
        }
    });
};


_.createWorker = function(sharedData) {
    var that = this,
        worker = cluster.fork();

    worker.on('message', function(msg) {
        if (msg.type === 'complete') {
            that.evt.emit('complete');
        } else if (msg.type === 'workerStart') {
            worker.send({
                type: 'data',
                data: sharedData
            });
        }
    });

    return worker;
};

blocking event when soft reset is fired

case 'softReset':
    if(!that.resetPostRun){
        that.resetPost(function(err) {
            if (err) {
                print(4, err);
                process.exit(-1);
                return;
            }
            process.emit('controlEnd');
        }); 
    }

    break;

_.resetPost = function(callback) {
    var that = this,
        workers = [];

    this.resetPostRun = true;

    for (var id in cluster.workers) {
        var worker = cluster.workers[id];

        workers.push(worker);
    }

    async.series(
        workers.map(function(v) {
            return function(cb) {
                that.evt.once('complete', function() {
                    cb(null, true);
                });
                v.kill();
            };
        }),
        function(err) {
            callback(err, true);
            that.resetPostRun = false;
        }
    );
};