snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

weed/util/grace/pprof.go

@@ -0,0 +1,71 @@
+package grace
+
+import (
+	"fmt"
+	"net/http"
+	_ "net/http/pprof"
+	"os"
+	"runtime"
+	"runtime/pprof"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+)
+
+// StartDebugServer starts an HTTP server for pprof debugging on the specified port.
+// The server runs in a goroutine and serves pprof endpoints at /debug/pprof/*.
+func StartDebugServer(debugPort int) {
+	go func() {
+		addr := fmt.Sprintf("127.0.0.1:%d", debugPort)
+		glog.V(0).Infof("Starting debug server for pprof at http://%s/debug/pprof/", addr)
+		if err := http.ListenAndServe(addr, nil); err != nil && err != http.ErrServerClosed {
+			glog.Errorf("Failed to start debug server on %s: %v", addr, err)
+		}
+	}()
+}
+
+func SetupProfiling(cpuProfile, memProfile string) {
+	if cpuProfile != "" {
+		f, err := os.Create(cpuProfile)
+		if err != nil {
+			glog.Fatal(err)
+		}
+		runtime.SetBlockProfileRate(1)
+		runtime.SetMutexProfileFraction(1)
+		pprof.StartCPUProfile(f)
+		OnInterrupt(func() {
+			pprof.StopCPUProfile()
+			f.Close()
+
+			// write block pprof
+			blockF, err := os.Create(cpuProfile + ".block")
+			if err != nil {
+				return
+			}
+			p := pprof.Lookup("block")
+			p.WriteTo(blockF, 0)
+			blockF.Close()
+
+			// write mutex pprof
+			mutexF, err := os.Create(cpuProfile + ".mutex")
+			if err != nil {
+				return
+			}
+			p = pprof.Lookup("mutex")
+			p.WriteTo(mutexF, 0)
+			mutexF.Close()
+
+		})
+	}
+	if memProfile != "" {
+		runtime.MemProfileRate = 1
+		f, err := os.Create(memProfile)
+		if err != nil {
+			glog.Fatal(err)
+		}
+		OnInterrupt(func() {
+			pprof.WriteHeapProfile(f)
+			f.Close()
+		})
+	}
+
+}

weed/util/grace/signal_handling.go

@@ -0,0 +1,76 @@
+//go:build !plan9
+
+package grace
+
+import (
+	"os"
+	"os/signal"
+	"reflect"
+	"runtime"
+	"sync"
+	"syscall"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+)
+
+var signalChan chan os.Signal
+var interruptHooks = make([]func(), 0)
+var interruptHookLock sync.RWMutex
+var reloadHooks = make([]func(), 0)
+var reloadHookLock sync.RWMutex
+
+func GetFunctionName(i interface{}) string {
+	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
+}
+
+func init() {
+	signalChan = make(chan os.Signal, 1)
+	signal.Notify(signalChan,
+		os.Interrupt,
+		os.Kill,
+		syscall.SIGALRM,
+		syscall.SIGHUP,
+		syscall.SIGINT,
+		syscall.SIGTERM,
+		// syscall.SIGQUIT,
+	)
+	go func() {
+		for s := range signalChan {
+			if s.String() == syscall.SIGHUP.String() {
+				reloadHookLock.RLock()
+				for _, hook := range reloadHooks {
+					hook()
+				}
+				reloadHookLock.RUnlock()
+			} else {
+				interruptHookLock.RLock()
+				// Execute hooks in reverse registration order (LIFO/defer-style) so
+				// later-started services shut down before the services they depend on.
+				for i := len(interruptHooks) - 1; i >= 0; i-- {
+					hook := interruptHooks[i]
+					glog.V(4).Infof("exec interrupt hook func name:%s", GetFunctionName(hook))
+					hook()
+				}
+				interruptHookLock.RUnlock()
+				os.Exit(0)
+			}
+		}
+	}()
+}
+
+func OnReload(fn func()) {
+	// prevent reentry
+	reloadHookLock.Lock()
+	defer reloadHookLock.Unlock()
+	reloadHooks = append(reloadHooks, fn)
+}
+
+func OnInterrupt(fn func()) {
+	// prevent reentry
+	interruptHookLock.Lock()
+	defer interruptHookLock.Unlock()
+
+	// deal with control+c,etc
+	// controlling terminal close, daemon not exit
+	interruptHooks = append(interruptHooks, fn)
+}

weed/util/grace/signal_handling_notsupported.go

@@ -0,0 +1,6 @@
+//go:build plan9
+
+package grace
+
+func OnInterrupt(fn func()) {
+}