using parent context to sequencer services shutdown

[lucasmenendez]

regarding the Stop comments: i believe we can simplify (and clarify) the whole startup/cleanup of services using context. it would require a small refactor but i think it's worth it.
right now we have this in prod

davinci-node/cmd/davinci-sequencer/main.go

Lines 296 to 317 in 4d77454

	// shutdownServices gracefully shuts down all services
	func shutdownServices(services *Services) {
	if services == nil {
	return
	}
	// Stop services in reverse order of startup
	if services.Sequencer != nil {
	services.Sequencer.Stop()
	}
	if services.API != nil {
	services.API.Stop()
	}
	if services.CensusDownloader != nil {
	services.CensusDownloader.Stop()
	}
	if services.ProcessMon != nil {
	services.ProcessMon.Stop()
	}
	services.TxManager.Stop() // Stop transaction manager
	services.Storage.Close() // Close storage last
	}

and even this in tests

davinci-node/tests/helpers_test.go

Lines 573 to 584 in 4d77454

	// Create a combined cleanup function
	cleanup := func() {
	seqCancel()
	api.Stop()
	stateSync.Stop()
	cd.Stop()
	pm.Stop()
	vp.Stop()
	stg.Close()
	c3cleanup()
	web3Cleanup()
	}

but those funcs just basically do a ctx.Cancel, can't we just handle that through the parent context anyway?

sequencer creates a single parent context, where all those services live. (test setup follows a similar pattern, obviously)

davinci-node/cmd/davinci-sequencer/main.go

Lines 64 to 70 in 4d77454

	// Create context with cancellation for graceful shutdown
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	// Setup services
	services, err := setupServices(ctx, cfg)
	if err != nil {

cancelling the parent context, cancels all derived contexts.
and whatever cleanup needed, could simply happen on <-ctx.Done

Originally posted by @altergui in #284 (comment)

[altergui]

we want to keep the "shutdown everything first, then close storage"
for that, my proposal would be to refactor all services to be coordinated with an errgroup
https://pkg.go.dev/golang.org/x/sync/errgroup#example-Group-Pipeline

so instead of each service Start() returning immediately, and then having Stop() (or Close()), rename Start() -> Run() and make it block, only return after all its internal goroutines are done.
that internal goroutine tracking would also happen with an internal errgroup, so Run() basically blocks until it's own internal errgroup.Wait()

i'm proposing errgroup so that we ALWAYS use it's Go() method, and not have any plain 'go func()' call anywhere in the codebase, currently many of them are untracked and can potentially run past the service Close method, for example this one:

davinci-node/sequencer/finalizer.go

Lines 72 to 79 in 34a528f

	go func(processID types.ProcessID) {
	// Check if process is marked as invalid (thread-safe)
	if _, isInvalid := f.invalidProcesses.Load(processID); !isInvalid {
	if err := f.finalize(processID); err != nil {
	log.Errorw(err, fmt.Sprintf("finalizing process %s", processID.String()))
	}
	}
	}(pid) // Use a goroutine to avoid blocking the channel

so in essence each service would track ALL of its goroutines and only return Run AFTER they are all done,

and the main() would track all of the services with wg.Go(service1.Run()), wg.Go(service2.Run()) and after they are all done (wg.Wait), call db.Close