Forked subtasks should be cancelled when parent is cancelled (?)

Imagine I have Task1 that forks Task2 that forks Task3

Now I cancel Task1, which cause a SagaCancellationException inside Task1. But by default seems forked tasks Task2 and Task3 are not cancelled and can stay alive even if the parent Task1 is cancelled.

Is it supposed to be handled by redux-saga, or should I propagate the cancellation myself to forked subtasks?

With this code I successfully propagate the cancellation to subtasks but it requires additional boilerplate:

export default function* task1() {
  let subtasks = [];
  try {
    subtasks.push(yield fork(task2));
    subtasks.push(yield fork(task3));
    while ( true ) {
      yield take("SOME_EVENT_THAT_RESTART_SUBTASKS");
      yield subtasks.map(cancel);
      subtasks = [];
      subtasks.push(yield fork(task2));
      subtasks.push(yield fork(task3));
    }
  }
  catch(e) {
    if ( e instanceof SagaCancellationException ) yield subtasks.map(cancel);
    else throw e;
  }
}

[yelouafi]

I’m thinking of integrating this into the next release.

The mental model is that a parent + forked children represent a whole unit: a tree with multiple execution paths.

Here is what I propose

1. Cancellation of parent automatically triggers cancellation of all currently active forked tasks (we cancel the whole execution tree)
2. A parent terminates when :
   1. its own body terminates and
   2. forked (and attached) tasks terminate (the whole execution tree must terminate)
3. Provide an additional setting to fork detached children (the default for children is to be attached). The cases for this IMO should be pretty rare so rather than create another effect, W’ll just provide this as a config option on the fork itself, something like : yield fork({fn, detached: true}, ...args) or yield fork(fn, ...args).detached

(1) would handle common client side scenarios: when an UI page is unloaded we’d typically like to cancel all the tasks related to that page

(2) would handle server side scenario: when we do render on the server, w’d like to wait for all triggered tasks to terminate before sending the HTML to the client (see #149)

(3) would provide an alternative for other cases

[yelouafi]

@slorber In this example you fork tasks then immediately join them

function* handleStamplesPaginationAndFiltering(model) {
  const subtasks = [];
  try {
    subtasks.push(yield fork(stamplePaginateSaga,model))
    subtasks.push(yield fork(stampleFilterUpdatesWatcher,model))
    yield subtasks.map(join)
  }
  catch(e) {
    if ( e instanceof SagaCancellationException ) {
      yield subtasks.map(cancel);
    }
  }
}

why not simply use

function* handleStamplesPaginationAndFiltering(model) {
  yield [
    call(stamplePaginateSaga,model),
    call(stampleFilterUpdatesWatcher,model)
  ]
}

if handleStamplesPaginationAndFiltering is cancelled from a parent Saga, then the cancellation would propagate automatically to the current effect which is the parallel yield [...]. Parallel effect cancellation means cancellation of all sub-effects