Context-Cancelable Worker Pool with First-Error Cancellation

package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"sync"
	"time"
)

type Job func(context.Context) error

func runWorkerPool(ctx context.Context, workerCount int, jobs []Job) error {
	if workerCount < 1 {
		return fmt.Errorf("workerCount must be >= 1")
	}
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	jobCh := make(chan Job)
	errCh := make(chan error, 1)

	var wg sync.WaitGroup
	worker := func(id int) {
		defer wg.Done()
		for job := range jobCh {
			if ctx.Err() != nil {
				return
			}
			if err := job(ctx); err != nil {
				select {
				case errCh <- err:
				default:
				}
				cancel()
				return
			}
		}
	}

	wg.Add(workerCount)
	for i := 0; i < workerCount; i++ {
		go worker(i + 1)
	}

	go func() {
		defer close(jobCh)
		for _, job := range jobs {
			select {
			case <-ctx.Done():
				return
			case jobCh <- job:
			}
		}
	}()

	wg.Wait()
	close(errCh)

	if err := <-errCh; err != nil {
		return err
	}
	return ctx.Err()
}

func main() {
	jobs := []Job{
		func(ctx context.Context) error {
			time.Sleep(150 * time.Millisecond)
			log.Printf("job 1 done")
			return nil
		},
		func(ctx context.Context) error {
			time.Sleep(200 * time.Millisecond)
			return errors.New("job 2 failed")
		},
		func(ctx context.Context) error {
			time.Sleep(500 * time.Millisecond)
			log.Printf("job 3 done")
			return nil
		},
	}

	err := runWorkerPool(context.Background(), 3, jobs)
	if err != nil {
		log.Printf("worker pool finished with error: %v", err)
		return
	}
	log.Printf("all jobs finished successfully")
}