Adding upstream version 2.52.6.

Signed-off-by: Daniel Baumann <daniel@debian.org>

internal/gopsutil/load/load.go

@@ -0,0 +1,30 @@
+package load
+
+import (
+	"encoding/json"
+)
+
+// var invoke common.Invoker = common.Invoke{}
+type AvgStat struct {
+	Load1  float64 `json:"load1"`
+	Load5  float64 `json:"load5"`
+	Load15 float64 `json:"load15"`
+}
+
+func (l AvgStat) String() string {
+	s, _ := json.Marshal(l)
+	return string(s)
+}
+
+type MiscStat struct {
+	ProcsTotal   int64 `json:"procsTotal"`
+	ProcsCreated int64 `json:"procsCreated"`
+	ProcsRunning int64 `json:"procsRunning"`
+	ProcsBlocked int64 `json:"procsBlocked"`
+	Ctxt         int64 `json:"ctxt"`
+}
+
+func (m MiscStat) String() string {
+	s, _ := json.Marshal(m)
+	return string(s)
+}

internal/gopsutil/load/load_bsd.go

@@ -0,0 +1,84 @@
+//go:build freebsd || openbsd
+
+package load
+
+import (
+	"context"
+	"os/exec"
+	"strings"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+
+	"github.com/gofiber/fiber/v2/internal/gopsutil/common"
+)
+
+var invoke common.Invoker = common.Invoke{}
+
+func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
+	// This SysctlRaw method borrowed from
+	// https://github.com/prometheus/node_exporter/blob/master/collector/loadavg_freebsd.go
+	type loadavg struct {
+		load  [3]uint32
+		scale int
+	}
+	b, err := unix.SysctlRaw("vm.loadavg")
+	if err != nil {
+		return nil, err
+	}
+	load := *(*loadavg)(unsafe.Pointer((&b[0])))
+	scale := float64(load.scale)
+	ret := &AvgStat{
+		Load1:  float64(load.load[0]) / scale,
+		Load5:  float64(load.load[1]) / scale,
+		Load15: float64(load.load[2]) / scale,
+	}
+
+	return ret, nil
+}
+
+type forkstat struct {
+	forks    int
+	vforks   int
+	__tforks int
+}
+
+// Misc returns miscellaneous host-wide statistics.
+// darwin use ps command to get process running/blocked count.
+// Almost same as Darwin implementation, but state is different.
+func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
+	bin, err := exec.LookPath("ps")
+	if err != nil {
+		return nil, err
+	}
+	out, err := invoke.CommandWithContext(ctx, bin, "axo", "state")
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(string(out), "\n")
+
+	ret := MiscStat{}
+	for _, l := range lines {
+		if strings.Contains(l, "R") {
+			ret.ProcsRunning++
+		} else if strings.Contains(l, "D") {
+			ret.ProcsBlocked++
+		}
+	}
+
+	f, err := getForkStat()
+	if err != nil {
+		return nil, err
+	}
+	ret.ProcsCreated = int64(f.forks)
+
+	return &ret, nil
+}

internal/gopsutil/load/load_darwin.go

@@ -0,0 +1,75 @@
+//go:build darwin
+
+package load
+
+import (
+	"context"
+	"os/exec"
+	"strings"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+
+	"github.com/gofiber/fiber/v2/internal/gopsutil/common"
+)
+
+var invoke common.Invoker = common.Invoke{}
+
+func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
+	// This SysctlRaw method borrowed from
+	// https://github.com/prometheus/node_exporter/blob/master/collector/loadavg_freebsd.go
+	// this implementation is common with BSDs
+	type loadavg struct {
+		load  [3]uint32
+		scale int
+	}
+	b, err := unix.SysctlRaw("vm.loadavg")
+	if err != nil {
+		return nil, err
+	}
+	load := *(*loadavg)(unsafe.Pointer((&b[0])))
+	scale := float64(load.scale)
+	ret := &AvgStat{
+		Load1:  float64(load.load[0]) / scale,
+		Load5:  float64(load.load[1]) / scale,
+		Load15: float64(load.load[2]) / scale,
+	}
+
+	return ret, nil
+}
+
+// Misc returnes miscellaneous host-wide statistics.
+// darwin use ps command to get process running/blocked count.
+// Almost same as FreeBSD implementation, but state is different.
+// U means 'Uninterruptible Sleep'.
+func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
+	bin, err := exec.LookPath("ps")
+	if err != nil {
+		return nil, err
+	}
+	out, err := invoke.CommandWithContext(ctx, bin, "axo", "state")
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(string(out), "\n")
+
+	ret := MiscStat{}
+	for _, l := range lines {
+		if strings.Contains(l, "R") {
+			ret.ProcsRunning++
+		} else if strings.Contains(l, "U") {
+			// uninterruptible sleep == blocked
+			ret.ProcsBlocked++
+		}
+	}
+
+	return &ret, nil
+}

internal/gopsutil/load/load_fallback.go

@@ -0,0 +1,25 @@
+//go:build !darwin && !linux && !freebsd && !openbsd && !windows && !solaris
+
+package load
+
+import (
+	"context"
+
+	"github.com/gofiber/fiber/v2/internal/gopsutil/common"
+)
+
+func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
+	return nil, common.ErrNotImplementedError
+}

internal/gopsutil/load/load_freebsd.go

@@ -0,0 +1,7 @@
+//go:build freebsd
+
+package load
+
+func getForkStat() (forkstat, error) {
+	return forkstat{}, nil
+}

internal/gopsutil/load/load_linux.go

@@ -0,0 +1,135 @@
+//go:build linux
+
+package load
+
+import (
+	"context"
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/gofiber/fiber/v2/internal/gopsutil/common"
+)
+
+func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
+	stat, err := fileAvgWithContext(ctx)
+	if err != nil {
+		stat, err = sysinfoAvgWithContext(ctx)
+	}
+	return stat, err
+}
+
+func sysinfoAvgWithContext(ctx context.Context) (*AvgStat, error) {
+	var info syscall.Sysinfo_t
+	err := syscall.Sysinfo(&info)
+	if err != nil {
+		return nil, err
+	}
+
+	const si_load_shift = 16
+	return &AvgStat{
+		Load1:  float64(info.Loads[0]) / float64(1<<si_load_shift),
+		Load5:  float64(info.Loads[1]) / float64(1<<si_load_shift),
+		Load15: float64(info.Loads[2]) / float64(1<<si_load_shift),
+	}, nil
+}
+
+func fileAvgWithContext(ctx context.Context) (*AvgStat, error) {
+	values, err := readLoadAvgFromFile()
+	if err != nil {
+		return nil, err
+	}
+
+	load1, err := strconv.ParseFloat(values[0], 64)
+	if err != nil {
+		return nil, err
+	}
+	load5, err := strconv.ParseFloat(values[1], 64)
+	if err != nil {
+		return nil, err
+	}
+	load15, err := strconv.ParseFloat(values[2], 64)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &AvgStat{
+		Load1:  load1,
+		Load5:  load5,
+		Load15: load15,
+	}
+
+	return ret, nil
+}
+
+// Misc returnes miscellaneous host-wide statistics.
+// Note: the name should be changed near future.
+func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
+	filename := common.HostProc("stat")
+	out, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &MiscStat{}
+	lines := strings.Split(string(out), "\n")
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) != 2 {
+			continue
+		}
+		v, err := strconv.ParseInt(fields[1], 10, 64)
+		if err != nil {
+			continue
+		}
+		switch fields[0] {
+		case "processes":
+			ret.ProcsCreated = v
+		case "procs_running":
+			ret.ProcsRunning = v
+		case "procs_blocked":
+			ret.ProcsBlocked = v
+		case "ctxt":
+			ret.Ctxt = v
+		default:
+			continue
+		}
+
+	}
+
+	procsTotal, err := getProcsTotal()
+	if err != nil {
+		return ret, err
+	}
+	ret.ProcsTotal = procsTotal
+
+	return ret, nil
+}
+
+func getProcsTotal() (int64, error) {
+	values, err := readLoadAvgFromFile()
+	if err != nil {
+		return 0, err
+	}
+	return strconv.ParseInt(strings.Split(values[3], "/")[1], 10, 64)
+}
+
+func readLoadAvgFromFile() ([]string, error) {
+	loadavgFilename := common.HostProc("loadavg")
+	line, err := os.ReadFile(loadavgFilename)
+	if err != nil {
+		return nil, err
+	}
+
+	values := strings.Fields(string(line))
+	return values, nil
+}

internal/gopsutil/load/load_openbsd.go

@@ -0,0 +1,17 @@
+//go:build openbsd
+
+package load
+
+import (
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+func getForkStat() (forkstat, error) {
+	b, err := unix.SysctlRaw("kern.forkstat")
+	if err != nil {
+		return forkstat{}, err
+	}
+	return *(*forkstat)(unsafe.Pointer((&b[0]))), nil
+}

internal/gopsutil/load/load_solaris.go

@@ -0,0 +1,44 @@
+//go:build solaris
+
+package load
+
+import (
+	"context"
+	"os/exec"
+	"strings"
+
+	"github.com/gofiber/fiber/v2/internal/gopsutil/common"
+)
+
+func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
+	bin, err := exec.LookPath("ps")
+	if err != nil {
+		return nil, err
+	}
+	out, err := invoke.CommandWithContext(ctx, bin, "-efo", "s")
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(string(out), "\n")
+
+	ret := MiscStat{}
+	for _, l := range lines {
+		if l == "O" {
+			ret.ProcsRunning++
+		}
+	}
+
+	return &ret, nil
+}

internal/gopsutil/load/load_windows.go

@@ -0,0 +1,84 @@
+//go:build windows
+
+package load
+
+import (
+	"context"
+	"log"
+	"math"
+	"sync"
+	"time"
+
+	"github.com/gofiber/fiber/v2/internal/gopsutil/common"
+)
+
+var (
+	loadErr              error
+	loadAvg1M            float64 = 0.0
+	loadAvg5M            float64 = 0.0
+	loadAvg15M           float64 = 0.0
+	loadAvgMutex         sync.RWMutex
+	loadAvgGoroutineOnce sync.Once
+)
+
+// loadAvgGoroutine updates avg data by fetching current load by interval
+// TODO instead of this goroutine, we can register a Win32 counter just as psutil does
+// see https://psutil.readthedocs.io/en/latest/#psutil.getloadavg
+// code https://github.com/giampaolo/psutil/blob/8415355c8badc9c94418b19bdf26e622f06f0cce/psutil/arch/windows/wmi.c
+func loadAvgGoroutine() {
+	var (
+		samplingFrequency time.Duration = 5 * time.Second
+		loadAvgFactor1M   float64       = 1 / math.Exp(samplingFrequency.Seconds()/time.Minute.Seconds())
+		loadAvgFactor5M   float64       = 1 / math.Exp(samplingFrequency.Seconds()/(5*time.Minute).Seconds())
+		loadAvgFactor15M  float64       = 1 / math.Exp(samplingFrequency.Seconds()/(15*time.Minute).Seconds())
+		currentLoad       float64
+	)
+
+	counter, err := common.ProcessorQueueLengthCounter()
+	if err != nil || counter == nil {
+		log.Println("gopsutil: unexpected processor queue length counter error, please file an issue on github: err")
+		return
+	}
+
+	tick := time.NewTicker(samplingFrequency).C
+	for {
+		currentLoad, err = counter.GetValue()
+		loadAvgMutex.Lock()
+		loadErr = err
+		loadAvg1M = loadAvg1M*loadAvgFactor1M + currentLoad*(1-loadAvgFactor1M)
+		loadAvg5M = loadAvg5M*loadAvgFactor5M + currentLoad*(1-loadAvgFactor5M)
+		loadAvg15M = loadAvg15M*loadAvgFactor15M + currentLoad*(1-loadAvgFactor15M)
+		loadAvgMutex.Unlock()
+		<-tick
+	}
+}
+
+// Avg for Windows may return 0 values for the first few 5 second intervals
+func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
+	loadAvgGoroutineOnce.Do(func() {
+		go loadAvgGoroutine()
+	})
+	loadAvgMutex.RLock()
+	defer loadAvgMutex.RUnlock()
+	ret := AvgStat{
+		Load1:  loadAvg1M,
+		Load5:  loadAvg5M,
+		Load15: loadAvg15M,
+	}
+
+	return &ret, loadErr
+}
+
+func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
+	ret := MiscStat{}
+
+	return &ret, common.ErrNotImplementedError
+}