Go ctx.Done() never firing in select statement

I have the following code for a module I'm developing and I'm not sure why the provider.Shutdown() function is never called when I called .Stop()

The main process does stop but I'm confused why this doesn't work?

package pluto

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

type Client struct {
    name string
    providers []Provider
    cancelCtxFunc context.CancelFunc
}

func NewClient(name string) *Client {
    return &Client{name: name}
}

func (c *Client) Start(blocking bool) {
    log.Println(fmt.Sprintf("Starting the %s service", c.name))

    ctx, cancel := context.WithCancel(context.Background())
    c.cancelCtxFunc = cancel // assign for later use

    var wg sync.WaitGroup

    for _, p := range c.providers {
        wg.Add(1)

        provider := p
        go func() {
            provider.Setup()

            select {
                case <-ctx.Done():
                    // THIS IS NEVER CALLED?!??!
                    provider.Shutdown()
                    return
                default:
                    provider.Run(ctx)
            }
        }()
    }

    if blocking {
        wg.Wait()
    }
}

func (c *Client) RegisterProvider(p Provider) {
    c.providers = append(c.providers, p)
}

func (c *Client) Stop() {
    log.Println("Attempting to stop service")
    c.cancelCtxFunc()
}

Client code

package main

import (
	"pluto/pkgs/pluto"
	"time"
)

func main() {
	client := pluto.NewClient("test-client")

	testProvider := pluto.NewTestProvider()
	client.RegisterProvider(testProvider)

	client.Start(false)

	time.Sleep(time.Second * 3)
	client.Stop()
}

Because it's already chosen the other case before the context is cancelled. Here is your code, annotated:

    // Start a new goroutine
go func() {
provider.Setup()
// Select the first available case
select {
// Is the context cancelled right now?
case <-ctx.Done():
// THIS IS NEVER CALLED?!??!
provider.Shutdown()
return
// No? Then call provider.Run()
default:
provider.Run(ctx)
// Run returned, nothing more to do, we're not in a loop, so our goroutine returns
}
}()

Once provider.Run is called, cancelling the context isn't going to do anything in the code shown. provider.Run also gets the context though, so it is free to handle cancellation as it sees fit. If you want your routine to also see cancellation, you could wrap this in a loop:

    go func() {
provider.Setup()
for {
select {
case <-ctx.Done():
// THIS IS NEVER CALLED?!??!
provider.Shutdown()
return
default:
provider.Run(ctx)
}
}
}()

This way, once provider.Run returns, it will go through the select again, and if the context has been cancelled, that case will be called. However, if the context hasn't been cancelled, it'll call provider.Run again, which may or may not be what you want.

EDIT:

More typically, you'd have one of a couple scenarios, depending on how provider.Run and provider.Shutdown work, which hasn't been made clear in the question, so here are your options:

Shutdown must be called when the context is cancelled, and Run must only be called once:

go func() {
provider.Setup()
go provider.Run(ctx)
go func() {
<- ctx.Done()
provider.Shutdown()
}()
}

Or Run, which already receives the context, already does the same thing as Shutdown when the context is cancelled, and therefore calling Shutdown when the context is cancelled is wholly unnecessary:

go provider.Run(ctx)