first commit

cmd/runmqserver/signals.go

@@ -0,0 +1,124 @@
+/*
+© Copyright IBM Corporation 2017, 2024
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package main
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/ibm-messaging/mq-container/internal/metrics"
+	"golang.org/x/sys/unix"
+)
+
+const (
+	startReaping = iota
+	reapNow      = iota
+)
+
+func signalHandler(qmgr string, startupCtx context.Context) chan int {
+	control := make(chan int)
+	// Use separate channels for the signals, to avoid SIGCHLD signals swamping
+	// the buffer, and preventing other signals.
+	stopSignals := make(chan os.Signal, 1)
+	reapSignals := make(chan os.Signal, 1)
+	signal.Notify(stopSignals, syscall.SIGTERM, syscall.SIGINT)
+
+	// Pulling out as function as reused for shutdown and standard control flow
+	processControlSignal := func(job int) {
+		switch {
+		case job == startReaping:
+			// Add SIGCHLD to the list of signals we're listening to
+			log.Debug("Listening for SIGCHLD signals")
+			signal.Notify(reapSignals, syscall.SIGCHLD)
+		case job == reapNow:
+			reapZombies()
+		}
+	}
+
+	// Start handling signals
+	go func() {
+		shutdownCtx, shutdownComplete := context.WithCancel(context.Background())
+		defer func() {
+			shutdownComplete()
+		}()
+		stopTriggered := false
+		for {
+			select {
+			case sig := <-stopSignals:
+				if stopTriggered {
+					continue
+				}
+				log.Printf("Signal received: %v", sig)
+				signal.Stop(stopSignals)
+				stopTriggered = true
+
+				// If a stop signal is received during the startup process continue processing control signals until the main thread marks startup as complete
+				// Don't close the control channel until the main thread has been allowed to finish spawning processes and marks startup as complete
+				// Continue to process job control signals to avoid a deadlock
+				done := false
+				for !done {
+					select {
+					// When the main thread has cancelled the startup context due to completion or an error stop processing control signals
+					case <-startupCtx.Done():
+						done = true
+					// Keep processing control signals until the main thread has finished its startup
+					case job := <-control:
+						processControlSignal(job)
+					}
+				}
+				metrics.StopMetricsGathering(log)
+
+				// Shutdown queue manager in separate goroutine to allow reaping to continue in parallel
+				go func() {
+					_ = stopQueueManager(qmgr)
+					shutdownComplete()
+				}()
+			case <-shutdownCtx.Done():
+				signal.Stop(reapSignals)
+
+				// One final reap
+				// This occurs after all startup processes have been spawned
+				reapZombies()
+
+				close(control)
+				// End the goroutine
+				return
+			case <-reapSignals:
+				log.Debug("Received SIGCHLD signal")
+				reapZombies()
+			case job := <-control:
+				processControlSignal(job)
+			}
+		}
+	}()
+	return control
+}
+
+// reapZombies reaps any zombie (terminated) processes now.
+// This function should be called before exiting.
+func reapZombies() {
+	for {
+		var ws unix.WaitStatus
+		pid, err := unix.Wait4(-1, &ws, unix.WNOHANG, nil)
+		// If err or pid indicate "no child processes"
+		if pid == 0 || err == unix.ECHILD {
+			return
+		}
+		log.Debugf("Reaped PID %v", pid)
+	}
+}