Add oncreated worker

[GwiYeong]

I wanted to add a cpu limit for the worker process created when utilizing workerpool in process mode.
However, the current callback doesn't know the pid of the created worker.

This PR adds a callback to get the information of the created worker after the worker is created.
I added a callback called onCreatedWorker, which is passed the currently created WorkerHandler directly.
If it's a process worker, I can get the created pid via worker.worker.pid.
The pid can then be used to limit resources, such as cpu limit.

For cpulimit worker, I add an example.

[josdejong]

Thanks @GwiYeong. Thinking aloud here: can we already achieve this already by using events? Would it be possible to let a worker send it's pid to the main process via workerpool.workerEmit?

[GwiYeong]

@josdejong Thank you for responding.
I just wonder that is there any way to receive messages from a worker that are passed to the workerpool.workerEmit function without calling pool.exec?
In case of cpu limit, it should be called only once per worker, and if the worker is terminated and recreated, it needs to be executed again.
Is there a way to send a message to workerpool.workerEmit as soon as the worker is created, depending on the life cycle of the worker, and have the main process receive and handle it?
If it is possible, can you give me some example code to achieve it?

[josdejong]

You can indeed only send/receive workerpool.workerEmit whilst executing a task. But a new worker will only be created when there is a task to execute. You can do do something like this:

// myWorker.js
var workerpool = require('workerpool')

var initialized = false

function wrapperSendPidOnce(fn) {
  return (...args) => {
    if (!initialized) {
      initialized = true

      workerpool.workerEmit({ type: 'created', pid: process.pid })
    }

    return fn(...args)
  }
}

function add(a, b) {
  return a + b
}

function multiply(a, b) {
  return a * b
}

workerpool.worker({
  add: wrapperSendPidOnce(add),
  multiply: wrapperSendPidOnce(multiply)
})

And then use the worker like so:

// main.js
var workerpool = require('workerpool')

var pool = workerpool.pool(__dirname + '/myWorker.js')

function execWithEventListener(method, args) {
  function handleEvent(event) {
    console.log('Event: ', event)
  }

  return pool.exec(method, args, { on: handleEvent })
}

async function run() {
  console.log(await execWithEventListener('add', [2, 3]))
  console.log(await execWithEventListener('add', [7, 2]))
}

run()
  .catch(function (err) {
    console.error(err)
  })
  .finally(function () {
    pool.terminate()
  })

Running this example wil output:

Event:  { type: 'created', pid: 26312 }
5
9

Would that address your case?

[GwiYeong]

@josdejong yes. I understand what you are saying.
However, It would be easier if we had a lifecycle hook like onCreatedWorker, but it seems a bit complicated to determine whether it's the first time or not.
If a worker's functions should always be executed by calling
How about adding a function like pool.broadcast that triggers all the worker's functions and handles all workers emit?
If so, we could separate functions in the worker that return only the pid and for action.

[joshLong145]

This is an interesting idea, I agree that since there is an onCreateWorker an onCreatedWorker makes sense. As it extends the life cycle model and does not require explicit implementation within worker contexts to implement. However, if we are to add a onCreatedWorker perhaps the life cycle as a whole should be thought of and perhaps we should also add onTerminatedWorker to complete cases of pre and post termination / creation of workers.

it seems a bit complicated to determine whether it's the first time or not

What do you mean by first time?

[GwiYeong]

@joshLong145

it seems a bit complicated to determine whether it's the first time or not
What do you mean by first time?

I mean the solution that @josdejong gave to me achieve my goal, but it seems a bit complicated.
wrapperSendPidOnce can always be executed only after the worker's function has been executed, so this is a slightly different timing than when the worker is created.
If I want to continuously monitor a worker process after it is created, I can't do that until the worker's function is called once (I don't even know the worker's PID.). I always need to run the worker's function after it is created, and also I can't specify what worker to run, I can't determine the timing of when a newly created worker can be monitored.

[josdejong]

Thanks @GwiYeong, and sorry for the late reply.

I've been thinking about it and you're right, the workaround that I posted is quite complicated. Also, adding support for an onCreatedWorker option is only a few lines of code, so not much to worry there. So, let's go for it 😄.

I made a couple of inline comments, can you have a look at those?

[josdejong]

If we pass the WorkerHandler to onCreatedWorker, we pass a fully undocumented class. How about passing the Worker instead (ie. this.onCreatedWorker(worker.worker)?

[josdejong]

Thanks, this is a nice example!

Can you please change the indentation to 2 spaces? (I know, I should set up a linter)

[josdejong]

Can you write a unit test for the new option please?

[josdejong]

@GwiYeong did you see my last reply?