Go workerpool implementation using errgroup, goroutines stuck

I have implemented a workerpool pattern using errgroup, so that error in any goroutines can be caught. Here is my detail:

    jobs := make(chan UsersInfo, totalUsers)
	results := make(chan UsersInfo, totalUsers)

	g, gCtx := errgroup.WithContext(ctx)

	for i := 1; i <= 4; i++ {
		g.Go(func() error {
			err := workerUser(gCtx, jobs, results)
			if err != nil {
				return err
			}
			return nil
		})
	}

	for _, user := range usersResp {
		jobs <- user
	}
	close(jobs)

    var usersArray []UsersInfo
	for  i := 1; i <= totalUsers; i++ {
        r := <-results
		usersArray = append(usersArray, r)
	}

	if err := g.Wait(); err != nil {
		return nil, err
	}

Then the worker function implemented like this:

func workerUser(ctx context.Context, jobs <-chan UsersInfo, results chan<- UsersInfo) error {
  for {
	select {
	case <-ctx.Done():
		return ctx.Err()
	case user, _ := <-jobs:
		userInfo, err := CallUserAPI(ctx, user)
		if err != nil {
			return err
		}
		results <- userInfo
	}
 }
}

The CallUserAPI return 403 Forbidden error which should invoke g.wait() and should stop all goroutines instantly when there is non-nil error. But this is not the case here, g.wait() is never called.

There are a couple of problems:

• The loop

    for  i := 1; i <= totalUsers; i++ {
        r := <-results
        usersArray = append(usersArray, r)
    }
  

  waits for the workers to send a result for each user. That will not happen when CallUserAPI returns an error.

• The worker does not handle the case where jobs is closed.

Here's code that fixes both of these problems:

Declare a type that specifies the user to work on and where to put the result:

type job struct {
	user UsersInfo
	result *UsersInfo
}

Modify the worker to use this new type. Also, modify the worker to exit when jobs is closed.

func workerUser(ctx context.Context, jobs <-chan job) error {
	for {
		select {
		case <-ctx.Done():
			return ctx.Err()
		case job, ok := <-jobs:
			if !ok {
				// No more jobs, exit.
				return nil
			}
			var err error
			*job.result, err = CallUserAPI(ctx, job.user)
			if err != nil {
				return err
			}
		}
	}
}

Glue it all together in the main goroutine:

jobs := make(chan UsersInfo, totalUsers)
usersArray := make([]UsersInfo, totalUsers)
g, gCtx := errgroup.WithContext(ctx)

// Start the workers.
for i := 1; i <= 4; i++ {
	g.Go(func() error {
		return workerUser(gCtx, jobs)
	})
}

// Feed the workers.  
for i, user := range usersResp {
	jobs <- job{user: user, result: &usersArray[i]}
}

// Close the channel to indicate that no more jobs will be sent.
// The workers exit via the `if !ok { return nil }` statement.
close(jobs)

// Wait for the workers to complete.
if err := g.Wait(); err != nil {
	return nil, err
}

// It is now safe to access the results in usersArray.