Fixed a possible leak bug in goroutine

[suwakei]

Problem:

The goroutine invoked by the ApplicationTermination method (go func() { ... }) has no termination mechanism.

The Close method calls s.ticker.Stop(), which only stops the ticker, but does not terminate the for loop in the goroutine.
The goroutine leaks because it is permanently waiting to receive from the channel in <-s.ticker.C.
This goroutine will remain in the program even after the command is terminated.

Fix:

Use context to manage the goroutine lifecycle.

By adding context.CancelFunc to the Stopping structure and notifying the goroutine of the cancellation with the Close method, the goroutine can be safely terminated.

Another small change is that within the ApplicationTermination method, the value 100 * time.Millisecond is written directly to time.NewTicker. This “magic number” could be confusing to the intent of the code and has been corrected.

package formatter
import (
+++ "context"
"fmt"
"strings"
"time"
"github.com/docker/compose/v2/pkg/progress"
)
+++ const tickerInterval = 100 * time.Millisecond
type Stopping struct {
api.LogConsumer
enabled bool
spinner *progress.Spinner
ticker *time.Ticker
startedAt time.Time
+++ cancel context.CancelFunc
}
func NewStopping(l api.LogConsumer) *Stopping {
s.spinner = progress.NewSpinner()
hideCursor()
s.startedAt = time.Now()
--- s.ticker = time.NewTicker(100 * time.Millisecond)
+++ s.ticker = time.NewTicker(tickerInterval)
ctx, cancel := context.WithCancel(context.Background())
s.cancel = cancel
go func() {
for {
--- <-s.ticker.C
--- s.print()
+++ select {
+++ case <-s.ticker.C:
+++ s.print()
+++ case <-ctx.Done():
+++ return
+++ }
}
}()
}
func (s *Stopping) Close() {
showCursor()
--- if s.ticker != nil {
--- s.ticker.Stop()
--- }
+++ s.ticker.Stop()
+++ s.cancel()
s.clear()
}

Benefits:

Applying this goroutine leak fix will greatly improve the stability of the program.

[ndeloof]

this is obsolete after #13064 has been merged

[suwakei]

Thank you for the feedback! Closing this PR since #13064 already addresses the issue.