Cancellation: AbortController and context

import { setTimeout as sleep } from "node:timers/promises";
 
const controller = new AbortController();
const { signal } = controller;
 
signal.addEventListener("abort", () => {
  console.log("abort event:", signal.reason.message); // → abort event: user cancelled
}, { once: true });
 
// cancel after 100ms, while the work needs a full second
setTimeout(() => controller.abort(new Error("user cancelled")), 100);
 
try {
  await sleep(1000, "done", { signal });
} catch (err) {
  console.log(err.name);          // → AbortError
  console.log(err.cause.message); // → user cancelled
}
 
console.log(signal.aborted);        // → true
console.log(signal.reason.message); // → user cancelled

package main
 
import (
	"context"
	"errors"
	"fmt"
	"time"
)
 
// sleep waits for d, or returns early when ctx is cancelled — like
// setTimeout from node:timers/promises with { signal }.
func sleep(ctx context.Context, d time.Duration) error {
	timer := time.NewTimer(d)
	defer timer.Stop()
 
	select {
	case <-timer.C:
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}
 
func main() {
	ctx, cancel := context.WithCancelCause(context.Background())
	defer cancel(nil) // always call cancel to release the context's resources
 
	// cancel after 100ms, while the work needs a full second
	time.AfterFunc(100*time.Millisecond, func() {
		cancel(errors.New("user cancelled"))
	})
 
	if err := sleep(ctx, 1*time.Second); err != nil {
		fmt.Println(err)                              // → context canceled
		fmt.Println(errors.Is(err, context.Canceled)) // → true
		fmt.Println(context.Cause(ctx))               // → user cancelled
	}
}

import { setTimeout as sleep } from "node:timers/promises";
 
const signal = AbortSignal.timeout(100); // aborts itself after 100ms
 
try {
  await sleep(1000, "done", { signal });
} catch (err) {
  console.log(err.name);           // → AbortError
  console.log(err.cause.name);     // → TimeoutError
  console.log(signal.reason.name); // → TimeoutError
}

package main
 
import (
	"context"
	"errors"
	"fmt"
	"time"
)
 
func sleep(ctx context.Context, d time.Duration) error {
	timer := time.NewTimer(d)
	defer timer.Stop()
 
	select {
	case <-timer.C:
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}
 
func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) // cancels itself after 100ms
	defer cancel()
 
	err := sleep(ctx, 1*time.Second)
	fmt.Println(err)                                      // → context deadline exceeded
	fmt.Println(errors.Is(err, context.DeadlineExceeded)) // → true
	fmt.Println(errors.Is(err, context.Canceled))         // → false
}

import { setTimeout as sleep } from "node:timers/promises";
 
async function download(userDelay) {
  const user = new AbortController();
  // abort when the user cancels OR after 200ms, whichever comes first
  const signal = AbortSignal.any([user.signal, AbortSignal.timeout(200)]);
 
  const timer = setTimeout(() => user.abort(new Error("user cancelled")), userDelay);
  try {
    return await sleep(1000, "done", { signal });
  } catch {
    return `aborted: ${signal.reason.name}: ${signal.reason.message}`;
  } finally {
    clearTimeout(timer);
  }
}
 
console.log(await download(50));  // → aborted: Error: user cancelled
console.log(await download(500)); // → aborted: TimeoutError: The operation was aborted due to timeout

package main
 
import (
	"context"
	"errors"
	"fmt"
	"time"
)
 
func sleep(ctx context.Context, d time.Duration) error {
	timer := time.NewTimer(d)
	defer timer.Stop()
 
	select {
	case <-timer.C:
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}
 
func download(userDelay time.Duration) string {
	user, cancelUser := context.WithCancelCause(context.Background())
	defer cancelUser(nil)
 
	// child context: cancelled when its parent (user) is cancelled OR after 200ms
	ctx, cancel := context.WithTimeout(user, 200*time.Millisecond)
	defer cancel()
 
	timer := time.AfterFunc(userDelay, func() { cancelUser(errors.New("user cancelled")) })
	defer timer.Stop()
 
	if err := sleep(ctx, 1*time.Second); err != nil {
		return fmt.Sprint("aborted: ", context.Cause(ctx))
	}
	return "done"
}
 
func main() {
	fmt.Println(download(50 * time.Millisecond))  // → aborted: user cancelled
	fmt.Println(download(500 * time.Millisecond)) // → aborted: context deadline exceeded
 
	// two contexts with NO parent-child relationship (e.g. server shutdown
	// and a single request): link them with context.AfterFunc
	shutdown, stopServer := context.WithCancelCause(context.Background())
	request, cancelRequest := context.WithCancelCause(context.Background())
	defer cancelRequest(nil)
 
	stop := context.AfterFunc(shutdown, func() {
		cancelRequest(context.Cause(shutdown))
	})
	defer stop()
 
	stopServer(errors.New("server shutting down"))
	<-request.Done()
	fmt.Println(context.Cause(request)) // → server shutting down
}

import { setTimeout as sleep } from "node:timers/promises";
 
async function processItems(items, signal) {
  for (const item of items) {
    signal.throwIfAborted(); // throws signal.reason if already aborted
    await sleep(50);         // simulate processing one item
    console.log("processed", item);
  }
}
 
try {
  await processItems([1, 2, 3, 4, 5], AbortSignal.timeout(125));
} catch (err) {
  console.log("stopped:", err.name);
}
// → processed 1
// → processed 2
// → processed 3
// → stopped: TimeoutError

package main
 
import (
	"context"
	"fmt"
	"time"
)
 
func processItems(ctx context.Context, items []int) error {
	for _, item := range items {
		if err := ctx.Err(); err != nil { // non-nil once ctx is cancelled, ~ throwIfAborted()
			return err
		}
		time.Sleep(50 * time.Millisecond) // simulate processing one item
		fmt.Println("processed", item)
	}
	return nil
}
 
func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 125*time.Millisecond)
	defer cancel()
 
	if err := processItems(ctx, []int{1, 2, 3, 4, 5}); err != nil {
		fmt.Println("stopped:", err)
	}
}
 
// → processed 1
// → processed 2
// → processed 3
// → stopped: context deadline exceeded