361 lines
10 KiB
Go
361 lines
10 KiB
Go
package backend
|
|
|
|
import (
|
|
"context"
|
|
"os/exec"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/shirou/gopsutil/v3/cpu"
|
|
"github.com/shirou/gopsutil/v3/mem"
|
|
ps "github.com/shirou/gopsutil/v3/process"
|
|
"github.com/wailsapp/wails/v2/pkg/runtime"
|
|
)
|
|
|
|
type SysInfo struct {
|
|
ctx context.Context
|
|
cancel context.CancelFunc
|
|
}
|
|
|
|
func NewSysInfo(ctx context.Context) *SysInfo {
|
|
cctx, cancel := context.WithCancel(ctx)
|
|
s := &SysInfo{ctx: cctx, cancel: cancel}
|
|
go s.startEmitter()
|
|
return s
|
|
}
|
|
|
|
func (s *SysInfo) startEmitter() {
|
|
ticker := time.NewTicker(1 * time.Second)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-s.ctx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
info, _ := s.CollectOnce()
|
|
// attach GPU global stats
|
|
name, tot, used, util := queryGPU(s.ctx)
|
|
if name != "" {
|
|
info.GPUName = name
|
|
info.GPUTotal = tot
|
|
info.GPUUsed = used
|
|
info.GPUUtil = util
|
|
// attach per-process GPU stats
|
|
info.GPUProcesses = queryGPUProcesses(s.ctx)
|
|
}
|
|
runtime.EventsEmit(s.ctx, "metrics", info)
|
|
}
|
|
}
|
|
}
|
|
|
|
type ProcessInfo struct {
|
|
PID int32 `json:"pid"`
|
|
Name string `json:"name"`
|
|
CPU float64 `json:"cpu"`
|
|
Mem uint64 `json:"mem"`
|
|
}
|
|
|
|
// GPUProcessInfo holds per-process GPU stats from nvidia-smi pmon.
|
|
type GPUProcessInfo struct {
|
|
PID int32 `json:"pid"`
|
|
Name string `json:"name"`
|
|
Type string `json:"type"` // "C", "G", or "C+G"
|
|
VRAM uint64 `json:"vram_mb"` // framebuffer memory in MB
|
|
RAM uint64 `json:"ram"` // resident set size in bytes
|
|
}
|
|
|
|
type Metrics struct {
|
|
CPUPercent float64 `json:"cpu_percent"`
|
|
TotalMem uint64 `json:"total_mem"`
|
|
FreeMem uint64 `json:"free_mem"`
|
|
Processes []ProcessInfo `json:"processes"`
|
|
Timestamp int64 `json:"timestamp"`
|
|
GPUName string `json:"gpu_name,omitempty"`
|
|
GPUTotal uint64 `json:"gpu_total_mem,omitempty"`
|
|
GPUUsed uint64 `json:"gpu_used_mem,omitempty"`
|
|
GPUUtil float64 `json:"gpu_util_percent,omitempty"`
|
|
GPUProcesses []GPUProcessInfo `json:"gpu_processes,omitempty"`
|
|
}
|
|
|
|
// CollectOnce gathers a snapshot of system metrics.
|
|
func (s *SysInfo) CollectOnce() (*Metrics, error) {
|
|
cpuPercents, _ := cpu.PercentWithContext(s.ctx, 0, false)
|
|
vm, _ := mem.VirtualMemory()
|
|
|
|
// Collect ALL processes, then sort and keep top 50
|
|
procs, _ := ps.Processes()
|
|
var list []ProcessInfo
|
|
for _, p := range procs {
|
|
name, _ := p.Name()
|
|
cpuPct, _ := p.CPUPercent()
|
|
memInfo, _ := p.MemoryInfo()
|
|
var memBytes uint64
|
|
if memInfo != nil {
|
|
memBytes = memInfo.RSS
|
|
}
|
|
list = append(list, ProcessInfo{PID: p.Pid, Name: name, CPU: cpuPct, Mem: memBytes})
|
|
}
|
|
// Sort: primary by CPU desc, secondary by Mem desc
|
|
sort.Slice(list, func(i, j int) bool {
|
|
if list[i].CPU != list[j].CPU {
|
|
return list[i].CPU > list[j].CPU
|
|
}
|
|
return list[i].Mem > list[j].Mem
|
|
})
|
|
|
|
var cpuVal float64
|
|
if len(cpuPercents) > 0 {
|
|
cpuVal = cpuPercents[0]
|
|
}
|
|
|
|
return &Metrics{
|
|
CPUPercent: cpuVal,
|
|
TotalMem: vm.Total,
|
|
FreeMem: vm.Available,
|
|
Processes: list,
|
|
Timestamp: time.Now().UnixMilli(),
|
|
GPUName: "",
|
|
GPUTotal: 0,
|
|
GPUUsed: 0,
|
|
GPUUtil: 0,
|
|
}, nil
|
|
}
|
|
|
|
// queryGPUProcesses lists all processes currently using the GPU via nvidia-smi pmon.
|
|
func queryGPUProcesses(ctx context.Context) []GPUProcessInfo {
|
|
cmd := exec.CommandContext(ctx, "nvidia-smi", "pmon", "-s", "m", "-c", "1")
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
var result []GPUProcessInfo
|
|
for _, line := range strings.Split(string(out), "\n") {
|
|
line = strings.TrimSpace(line)
|
|
if line == "" || strings.HasPrefix(line, "#") {
|
|
continue
|
|
}
|
|
fields := strings.Fields(line)
|
|
// expected: [gpuIdx, pid, type, fbMB, ccpmMB, name...]
|
|
if len(fields) < 5 {
|
|
continue
|
|
}
|
|
pid64, err := strconv.ParseInt(fields[1], 10, 32)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
vram, _ := strconv.ParseUint(fields[3], 10, 64)
|
|
name := ""
|
|
if len(fields) >= 6 {
|
|
name = strings.Join(fields[5:], " ")
|
|
} else {
|
|
name = fields[len(fields)-1]
|
|
}
|
|
gp := GPUProcessInfo{
|
|
PID: int32(pid64),
|
|
Name: name,
|
|
Type: fields[2],
|
|
VRAM: vram,
|
|
}
|
|
// look up RAM (RSS) for this process
|
|
if p, err := ps.NewProcess(int32(pid64)); err == nil {
|
|
if mi, err := p.MemoryInfoWithContext(ctx); err == nil && mi != nil {
|
|
gp.RAM = mi.RSS
|
|
}
|
|
}
|
|
result = append(result, gp)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// try to query GPU info via nvidia-smi; returns name, totalMB, usedMB, utilPercent
|
|
func queryGPU(ctx context.Context) (string, uint64, uint64, float64) {
|
|
// Use nvidia-smi if available
|
|
cmd := exec.CommandContext(ctx, "nvidia-smi", "--query-gpu=name,memory.total,memory.used,utilization.gpu", "--format=csv,noheader,nounits")
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
return "", 0, 0, 0
|
|
}
|
|
line := strings.TrimSpace(string(out))
|
|
if line == "" {
|
|
return "", 0, 0, 0
|
|
}
|
|
// fields: name, totalMB, usedMB, util
|
|
parts := strings.Split(line, ",")
|
|
if len(parts) < 4 {
|
|
return "", 0, 0, 0
|
|
}
|
|
name := strings.TrimSpace(parts[0])
|
|
totStr := strings.TrimSpace(parts[1])
|
|
usedStr := strings.TrimSpace(parts[2])
|
|
utilStr := strings.TrimSpace(parts[3])
|
|
tot, _ := strconv.ParseUint(strings.Fields(totStr)[0], 10, 64)
|
|
used, _ := strconv.ParseUint(strings.Fields(usedStr)[0], 10, 64)
|
|
utilVal, _ := strconv.ParseFloat(strings.Fields(utilStr)[0], 64)
|
|
return name, tot * 1024 * 1024, used * 1024 * 1024, utilVal
|
|
}
|
|
|
|
// GetMetrics is an exported method callable from frontend.
|
|
func (s *SysInfo) GetMetrics() (*Metrics, error) {
|
|
return s.CollectOnce()
|
|
}
|
|
// ProcessDetail contains all available details about a single process.
|
|
type ProcessDetail struct {
|
|
PID int32 `json:"pid"`
|
|
Name string `json:"name"`
|
|
Exe string `json:"exe"`
|
|
Cmdline string `json:"cmdline"`
|
|
Cwd string `json:"cwd"`
|
|
Status string `json:"status"`
|
|
Username string `json:"username"`
|
|
CreatedAt int64 `json:"created_at"` // unix ms
|
|
ParentPID int32 `json:"parent_pid"`
|
|
ParentName string `json:"parent_name"`
|
|
Nice int32 `json:"nice"`
|
|
NumThreads int32 `json:"num_threads"`
|
|
NumFDs int32 `json:"num_fds"`
|
|
CPUPercent float64 `json:"cpu_percent"`
|
|
RSS uint64 `json:"rss"`
|
|
VMS uint64 `json:"vms"`
|
|
Swap uint64 `json:"swap"`
|
|
MemPercent float32 `json:"mem_percent"`
|
|
ReadBytes uint64 `json:"read_bytes"`
|
|
WriteBytes uint64 `json:"write_bytes"`
|
|
ReadOps uint64 `json:"read_ops"`
|
|
WriteOps uint64 `json:"write_ops"`
|
|
OpenFilesCount int `json:"open_files_count"`
|
|
ConnCount int `json:"conn_count"`
|
|
}
|
|
|
|
// FetchProcessDetail collects all available details for a given PID.
|
|
// Fields that can't be read (e.g. permission denied) are left at zero/empty.
|
|
func FetchProcessDetail(pid int32) (*ProcessDetail, error) {
|
|
p, err := ps.NewProcess(pid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
d := &ProcessDetail{PID: pid}
|
|
if v, e := p.Name(); e == nil {
|
|
d.Name = v
|
|
}
|
|
if v, e := p.Exe(); e == nil {
|
|
d.Exe = v
|
|
}
|
|
if v, e := p.Cmdline(); e == nil {
|
|
d.Cmdline = v
|
|
}
|
|
if v, e := p.Cwd(); e == nil {
|
|
d.Cwd = v
|
|
}
|
|
if vv, e := p.Status(); e == nil && len(vv) > 0 {
|
|
d.Status = vv[0]
|
|
}
|
|
if v, e := p.Username(); e == nil {
|
|
d.Username = v
|
|
}
|
|
if v, e := p.CreateTime(); e == nil {
|
|
d.CreatedAt = v
|
|
}
|
|
if v, e := p.Ppid(); e == nil {
|
|
d.ParentPID = v
|
|
if d.ParentPID > 0 {
|
|
if pp, err2 := ps.NewProcess(d.ParentPID); err2 == nil {
|
|
if pname, err2 := pp.Name(); err2 == nil {
|
|
d.ParentName = pname
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if v, e := p.Nice(); e == nil {
|
|
d.Nice = v
|
|
}
|
|
if v, e := p.NumThreads(); e == nil {
|
|
d.NumThreads = v
|
|
}
|
|
if v, e := p.NumFDs(); e == nil {
|
|
d.NumFDs = v
|
|
}
|
|
if v, e := p.CPUPercent(); e == nil {
|
|
d.CPUPercent = v
|
|
}
|
|
if v, e := p.MemoryInfo(); e == nil && v != nil {
|
|
d.RSS = v.RSS
|
|
d.VMS = v.VMS
|
|
d.Swap = v.Swap
|
|
}
|
|
if v, e := p.MemoryPercent(); e == nil {
|
|
d.MemPercent = v
|
|
}
|
|
if v, e := p.IOCounters(); e == nil && v != nil {
|
|
d.ReadBytes = v.ReadBytes
|
|
d.WriteBytes = v.WriteBytes
|
|
d.ReadOps = v.ReadCount
|
|
d.WriteOps = v.WriteCount
|
|
}
|
|
if v, e := p.OpenFiles(); e == nil {
|
|
d.OpenFilesCount = len(v)
|
|
}
|
|
if v, e := p.Connections(); e == nil {
|
|
d.ConnCount = len(v)
|
|
}
|
|
return d, nil
|
|
}
|
|
|
|
// KillProcess sends SIGTERM to the process. Use force=true to send SIGKILL.
|
|
func KillProcess(pid int32, force bool) error {
|
|
p, err := ps.NewProcess(pid)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if force {
|
|
return p.Kill()
|
|
}
|
|
return p.Terminate()
|
|
}
|
|
// CollectFull gathers a complete metrics snapshot including GPU data.
|
|
// Unlike NewSysInfo, it does not start a background emitter and does not
|
|
// require a Wails runtime context — safe to call from server mode.
|
|
func CollectFull(ctx context.Context) (*Metrics, error) {
|
|
s := &SysInfo{ctx: ctx}
|
|
m, err := s.CollectOnce()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
name, tot, used, util := queryGPU(ctx)
|
|
if name != "" {
|
|
m.GPUName = name
|
|
m.GPUTotal = tot
|
|
m.GPUUsed = used
|
|
m.GPUUtil = util
|
|
m.GPUProcesses = queryGPUProcesses(ctx)
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// GetManPage returns the plain-text man page for the given command name.
|
|
// Returns an empty string if man is not installed or the page does not exist.
|
|
func GetManPage(name string) string {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second)
|
|
defer cancel()
|
|
cmd := exec.CommandContext(ctx, "man", "-P", "cat", name)
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
// Strip nroff backspace-based bold/underline formatting (char + backspace + char)
|
|
raw := []byte(out)
|
|
cleaned := make([]byte, 0, len(raw))
|
|
for i := 0; i < len(raw); i++ {
|
|
if i+1 < len(raw) && raw[i+1] == '\b' {
|
|
i++ // skip formatting char and backspace; the real char follows
|
|
} else {
|
|
cleaned = append(cleaned, raw[i])
|
|
}
|
|
}
|
|
text := strings.TrimSpace(string(cleaned))
|
|
if len(text) > 12000 {
|
|
text = text[:12000] + "\n…[truncated]"
|
|
}
|
|
return text
|
|
} |