Is errgroup in golang restrictive in its usage?

I am learning golang and am confused about errgroup package when used with context.
Here is my simple code:

  package main
  
  import (
  	"context"
  	"errors"
  	"fmt"
  	"time"
  
  	"golang.org/x/sync/errgroup"
  )
  
  func main() {
  	fmt.Println("..................")
  	ctx := context.Background()
  	group, ctx := errgroup.WithContext(ctx)
  	ctx, cancel := context.WithCancel(ctx)
  
  	group.Go(func() error {
  		//return errors.New("Error 1")
  		time.Sleep(8 * time.Second)
  		fmt.Println("Sleep 1 ended..................")
  		cancel()
  		return errors.New("Error 1")
  	})
  
  	group.Go(func() error {
  		//return errors.New("Error 1")
  		time.Sleep(2 * time.Second)
  		fmt.Println("Sleep 2 ended..................")
  		cancel()
  		return errors.New("Error 2")
  	})
  
  	err := group.Wait()
  
  	if err != nil {
  		fmt.Println("Error: ", err)
  	}
  	fmt.Println("..................")
  
  }

The output, as expected is:

   ..................
   Sleep 2 ended..................
   Sleep 1 ended..................
   Error:  Error 2
   ..................

group.Wait() "blocks until all function calls from the Go method have returned, then returns the first non-nil error (if any) from them."
Questions:

1. What if I want to use errgroup but want to wait until the
   context shared by all the Go methods is cancelled or all
   function calls from the Go method have returned?
2. What if I want to use errgroup but want to wait until one of the Go method has returned error, which method will cancel the context and not wait for all to finish?

Somehow I feel that errgroup package is too restrictive in its use. What am I missing?

It seems like this cannot be achieved just by using errGroup itself.

1. Maybe waitGroup can be used here.
2. Maybe call cancel only if error happened. Or use error channel and wait till first error.

This implementation answers both of your questions:

package main

import (
	"context"
	"errors"
	"fmt"
	"time"

	"golang.org/x/sync/errgroup"
)

func main() {
	ctx := context.Background()

	g, gtx := errgroup.WithContext(ctx)

	g.Go(func() error {
		select {
		case <-time.After(8 * time.Second):
			fmt.Println("Sleep 1 ended..................")
			return errors.New("Error 1")
		case <-gtx.Done():
			return gtx.Err()
		}
	})

	g.Go(func() error {
		select {
		case <-time.After(2 * time.Second):
			fmt.Println("Sleep 2 ended..................")
			return errors.New("Error 2")
		case <-gtx.Done():
			return gtx.Err()
		}
	})

	err := g.Wait()
	if err != nil {
		fmt.Println("Error: ", err)
	}
	fmt.Println("..................")
}

It will print the following:

   ..................
   Sleep 2 ended..................
   Error:  Error 2
   ..................

Returning an error cancels the context implicitly. You need to wait for ctx.Done() to abandon the execution of the go routines explicitly.

Using time.Sleep might be considered as an anti-pattern, as it doesn't acknowledge context cancelation. In many cases you want to use:

select {
case <-time.After(x):
case <-ctx.Done():
return ctx.Err()
}