Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: show correct stats based on cgroup restrictions (#923)
Kyle Mendell02175be99371
diff --git a/backend/internal/api/system_handler.go b/backend/internal/api/system_handler.goindex 16cd2178c..3f8f91727 100644--- a/backend/internal/api/system_handler.go+++ b/backend/internal/api/system_handler.go@@ -8,6 +8,7 @@ import ("errors""fmt""log/slog"+ "math""net/http""os/exec""runtime"@@ -26,6 +27,7 @@ import ("github.com/ofkm/arcane-backend/internal/middleware""github.com/ofkm/arcane-backend/internal/models""github.com/ofkm/arcane-backend/internal/services"+ "github.com/ofkm/arcane-backend/internal/utils"httputil "github.com/ofkm/arcane-backend/internal/utils/http""github.com/shirou/gopsutil/v4/cpu""github.com/shirou/gopsutil/v4/disk"@@ -183,6 +185,28 @@ func (h *SystemHandler) GetDockerInfo(c *gin.Context) {return}+ cpuCount := info.NCPU+ var memTotal uint64+ if info.MemTotal > 0 {+ memTotal = uint64(info.MemTotal)+ }++ // Check for cgroup limits (LXC, Docker, etc.)+ if cgroupLimits, err := utils.DetectCgroupLimits(); err == nil {+ // Use cgroup memory limit if available and smaller than host value+ if limit := cgroupLimits.MemoryLimit; limit > 0 {+ limitUint := uint64(limit)+ if memTotal == 0 || limitUint < memTotal {+ memTotal = limitUint+ }+ }++ // Use cgroup CPU count if available+ if cgroupLimits.CPUCount > 0 && (cpuCount == 0 || cgroupLimits.CPUCount < cpuCount) {+ cpuCount = cgroupLimits.CPUCount+ }+ }+dockerInfo := dto.DockerInfoDto{Success: true,Version: version.Version,@@ -206,8 +230,8 @@ func (h *SystemHandler) GetDockerInfo(c *gin.Context) {OSVersion: info.OSVersion,ServerVersion: info.ServerVersion,Architecture: info.Architecture,- CPUs: info.NCPU,- MemTotal: info.MemTotal,+ CPUs: cpuCount,+ MemTotal: safeUint64ToInt64(memTotal),}c.JSON(http.StatusOK, dockerInfo)@@ -265,6 +289,13 @@ func (h *SystemHandler) PruneAll(c *gin.Context) {})}+func safeUint64ToInt64(value uint64) int64 {+ if value > uint64(math.MaxInt64) {+ return math.MaxInt64+ }+ return int64(value)+}+func (h *SystemHandler) StartAllContainers(c *gin.Context) {result, err := h.systemService.StartAllContainers(c.Request.Context())if err != nil {@@ -410,6 +441,26 @@ func (h *SystemHandler) Stats(c *gin.Context) {memTotal = memInfo.Total}+ if cgroupLimits, err := utils.DetectCgroupLimits(); err == nil {+ // Use cgroup memory limits if available and smaller than host values+ if limit := cgroupLimits.MemoryLimit; limit > 0 {+ limitUint := uint64(limit)+ if memTotal == 0 || limitUint < memTotal {+ memTotal = limitUint+ }+ }++ // Use actual cgroup memory usage if available+ if usage := cgroupLimits.MemoryUsage; usage > 0 {+ memUsed = uint64(usage)+ }++ // Use cgroup CPU count if available+ if cgroupLimits.CPUCount > 0 && (cpuCount == 0 || cgroupLimits.CPUCount < cpuCount) {+ cpuCount = cgroupLimits.CPUCount+ }+ }+diskUsagePath := h.getDiskUsagePath(ctx)diskInfo, err := disk.Usage(diskUsagePath)if err != nil || diskInfo == nil || diskInfo.Total == 0 {diff --git a/backend/internal/utils/cgroup_utils.go b/backend/internal/utils/cgroup_utils.gonew file mode 100644index 000000000..34a33396f--- /dev/null+++ b/backend/internal/utils/cgroup_utils.go@@ -0,0 +1,267 @@+package utils++import (+ "bufio"+ "fmt"+ "os"+ "path/filepath"+ "strconv"+ "strings"++ "github.com/shirou/gopsutil/v4/host"+)++const unrestricted = 9223372036854771712++type CgroupLimits struct {+ MemoryLimit int64+ MemoryUsage int64+ CPUQuota int64+ CPUPeriod int64+ CPUCount int+}++func DetectCgroupLimits() (*CgroupLimits, error) {+ limits := &CgroupLimits{+ MemoryLimit: -1,+ MemoryUsage: -1,+ CPUQuota: -1,+ CPUPeriod: -1,+ CPUCount: -1,+ }++ if !isInCgroup() {+ return nil, fmt.Errorf("not running in a cgroup")+ }++ if isCgroupV2() {+ return detectCgroupV2Limits(limits)+ }++ return detectCgroupV1Limits(limits)+}++func isInCgroup() bool {+ if info, err := host.Info(); err == nil {+ if info.VirtualizationSystem != "" && strings.EqualFold(info.VirtualizationRole, "guest") {+ return true+ }+ }++ return hasExplicitCgroupLimit()+}++func isCgroupV2() bool {+ _, err := os.Stat("/sys/fs/cgroup/cgroup.controllers")+ return err == nil+}++func hasExplicitCgroupLimit() bool {+ if isCgroupV2() {+ if limit, err := readCgroupV2Int64("/sys/fs/cgroup/memory.max"); err == nil && isFiniteLimit(limit) {+ return true+ }++ if quota, period := readCgroupV2CPU(); quota > 0 && period > 0 {+ return true+ }++ return false+ }++ cgroupPath, err := getCgroupV1Path()+ if err != nil || cgroupPath == "" {+ return false+ }++ memLimitPath := filepath.Join("/sys/fs/cgroup/memory", cgroupPath, "memory.limit_in_bytes")+ if limit, err := readCgroupV1Int64(memLimitPath); err == nil && isFiniteLimit(limit) {+ return true+ }++ if quota, err := readCgroupV1CPUControllerInt64(cgroupPath, "cpu.cfs_quota_us"); err == nil && quota > 0 {+ if period, err := readCgroupV1CPUControllerInt64(cgroupPath, "cpu.cfs_period_us"); err == nil && period > 0 {+ return true+ }+ }++ return false+}++func detectCgroupV2Limits(limits *CgroupLimits) (*CgroupLimits, error) {+ if memLimit, err := readCgroupV2Int64("/sys/fs/cgroup/memory.max"); err == nil {+ if memLimit != unrestricted {+ limits.MemoryLimit = memLimit+ }+ }++ if memUsage, err := readCgroupV2Int64("/sys/fs/cgroup/memory.current"); err == nil {+ limits.MemoryUsage = memUsage+ }++ if cpuMax, err := os.ReadFile("/sys/fs/cgroup/cpu.max"); err == nil {+ parts := strings.Fields(string(cpuMax))+ if len(parts) >= 2 {+ if parts[0] != "max" {+ if quota, err := strconv.ParseInt(parts[0], 10, 64); err == nil {+ limits.CPUQuota = quota+ }+ }+ if period, err := strconv.ParseInt(parts[1], 10, 64); err == nil {+ limits.CPUPeriod = period+ }+ }+ }++ if limits.CPUQuota > 0 && limits.CPUPeriod > 0 {+ limits.CPUCount = int((limits.CPUQuota + limits.CPUPeriod - 1) / limits.CPUPeriod)+ if limits.CPUCount < 1 {+ limits.CPUCount = 1+ }+ }++ return limits, nil+}++func detectCgroupV1Limits(limits *CgroupLimits) (*CgroupLimits, error) {+ cgroupPath, err := getCgroupV1Path()+ if err != nil {+ return limits, err+ }++ memoryLimitPath := filepath.Join("/sys/fs/cgroup/memory", cgroupPath, "memory.limit_in_bytes")+ if memLimit, err := readCgroupV1Int64(memoryLimitPath); err == nil {+ if memLimit < unrestricted {+ limits.MemoryLimit = memLimit+ }+ }++ memoryUsagePath := filepath.Join("/sys/fs/cgroup/memory", cgroupPath, "memory.usage_in_bytes")+ if memUsage, err := readCgroupV1Int64(memoryUsagePath); err == nil {+ limits.MemoryUsage = memUsage+ }++ if cpuQuota, err := readCgroupV1CPUControllerInt64(cgroupPath, "cpu.cfs_quota_us"); err == nil {+ limits.CPUQuota = cpuQuota+ }++ if cpuPeriod, err := readCgroupV1CPUControllerInt64(cgroupPath, "cpu.cfs_period_us"); err == nil {+ limits.CPUPeriod = cpuPeriod+ }++ if limits.CPUQuota > 0 && limits.CPUPeriod > 0 {+ limits.CPUCount = int((limits.CPUQuota + limits.CPUPeriod - 1) / limits.CPUPeriod)+ if limits.CPUCount < 1 {+ limits.CPUCount = 1+ }+ }++ return limits, nil+}++func getCgroupV1Path() (string, error) {+ file, err := os.Open("/proc/self/cgroup")+ if err != nil {+ return "", err+ }+ defer file.Close()++ scanner := bufio.NewScanner(file)+ for scanner.Scan() {+ line := scanner.Text()+ parts := strings.SplitN(line, ":", 3)+ if len(parts) == 3 {+ if strings.Contains(parts[1], "memory") || strings.Contains(parts[1], "cpu") {+ return strings.TrimPrefix(parts[2], "/"), nil+ }+ }+ }++ if err := scanner.Err(); err != nil {+ return "", fmt.Errorf("error scanning cgroup file: %w", err)+ }++ return "", fmt.Errorf("cgroup path not found")+}++func readCgroupV1Int64(path string) (int64, error) {+ data, err := os.ReadFile(path)+ if err != nil {+ return 0, err+ }++ value, err := strconv.ParseInt(strings.TrimSpace(string(data)), 10, 64)+ if err != nil {+ return 0, err+ }++ return value, nil+}++func readCgroupV2Int64(path string) (int64, error) {+ data, err := os.ReadFile(path)+ if err != nil {+ return 0, err+ }++ content := strings.TrimSpace(string(data))+ if content == "max" {+ return unrestricted, nil+ }++ value, err := strconv.ParseInt(content, 10, 64)+ if err != nil {+ return 0, err+ }++ return value, nil+}++func readCgroupV2CPU() (int64, int64) {+ data, err := os.ReadFile("/sys/fs/cgroup/cpu.max")+ if err != nil {+ return -1, -1+ }++ parts := strings.Fields(string(data))+ if len(parts) < 2 {+ return -1, -1+ }++ var quota int64+ if parts[0] != "max" {+ if q, err := strconv.ParseInt(parts[0], 10, 64); err == nil {+ quota = q+ }+ }++ period, err := strconv.ParseInt(parts[1], 10, 64)+ if err != nil {+ return -1, -1+ }++ return quota, period+}++func isFiniteLimit(value int64) bool {+ return value > 0 && value < unrestricted+}++func readCgroupV1CPUControllerInt64(cgroupPath, filename string) (int64, error) {+ controllerBases := []string{+ "/sys/fs/cgroup/cpu,cpuacct",+ "/sys/fs/cgroup/cpu",+ "/sys/fs/cgroup/cpuacct",+ }++ var lastErr error+ for _, base := range controllerBases {+ value, err := readCgroupV1Int64(filepath.Join(base, cgroupPath, filename))+ if err == nil {+ return value, nil+ }+ lastErr = err+ }++ return 0, lastErr+}