docs: function reserveWorker(workerType, callback) {
          var debug = false,
              execArgv = process.execArgv.filter(function (arg) {
                  if (arg.indexOf('--debug-brk') === 0) {
                      debug = '--debug-brk';
                  } else if (arg.indexOf('--debug') === 0) {
                      debug = '--debug';
                  } else if (arg.indexOf('--inspect-brk') === 0) {
                      debug = '--inspect-brk';
                  } else if (arg.indexOf('--inspect') === 0) {
                      debug = '--inspect';
                  } else {
                      return true;
                  }
  
                  return false;
              }),
              childProcess;
  
          // http://stackoverflow.com/questions/16840623/how-to-debug-node-js-child-forked-process
          // For some reason --debug-brk is given here..
          if (debug) {
              execArgv.push(debug + '=' + debugPort.toString());
              logger.info('Child debug port: ' + debugPort.toString());
              debugPort += 2;
          }
  
          logger.debug('execArgv for main process', process.execArgv);
          logger.debug('execArgv for new child process', execArgv);
  
          childProcess = Child.fork(CONNECTED_WORKER_JS, [], {execArgv: execArgv});
  
          _workers[childProcess.pid] = {
              childProcess: childProcess,
              state: CONSTANTS.workerStates.initializing,
              type: workerType,
              cb: null
          };
  
          logger.debug('workerPid forked ' + childProcess.pid);
          childProcess.on('message', function (msg) {
              messageHandling(msg);
  
              // FIXME: Do we really need the "initialize" in addition to "initialized"?
              // FIXME: Why couldn't the worker start the initializing at spawn? (It can load the gmeConfig itself)
              if (msg.type === CONSTANTS.msgTypes.initialized && typeof callback === 'function') {
                  callback();
                  callback = null;
              }
          });
  
          childProcess.on('exit', function (code, signal) {
              logger.debug('worker has exited: ' + childProcess.pid);
              // When killing child-process the code is undefined and the signal SIGINT.
              if (code !== 0 && signal !== 'SIGINT') {
                  logger.warn('worker ' + childProcess.pid + ' has exited abnormally with code ' + code +
                      ', signal', signal);
                  if (typeof callback === 'function') {
                      callback(new Error('worker ' + childProcess.pid + ' exited abnormally with code ' + code));
                  }
              } else {
                  logger.debug('worker ' + childProcess.pid + ' was terminated.');
              }
  
              if (workerType === CONSTANTS.workerTypes.connected) {
                  self.connectedWorkerId = null;
              }
  
              delete _workers[childProcess.pid];
              reserveWorker(workerType);
          });
      }