How to cancel a channel job based on an ID in golang

So i have a POST endpoint that creates a job and adds them to a chan. workerJobsChan = make(chan Job, maxQueueSize)

This is how i execute the jobs in the channel (main.go):

for i := 1; i <= maxWorkers; i++ {
	go func(i int) {
		for job := range workerJobsChan {
			ctx, cancel := context.WithCancel(context.Background())
			storeJob(job.Search.ID, cancel)
			job.Execute(ctx, c.db, i)
		}
	}(i)
}

I store the cancel function in a map: cancelJobFuncs = make(map[int]context.CancelFunc).

This is the job function :

func (j *Job) Execute(ctx context.Context, db *sql.DB, workerID int) error {


	for {
		select {
		// Check for cancellation signal
		case <-ctx.Done():
			 if err := ctx.Err(); err != nil {
			 	fmt.Println("Worker", workerID, "error", err)
			 }
			fmt.Println("Worker", workerID, "cancelled")
            return nil

		default:
			fmt.Printf("worker%d: processing %s\n", workerID, j.Search.Query)
			time.Sleep(2 * time.Second)
			fmt.Printf("worker%d: active %s\n", workerID, j.Search.Query)
			time.Sleep(5 * time.Second)
			fmt.Printf("worker%d: completed %s!\n", workerID, j.Search.Query)

		}
	}
}

I cancel a context like this (in a http handler):

cancelJob(search.ID)

But the job just continues to run. I tried a lot of things but i just can't seem to get it working.

Here is one way to state an obvious point: if your code does not check ctx.Done(), it can't know it is cancelled.
(by the way this is yet another rewording of what @JimB wrote in comments to your question).

So when your code in your .Execute(...) method starts executing this block :

    fmt.Printf("worker%d: processing %s\n", workerID, j.Search.Query)
    time.Sleep(2 * time.Second)
    fmt.Printf("worker%d: active %s\n", workerID, j.Search.Query)
    time.Sleep(5 * time.Second)
    fmt.Printf("worker%d: completed %s!\n", workerID, j.Search.Query)

it will go to the end of this block (7 seconds). There is no instruction telling it to stop on cancellation.

If you want your function to be able to detect cancellation during the "Sleep" instructions, you have to change your code.

Here is one example of how to do that with your example:

func (j *Job) Execute(ctx context.Context, db *sql.DB, workerID int) error {


    for {
        fmt.Printf("worker%d: processing %s\n", workerID, j.Search.Query)

        // rewrite time.Sleep() with time.After() so that it can be composed
        // in a select statement:
        select {
        case <-ctx.Done():
            fmt.Println("Worker", workerID, "cancelled")
            return nil
        case <-time.After(2 * time.Second):
            // keep going
        }

        fmt.Printf("worker%d: active %s\n", workerID, j.Search.Query)

        select {
        case <-ctx.Done():
            fmt.Println("Worker", workerID, "cancelled")
            return nil
        case <-time.After(5 * time.Second):
            // keep going
        }

        fmt.Printf("worker%d: completed %s!\n", workerID, j.Search.Query)
    }
}

https://go.dev/play/p/Tlpggug2AUB

I guess your actual code doesn't have time.Sleep() instructions but rather processSearch(...) or doQuery(...) or ...

If you need these functions to be cancellable during their execution, you will need to somehow pass your cancellation context to them and have them check the cancellation some way or some other.

One way to "pass the context" is obviously to add it to the arguments of said functions :

processSearch(ctx, ...)
doQuery(ctx, ...)

but depending on your existing code, some arguments may already have a built-in way to be cancelled.
As an illustration:

// an http.Request carries a context:
func doQuery(req *http.Request, ....) {
    ...
}

// at call site:
    ...
    req := http.NewRequestWithContext(ctx, "GET", "https://some.other.service/", nil)
    doQuery(req, ...)