Invocations to `getProcessTree`/`getProcessList` with different flags are confused

[rwe]

Related to (but neither caused nor fixed by): #46.

Filing because I noticed the issue by inspection, not from a particular known defect.

Basically, because of the gating to native.getProcessList, if one invocation is called with one set of flags, and then with another is made before the first returns, the second invocation will get results from the wrong flags. This could confuse code in cases where e.g. you requested memory info and occasionally do not receive it seemingly randomly.

Instead, there should probably be logic along the lines of:

• different queues for different sets of flags
• on completion of an invocation, callbacks run for all queues with fully-satisfied flags
• if there are queued requests for additional flags, re-run with those flags immediately

Or something like that. Or just always run with all the flags, unless there's a performance reason not to.

[Tyriar]

Good observation, I guess a simple change to queues: Map<flags, RequestCallback[]> would fix it?

[rwe]

That could work. Importantly, when the request completes, there needs to be a check whether another request should be immediately initiated.

Since (currently, at least) the flags are all additive—i.e. if you ask for fewer flags, it's ok to get more info back—you can get away with at most a single inactive callback queue. Either add to the active request's queue if those flags are compatible, or OR the flags for the next request and enqueue there.

Something like (super messy code below):

const state: {
  active?: { readonly flags: ProcessDataFlag, callbacks: RequestQueue },
  next?: { flags: ProcessDataFlag, callbacks: RequestQueue },
} = {};

export function getRawProcessList(flags: ProcessDataFlag, callback: (processList: IProcessInfo[]) => void): void {
  // Shift the "next" group to become active, discarding the current "active" group.
  function activateNextGroup() {
    ([state.active, state.next] = [state.next, undefined]);
    return state.active;
  }

  function run({ flags, callbacks }: { readonly flags: ProcessDataFlag, callbacks: RequestQueue }) {
    native.getProcessList((processList: IProcessInfo[]) => {
      while (callbacks.length) {
        callbacks.splice(0).forEach(cb => cb(processList));
      }

      // We've finished this request: is there another callback group pending?
      // Activate it immediately (so that new callbacks are added to its queue), and initiate it on the next tick.
      const next = activateNextGroup();
      if (next) {
        process.nextTick(() => run(next));
      }
    }, flags);
  }

  // If there's an active request with compatible flags, just use that result when it comes in.
  if (state.active && ((state.active.flags & flags) === flags)) {
    state.active.callbacks.push(callback);
  } else {
    // Either the active request was incompatible, or there wasn't one active.
    // Add to the requirements and callbacks of the next batch, which may be triggered immediately.
    const next = (state.next ??= { flags: ProcessDataFlag.None, callbacks: [] });
    next.flags |= flags;
    next.callbacks.push(callback);
  }

  const startGroup = state.active ? undefined : activateNextGroup();
  if (startGroup) {
    run(startGroup);
  }
}