CODEWITHSUNDEEP
javascript
Joji Ddan
Joji Ddan

Reputation: 61

child-process on callback access global object nodejs

process npm module in Node and accessing another file that does computations for me. The problem is that when on. message event/callback I am not sure what it is actually but there i am trying to access global variable and it says it is undefined. If somebody have can have a good explained solution.

        _addBlock(newBlock)
        {
                newBlock.previousHash = this._getLatestBlock().hash;
                 var child = 
      childProcess.fork('C:\\Users\\Yoana\\WebstormProjects\\ChildProcess\\mining1.js'
               );
               child.on('message', function(newBlock)
               {
                // Receive results from child process
                console.log('received: ' , newBlock);
                this.chain.push(newBlock);
            })

            // Send child process some work
            child.send(newBlock);

    }

It says that this.chain.push is undefined. The method _addBlock is part of a class Blockchain and this.chain is globally accessible.

Upvotes: 0

Views: 681

Answers (1)

loretoparisi
loretoparisi

Reputation: 16301

I'm not sure which model are you using i.e. node.js master/worker architecture with cluster native module or child_process native module with message passing etc., by the way despite of sharing globals it is not recommended (how to handle the shared memory? how to handle protected memory?), you can do in this way:

global.GlobalBotFactory = function() {
        if (typeof(instance)=="undefined")
            instance = new MyClass(options);
        return instance;
    }

and then you can reference it in other files like

this.instance = GlobalBotFactory(); // the shared factory instance

But this approach, despite it works, could led to several issues like

  • concurrent variable modification
  • shared memory corruption
  • reader/writer problem

etc. so I strongly suggest to follow a node cluster module with master/worker approach and then message passing:

/// node clustering
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) { // master node
    var masterConfig=require('./config/masterconfig.json');

    // Fork workers.
    var maxCPUs = masterConfig.cluster.worker.num;
    maxCPUs=(maxCPUs>=numCPUs)?numCPUs:maxCPUs;

    for (let i = 0; i < maxCPUs; i++) {
        const worker=cluster.fork();
    }

    var MasterNode=require('./lib/master');
    var master= new MasterNode(masterConfig);
    master.start()
    .then(done=> {
        console.log(`Master ${process.pid} running on ${masterConfig.pubsub.node}`);
    })
    .catch(error=> {
        console.error(`Master ${process.pid} error`,error);
    });
}
else if (cluster.isWorker) { // worker node
    var workerConfig=require('./config/workerconfig.json');
    var WorkerNode=require('./lib/worker');
    var worker= new WorkerNode(workerConfig);
    worker.start()
    .then(done=> {
        console.log(`Worker ${process.pid} running on ${workerConfig.pubsub.node}`);
    })
    .catch(error=> {
        console.error(`Worker ${process.pid} error`,error);
    });
}

For the message passing part take care since you will deal with async forked process, and in node.js there is not guarantee that a message will be delivered, so you need a ack logic or you can use a pubsub approach (Redis will offer this for free, please check here), by the way here you are

for (var i = 0; i < 2; i++) {
    var worker = cluster.fork();

    // Receive messages from this worker and handle them in the master process.
    worker.on('message', function(msg) {
      console.log('Master ' + process.pid + ' received message from worker ' + this.pid + '.', msg);
    });

    // Send a message from the master process to the worker.
    worker.send({msgFromMaster: 'This is from master ' + process.pid + ' to worker ' + worker.pid + '.'});
  }

this will fork the workers and listen for incoming messages from the master or other workers. But please keep in mind that the delivery logic it's up to you. See here for more info about subprocess.send.

Upvotes: 2

Related Questions