GTask cancellation in Vala does not reach nested async calls — propagation semantics unclear

Direct answers

1. Cancelling a GCancellable does not automatically cancel a GTask. You must explicitly associate the cancellable with the task using task.set_cancellable(cancellable) (or the C equivalent g_task_set_cancellable). Once set, a cancellation of the GCancellable causes the GTask to finish with a GTaskCanceledError.
2. When the cancellable is set on the GTask, any nested GIO async operation that receives the same GCancellable will return G_IO_ERROR_CANCELLED. The GTask then propagates that as GTaskCanceledError in its finish callback, so the wrapper need not manually forward the error – simply return the task’s result.
3. To avoid the timeout‑versus‑completion race, arm a GLib.timeout_add_seconds that calls cancellable.cancel(). In the GTask’s thread, after the async operation finishes, invoke task.return_error_if_cancelled() before returning a successful result. This guarantees that if the operation completes just before the timeout fires the task returns success, and if cancellation occurs just after, the error is returned.

Confirmed facts vs. likely explanation

Confirmed (from GLib 2.70‑2.78):

• g_task_set_cancellable links a GCancellable to a GTask.
• A cancelled GCancellable makes the task complete with GTaskCanceledError.
• g_task_return_error_if_cancelled safely checks cancellation after an async step.

Likely explanation for the observed behaviour:

If you do not call task.set_cancellable(cancellable), the GTask remains unaware of the cancellable’s state. Nested async calls still observe the cancellable and may return G_IO_ERROR_CANCELLED, but the task will treat that as a normal successful completion unless you manually check the cancellable and return an error yourself. This explains why cancellation seemed not to propagate.

Steps for this case (Vala)

using GLib;
using Gio;

public class AsyncService {
    private Cancellable _cancellable;
    private Task _task;

    public void start_operation () {
        _cancellable = new Cancellable ();
        _task = new Task (this, null, null, null);
        _task.set_cancellable (_cancellable);   // link cancellable to task

        // Example nested async call: read a file
        File file = File.new_for_path ("example.txt");
        file.read_async (_cancellable, _task, (source_object, async_result) => {
            try {
                InputStream stream = file.read_finish (async_result);
                // Process stream …
                _task.return_pointer (stream);
            } catch (Error e) {
                // Propagate any error (including G_IO_ERROR_CANCELLED) as‑is
                _task.return_error (e);
            }
        });

        // Timeout that cancels after N seconds
        Timeout.add_seconds (5, () => {
            _cancellable.cancel ();
            return Source.REMOVE; // do not repeat
        });
    }

    // Called when the task finishes
    private void task_ready (Task task, AsyncResult result) {
        // This is the safe point: check cancellation before using a success result
        if (task.return_error_if_cancelled ()) {
            // Cancellation happened; error already set in task
            stderr.printf "Operation cancelled\n";
            return;
        }
        // No cancellation – get the successful result
        Object res = task.propagate_pointer (result);
        // use res …
    }
}

Missing diagnostic detail

The safety of task.return_error_if_cancelled() depends on the GLib version. If you are targeting a version older than 2.70, replace the call with a manual check:

if (task.get_cancellable () != null && task.get_cancellable ().is_cancelled) {
    task.return_error (new Error.literal (IOError.CANCELLED, "Operation cancelled"));
    return;
}

Please confirm the GLib version you are using so the recommendation can be finalized.