🥮 mooncakes.io

sysinfo

System metrics and process inspection library.

sysinfo
metrics
moon add Milky2018/sysinfo@0.1.2
Download zip
Author
Version
0.1.2
License
Apache-2.0
Repository
Last updated
4 months ago
Downloads
718

Dependencies

README

#Milky2018/sysinfo

A MoonBit-native system metrics and process inspection library for Linux and macOS.

#Status

  • native target only.
  • Linux: fully supported.
  • macOS: fully supported.
  • Other OSes: unsupported semantics (is_supported_system == false, APIs return None, empty collections, or no-op defaults instead of panicking).

#Install

moon add Milky2018/sysinfo

#Quick Start

let system = @sysinfo.System::new_all()

println("supported=\{@sysinfo.is_supported_system}")
println("total_memory=\{system.total_memory()}")
println("used_memory=\{system.used_memory()}")
println("cpu_usage=\{system.global_cpu_usage()}")
println("process_count=\{system.processes().size()}")

#Refresh Semantics

sysinfo-style delta metrics require at least two refreshes with an interval:

  • CPU usage
  • Network traffic deltas
  • Process CPU usage

MINIMUM_CPU_UPDATE_INTERVAL is fixed to 200 ms.

let system = @sysinfo.System::new_all()
system.refresh_cpu_usage()

sleep(220)

system.refresh_cpu_usage()
let usage = system.global_cpu_usage()

#Main API Surface

  • System: System, RefreshKind, CpuRefreshKind, MemoryRefreshKind, ProcessRefreshKind
  • Process: Process, Pid, Uid, Gid, ProcessStatus, ThreadKind, Signal, KillError
  • CPU: Cpu
  • Disks: Disks, Disk, DiskKind, DiskRefreshKind, DiskUsage
  • Networks: Networks, NetworkData, MacAddr, IpNetwork
  • Components: Components, Component
  • Users/Groups: Users, User, Groups, Group
  • Globals: is_supported_system, MINIMUM_CPU_UPDATE_INTERVAL, supported_signals

#Process Control

Supported process-control APIs:

  • Process::kill()
  • Process::kill_with(signal)
  • Process::wait()
  • Process::kill_and_wait()
  • Process::kill_with_and_wait(signal)

On unsupported systems, these return unsupported-safe values (None/Err(KillError::Unsupported)), matching the library's non-panicking downgrade policy.

#Notes

  • set_open_files_limit and System::open_files_limit follow upstream behavior:
    • Linux: implemented.
    • macOS: set returns false; query may return a system limit when available.
  • supported_signals exposes the signal list supported by this binding.

#
CGroupLimits

source
pub(all) struct CGroupLimits {
  total_memory : UInt64
  free_memory : UInt64
  free_swap : UInt64
} derive(Eq, 
Debug)

#
Component

source
pub(all) struct Component {
  temperature : Double?
  max : Double?
  critical : Double?
  label : String
  id : String?
} derive(Eq, 
Debug)

impl Show for Component

#
Component::critical

source
fn Component::critical(self : Component) -> Double?

#
Component::id

source
fn Component::id(self : Component) -> String?

#
Component::label

source
fn Component::label(self : Component) -> String

#
Component::max

source
fn Component::max(self : Component) -> Double?

#
Component::refresh

source
fn Component::refresh(self : Component) -> Unit

#
Component::temperature

source
fn Component::temperature(self : Component) -> Double?

#
Components

source
pub(all) struct Components {
  components_data : Array[Component]
} derive(
Debug)

impl Show for Components

#
Components::list

source
fn Components::list(self : Components) -> Array[Component]

#
Components::list_mut

source
fn Components::list_mut(self : Components) -> Array[Component]

#
Components::new

source
fn Components::new() -> Components

#
Components::new_with_refreshed_list

source
fn Components::new_with_refreshed_list() -> Components

#
Components::refresh

source
fn Components::refresh(self : Components, remove_not_listed_components : Bool) -> Unit

#
Cpu

source
pub(all) struct Cpu {
  name : String
  vendor_id : String
  brand : String
  frequency : UInt64
  cpu_usage : Double
} derive(Eq, 
Debug)

impl Show for Cpu

#
Cpu::brand

source
fn Cpu::brand(self : Cpu) -> String

#
Cpu::cpu_usage

source
fn Cpu::cpu_usage(self : Cpu) -> Double

#
Cpu::frequency

source
fn Cpu::frequency(self : Cpu) -> UInt64

#
Cpu::name

source
fn Cpu::name(self : Cpu) -> String

#
Cpu::vendor_id

source
fn Cpu::vendor_id(self : Cpu) -> String

#
CpuRefreshKind

source
pub(all) struct CpuRefreshKind {
  cpu_usage : Bool
  frequency : Bool
} derive(Eq, 
Debug)

#
CpuRefreshKind::cpu_usage

source
fn CpuRefreshKind::cpu_usage(self : CpuRefreshKind) -> Bool

#
CpuRefreshKind::everything

source
fn CpuRefreshKind::everything() -> CpuRefreshKind

#
CpuRefreshKind::frequency

source
fn CpuRefreshKind::frequency(self : CpuRefreshKind) -> Bool

#
CpuRefreshKind::nothing

source

#
CpuRefreshKind::with_cpu_usage

source
fn CpuRefreshKind::with_cpu_usage(self : CpuRefreshKind) -> CpuRefreshKind

#
CpuRefreshKind::with_frequency

source
fn CpuRefreshKind::with_frequency(self : CpuRefreshKind) -> CpuRefreshKind

#
CpuRefreshKind::without_cpu_usage

source
fn CpuRefreshKind::without_cpu_usage(self : CpuRefreshKind) -> CpuRefreshKind

#
CpuRefreshKind::without_frequency

source
fn CpuRefreshKind::without_frequency(self : CpuRefreshKind) -> CpuRefreshKind

#
CpuSnapshot

source
type CpuSnapshot derive(Eq, 
Debug)

impl Show for CpuSnapshot

#
Disk

source
pub(all) struct Disk {
  kind : DiskKind
  name : String
  file_system : String
  mount_point : String
  total_space : UInt64
  available_space : UInt64
  is_removable : Bool
  is_read_only : Bool
  usage : DiskUsage
} derive(Eq, 
Debug)

impl Show for Disk

#
Disk::available_space

source
fn Disk::available_space(self : Disk) -> UInt64

#
Disk::file_system

source
fn Disk::file_system(self : Disk) -> String

#
Disk::is_read_only

source
fn Disk::is_read_only(self : Disk) -> Bool

#
Disk::is_removable

source
fn Disk::is_removable(self : Disk) -> Bool

#
Disk::kind

source
fn Disk::kind(self : Disk) -> DiskKind

#
Disk::mount_point

source
fn Disk::mount_point(self : Disk) -> String

#
Disk::name

source
fn Disk::name(self : Disk) -> String

#
Disk::refresh

source
fn Disk::refresh(self : Disk) -> Bool

#
Disk::refresh_specifics

source
fn Disk::refresh_specifics(self : Disk, refreshes : DiskRefreshKind) -> Bool

#
Disk::total_space

source
fn Disk::total_space(self : Disk) -> UInt64

#
Disk::usage

source
fn Disk::usage(self : Disk) -> DiskUsage

#
DiskIoSnapshot

source
type DiskIoSnapshot derive(Eq, 
Debug)

#
DiskKind

source
pub(all) enum DiskKind {
  HDD
  SSD
  Unknown(String)
} derive(Eq, 
Debug)

impl Show for DiskKind

#
DiskRefreshKind

source
pub(all) struct DiskRefreshKind {
  kind : Bool
  storage : Bool
  io_usage : Bool
} derive(Eq, 
Debug)

#
DiskRefreshKind::everything

source
fn DiskRefreshKind::everything() -> DiskRefreshKind

#
DiskRefreshKind::io_usage

source
fn DiskRefreshKind::io_usage(self : DiskRefreshKind) -> Bool

#
DiskRefreshKind::kind

source
fn DiskRefreshKind::kind(self : DiskRefreshKind) -> Bool

#
DiskRefreshKind::nothing

source

#
DiskRefreshKind::storage

source
fn DiskRefreshKind::storage(self : DiskRefreshKind) -> Bool

#
DiskRefreshKind::with_io_usage

source
fn DiskRefreshKind::with_io_usage(self : DiskRefreshKind) -> DiskRefreshKind

#
DiskRefreshKind::with_kind

source

#
DiskRefreshKind::with_storage

source
fn DiskRefreshKind::with_storage(self : DiskRefreshKind) -> DiskRefreshKind

#
DiskRefreshKind::without_io_usage

source
fn DiskRefreshKind::without_io_usage(self : DiskRefreshKind) -> DiskRefreshKind

#
DiskRefreshKind::without_kind

source
fn DiskRefreshKind::without_kind(self : DiskRefreshKind) -> DiskRefreshKind

#
DiskRefreshKind::without_storage

source
fn DiskRefreshKind::without_storage(self : DiskRefreshKind) -> DiskRefreshKind

#
DiskUsage

source
pub(all) struct DiskUsage {
  total_read_bytes : UInt64
  read_bytes : UInt64
  total_written_bytes : UInt64
  written_bytes : UInt64
} derive(Eq, 
Debug)

impl Show for DiskUsage

#
DiskUsage::zero

source
fn DiskUsage::zero() -> DiskUsage

#
Disks

source
pub(all) struct Disks {
  disks_data : Array[Disk]
} derive(
Debug)

impl Show for Disks

#
Disks::list

source
fn Disks::list(self : Disks) -> Array[Disk]

#
Disks::list_mut

source
fn Disks::list_mut(self : Disks) -> Array[Disk]

#
Disks::new

source
fn Disks::new() -> Disks

#
Disks::new_with_refreshed_list

source
fn Disks::new_with_refreshed_list() -> Disks

#
Disks::new_with_refreshed_list_specifics

source
fn Disks::new_with_refreshed_list_specifics(refreshes : DiskRefreshKind) -> Disks

#
Disks::refresh

source
fn Disks::refresh(self : Disks, remove_not_listed_disks : Bool) -> Unit

#
Disks::refresh_specifics

source
fn Disks::refresh_specifics(self : Disks, remove_not_listed_disks : Bool, refreshes : DiskRefreshKind) -> Unit

#
ExitStatus

source
pub(all) struct ExitStatus {
  code : Int?
  signal : Signal?
  success : Bool
} derive(Eq, 
Debug)

impl Show for ExitStatus

#
ExitStatus::from_code

source
fn ExitStatus::from_code(code : Int) -> ExitStatus

#
ExitStatus::from_signal

source
fn ExitStatus::from_signal(signal : Signal) -> ExitStatus

#
Gid

source
pub(all) struct Gid {
  value : Int
} derive(Compare, Eq, Hash, 
Debug)

impl Show for Gid

#
Gid::from

source
fn Gid::from(value : Int) -> Gid

#
Gid::to_int

source
fn Gid::to_int(self : Gid) -> Int

#
Group

source
pub(all) struct Group {
  id : Gid
  name : String
} derive(Eq, 
Debug)

impl Show for Group

#
Group::id

source
fn Group::id(self : Group) -> Gid

#
Group::name

source
fn Group::name(self : Group) -> String

#
Groups

source
pub(all) struct Groups {
  groups_data : Array[Group]
} derive(
Debug)

impl Show for Groups

#
Groups::list

source
fn Groups::list(self : Groups) -> Array[Group]

#
Groups::list_mut

source
fn Groups::list_mut(self : Groups) -> Array[Group]

#
Groups::new

source
fn Groups::new() -> Groups

#
Groups::new_with_refreshed_list

source
fn Groups::new_with_refreshed_list() -> Groups

#
Groups::refresh

source
fn Groups::refresh(self : Groups) -> Unit

#
IpNetwork

source
pub(all) struct IpNetwork {
  raw : String
} derive(Eq, 
Debug)

impl Show for IpNetwork

#
IpNetwork::to_string

source
fn IpNetwork::to_string(self : IpNetwork) -> String

#
KillError

source
pub(all) enum KillError {
  Unsupported
  NotFound
  PermissionDenied
  Timeout
  WaitFailed
  Unknown(String)
} derive(Eq, 
Debug)

impl Show for KillError

#
LoadAvg

source
pub(all) struct LoadAvg {
  one : Double
  five : Double
  fifteen : Double
} derive(Eq, 
Debug)

impl Show for LoadAvg

#
LoadAvg::zero

source
fn LoadAvg::zero() -> LoadAvg

#
MacAddr

source
pub(all) struct MacAddr {
  raw : String
} derive(Eq, 
Debug)

impl Show for MacAddr

#
MacAddr::is_unspecified

source
fn MacAddr::is_unspecified(self : MacAddr) -> Bool

#
MacAddr::to_string

source
fn MacAddr::to_string(self : MacAddr) -> String

#
MacosDiskInfo

source
type MacosDiskInfo derive(Eq, 
Debug)

#
MemoryRefreshKind

source
pub(all) struct MemoryRefreshKind {
  ram : Bool
  swap : Bool
} derive(Eq, 
Debug)

#
MemoryRefreshKind::everything

source

#
MemoryRefreshKind::nothing

source

#
MemoryRefreshKind::ram

source
fn MemoryRefreshKind::ram(self : MemoryRefreshKind) -> Bool

#
MemoryRefreshKind::swap

source
fn MemoryRefreshKind::swap(self : MemoryRefreshKind) -> Bool

#
MemoryRefreshKind::with_ram

source

#
MemoryRefreshKind::with_swap

source

#
MemoryRefreshKind::without_ram

source

#
MemoryRefreshKind::without_swap

source

#
MountEntry

source
type MountEntry derive(Eq, 
Debug)

impl Show for MountEntry

#
NetworkData

source
pub(all) struct NetworkData {
  received : UInt64
  total_received : UInt64
  transmitted : UInt64
  total_transmitted : UInt64
  packets_received : UInt64
  total_packets_received : UInt64
  packets_transmitted : UInt64
  total_packets_transmitted : UInt64
  errors_on_received : UInt64
  total_errors_on_received : UInt64
  errors_on_transmitted : UInt64
  total_errors_on_transmitted : UInt64
  mac_address : MacAddr
  ip_networks : Array[IpNetwork]
  mtu : UInt64
} derive(Eq, 
Debug)

impl Show for NetworkData

#
NetworkData::errors_on_received

source
fn NetworkData::errors_on_received(self : NetworkData) -> UInt64

#
NetworkData::errors_on_transmitted

source
fn NetworkData::errors_on_transmitted(self : NetworkData) -> UInt64

#
NetworkData::ip_networks

source
fn NetworkData::ip_networks(self : NetworkData) -> Array[IpNetwork]

#
NetworkData::mac_address

source
fn NetworkData::mac_address(self : NetworkData) -> MacAddr

#
NetworkData::mtu

source
fn NetworkData::mtu(self : NetworkData) -> UInt64

#
NetworkData::packets_received

source
fn NetworkData::packets_received(self : NetworkData) -> UInt64

#
NetworkData::packets_transmitted

source
fn NetworkData::packets_transmitted(self : NetworkData) -> UInt64

#
NetworkData::received

source
fn NetworkData::received(self : NetworkData) -> UInt64

#
NetworkData::total_errors_on_received

source
fn NetworkData::total_errors_on_received(self : NetworkData) -> UInt64

#
NetworkData::total_errors_on_transmitted

source
fn NetworkData::total_errors_on_transmitted(self : NetworkData) -> UInt64

#
NetworkData::total_packets_received

source
fn NetworkData::total_packets_received(self : NetworkData) -> UInt64

#
NetworkData::total_packets_transmitted

source
fn NetworkData::total_packets_transmitted(self : NetworkData) -> UInt64

#
NetworkData::total_received

source
fn NetworkData::total_received(self : NetworkData) -> UInt64

#
NetworkData::total_transmitted

source
fn NetworkData::total_transmitted(self : NetworkData) -> UInt64

#
NetworkData::transmitted

source
fn NetworkData::transmitted(self : NetworkData) -> UInt64

#
Networks

source
pub(all) struct Networks {
  networks_data : Map[String, NetworkData]
} derive(
Debug)

impl Show for Networks

#
Networks::list

source
fn Networks::list(self : Networks) -> Map[String, NetworkData]

#
Networks::new

source
fn Networks::new() -> Networks

#
Networks::new_with_refreshed_list

source
fn Networks::new_with_refreshed_list() -> Networks

#
Networks::refresh

source
fn Networks::refresh(self : Networks, remove_not_listed_interfaces : Bool) -> Unit

#
Pid

source
pub(all) struct Pid {
  value : Int
} derive(Compare, Eq, Hash, 
Debug)

impl Show for Pid

#
Pid::as_u32

source
fn Pid::as_u32(self : Pid) -> UInt

#
Pid::from

source
fn Pid::from(value : Int) -> Pid

#
Pid::from_u32

source
fn Pid::from_u32(value : UInt) -> Pid

#
Pid::to_int

source
fn Pid::to_int(self : Pid) -> Int

#
Process

source
pub(all) struct Process {
  pid : Pid
  parent : Pid?
  name : String
  cmd : Array[String]
  environ : Array[String]
  exe : String?
  cwd : String?
  root : String?
  memory : UInt64
  virtual_memory : UInt64
  status : ProcessStatus
  start_time : UInt64
  run_time : UInt64
  cpu_usage : Double
  accumulated_cpu_time : UInt64
  disk_usage : DiskUsage
  user_id : Uid?
  effective_user_id : Uid?
  group_id : Gid?
  effective_group_id : Gid?
  session_id : Pid?
  tasks : Array[Pid]?
  thread_kind : ThreadKind?
  open_files : Int?
  open_files_limit : Int?
} derive(Eq, 
Debug)

impl Show for Process

#
Process::accumulated_cpu_time

source
fn Process::accumulated_cpu_time(self : Process) -> UInt64

#
Process::cmd

source
fn Process::cmd(self : Process) -> Array[String]

#
Process::cpu_usage

source
fn Process::cpu_usage(self : Process) -> Double

#
Process::cwd

source
fn Process::cwd(self : Process) -> String?

#
Process::disk_usage

source
fn Process::disk_usage(self : Process) -> DiskUsage

#
Process::effective_group_id

source
fn Process::effective_group_id(self : Process) -> Gid?

#
Process::effective_user_id

source
fn Process::effective_user_id(self : Process) -> Uid?

#
Process::environ

source
fn Process::environ(self : Process) -> Array[String]

#
Process::exe

source
fn Process::exe(self : Process) -> String?

#
Process::exists

source
fn Process::exists(self : Process) -> Bool

#
Process::group_id

source
fn Process::group_id(self : Process) -> Gid?

#
Process::kill

source
fn Process::kill(self : Process) -> Bool

#
Process::kill_and_wait

source
fn Process::kill_and_wait(self : Process) -> Result[ExitStatus?, KillError]

#
Process::kill_with

source
fn Process::kill_with(self : Process, signal : Signal) -> Bool?

#
Process::kill_with_and_wait

source
fn Process::kill_with_and_wait(self : Process, signal : Signal) -> Result[ExitStatus?, KillError]

#
Process::memory

source
fn Process::memory(self : Process) -> UInt64

#
Process::name

source
fn Process::name(self : Process) -> String

#
Process::open_files

source
fn Process::open_files(self : Process) -> Int?

#
Process::open_files_limit

source
fn Process::open_files_limit(self : Process) -> Int?

#
Process::parent

source
fn Process::parent(self : Process) -> Pid?

#
Process::pid

source
fn Process::pid(self : Process) -> Pid

#
Process::root

source
fn Process::root(self : Process) -> String?

#
Process::run_time

source
fn Process::run_time(self : Process) -> UInt64

#
Process::session_id

source
fn Process::session_id(self : Process) -> Pid?

#
Process::start_time

source
fn Process::start_time(self : Process) -> UInt64

#
Process::status

source
fn Process::status(self : Process) -> ProcessStatus

#
Process::tasks

source
fn Process::tasks(self : Process) -> Array[Pid]?

#
Process::thread_kind

source
fn Process::thread_kind(self : Process) -> ThreadKind?

#
Process::user_id

source
fn Process::user_id(self : Process) -> Uid?

#
Process::virtual_memory

source
fn Process::virtual_memory(self : Process) -> UInt64

#
Process::wait

source
fn Process::wait(self : Process) -> ExitStatus?

#
ProcessRefreshKind

source
pub(all) struct ProcessRefreshKind {
  cpu : Bool
  disk_usage : Bool
  memory : Bool
  user : UpdateKind
  cwd : UpdateKind
  root : UpdateKind
  environ : UpdateKind
  cmd : UpdateKind
  exe : UpdateKind
  tasks : Bool
} derive(Eq, 
Debug)

#
ProcessRefreshKind::cmd

source

#
ProcessRefreshKind::cpu

source
fn ProcessRefreshKind::cpu(self : ProcessRefreshKind) -> Bool

#
ProcessRefreshKind::cwd

source

#
ProcessRefreshKind::disk_usage

source
fn ProcessRefreshKind::disk_usage(self : ProcessRefreshKind) -> Bool

#
ProcessRefreshKind::environ

source

#
ProcessRefreshKind::everything

source

#
ProcessRefreshKind::exe

source

#
ProcessRefreshKind::memory

source
fn ProcessRefreshKind::memory(self : ProcessRefreshKind) -> Bool

#
ProcessRefreshKind::nothing

source

#
ProcessRefreshKind::root

source

#
ProcessRefreshKind::tasks

source
fn ProcessRefreshKind::tasks(self : ProcessRefreshKind) -> Bool

#
ProcessRefreshKind::user

source

#
ProcessRefreshKind::with_cmd

source

#
ProcessRefreshKind::with_cpu

source

#
ProcessRefreshKind::with_cwd

source

#
ProcessRefreshKind::with_disk_usage

source

#
ProcessRefreshKind::with_environ

source

#
ProcessRefreshKind::with_exe

source

#
ProcessRefreshKind::with_memory

source

#
ProcessRefreshKind::with_root

source

#
ProcessRefreshKind::with_tasks

source

#
ProcessRefreshKind::with_user

source

#
ProcessRefreshKind::without_cmd

source

#
ProcessRefreshKind::without_cpu

source

#
ProcessRefreshKind::without_cwd

source

#
ProcessRefreshKind::without_disk_usage

source
fn ProcessRefreshKind::without_disk_usage(self : ProcessRefreshKind) -> ProcessRefreshKind

#
ProcessRefreshKind::without_environ

source

#
ProcessRefreshKind::without_exe

source

#
ProcessRefreshKind::without_memory

source

#
ProcessRefreshKind::without_root

source

#
ProcessRefreshKind::without_tasks

source

#
ProcessRefreshKind::without_user

source

#
ProcessStatus

source
pub(all) enum ProcessStatus {
  Dead
  Idle
  LockBlocked
  Parked
  Run
  Sleep
  Stop
  Suspended
  Tracing
  UninterruptibleDiskSleep
  Unknown(Int)
  Wakekill
  Waking
  Zombie
} derive(Eq, 
Debug)

#
ProcessesToUpdate

source
pub(all) enum ProcessesToUpdate {
  All
  Selected(Array[Pid])
} derive(Eq, 
Debug)

#
RefreshKind

source
pub(all) struct RefreshKind {
  processes : ProcessRefreshKind?
  memory : MemoryRefreshKind?
  cpu : CpuRefreshKind?
} derive(Eq, 
Debug)

impl Show for RefreshKind

#
RefreshKind::cpu

source

#
RefreshKind::everything

source
fn RefreshKind::everything() -> RefreshKind

#
RefreshKind::memory

source

#
RefreshKind::nothing

source
fn RefreshKind::nothing() -> RefreshKind

#
RefreshKind::processes

source
fn RefreshKind::processes(self : RefreshKind) -> ProcessRefreshKind?

#
RefreshKind::with_cpu

source
fn RefreshKind::with_cpu(self : RefreshKind, kind : CpuRefreshKind) -> RefreshKind

#
RefreshKind::with_memory

source
fn RefreshKind::with_memory(self : RefreshKind, kind : MemoryRefreshKind) -> RefreshKind

#
RefreshKind::with_processes

source
fn RefreshKind::with_processes(self : RefreshKind, kind : ProcessRefreshKind) -> RefreshKind

#
RefreshKind::without_cpu

source
fn RefreshKind::without_cpu(self : RefreshKind) -> RefreshKind

#
RefreshKind::without_memory

source
fn RefreshKind::without_memory(self : RefreshKind) -> RefreshKind

#
RefreshKind::without_processes

source
fn RefreshKind::without_processes(self : RefreshKind) -> RefreshKind

#
Signal

source
pub(all) enum Signal {
  Abort
  Alarm
  Bus
  Child
  Continue
  FloatingPointException
  Hangup
  IO
  IOT
  Illegal
  Interrupt
  Kill
  Pipe
  Poll
  Power
  Profiling
  Quit
  Segv
  Stop
  Sys
  TSTP
  TTIN
  TTOU
  Term
  Trap
  Urgent
  User1
  User2
  VirtualAlarm
  Winch
  XCPU
  XFSZ
} derive(Eq, 
Debug)

impl Show for Signal

#
System

source
pub(all) struct System {
  processes_data : Map[Pid, Process]
  cpus_data : Array[Cpu]
  total_memory_data : UInt64
  free_memory_data : UInt64
  available_memory_data : UInt64
  used_memory_data : UInt64
  total_swap_data : UInt64
  free_swap_data : UInt64
  used_swap_data : UInt64
  cgroup_limits_data : CGroupLimits?
  last_cpu_refresh_ms : UInt64
  prev_cpu_snapshots : Array[CpuSnapshot]
  prev_global_cpu_snapshot : CpuSnapshot?
  prev_proc_cpu_total : Map[Pid, UInt64]
  prev_proc_system_total : UInt64
}

#
System::available_memory

source
fn System::available_memory(self : System) -> UInt64

#
System::boot_time

source
fn System::boot_time() -> UInt64

#
System::cgroup_limits

source
fn System::cgroup_limits(self : System) -> CGroupLimits?

#
System::cpu_arch

source
fn System::cpu_arch() -> String

#
System::cpus

source
fn System::cpus(self : System) -> Array[Cpu]

#
System::distribution_id

source
fn System::distribution_id() -> String

#
System::distribution_id_like

source
fn System::distribution_id_like() -> Array[String]

#
System::free_memory

source
fn System::free_memory(self : System) -> UInt64

#
System::free_swap

source
fn System::free_swap(self : System) -> UInt64

#
System::global_cpu_usage

source
fn System::global_cpu_usage(self : System) -> Double

#
System::host_name

source
fn System::host_name() -> String?

#
System::kernel_long_version

source
fn System::kernel_long_version() -> String

#
System::kernel_version

source
fn System::kernel_version() -> String?

#
System::load_average

source
fn System::load_average() -> LoadAvg

#
System::long_os_version

source
fn System::long_os_version() -> String?

#
System::name

source
fn System::name() -> String?

#
System::new

source
fn System::new() -> System

#
System::new_all

source
fn System::new_all() -> System

#
System::new_with_specifics

source
fn System::new_with_specifics(refreshes : RefreshKind) -> System

#
System::open_files_limit

source
fn System::open_files_limit() -> Int?

#
System::os_version

source
fn System::os_version() -> String?

#
System::physical_core_count

source
fn System::physical_core_count() -> Int?

#
System::process

source
fn System::process(self : System, pid : Pid) -> Process?

#
System::processes

source
fn System::processes(self : System) -> Map[Pid, Process]

#
System::processes_by_exact_name

source
fn System::processes_by_exact_name(self : System, name : String) -> Array[(Pid, Process)]

#
System::processes_by_name

source
fn System::processes_by_name(self : System, name : String) -> Array[(Pid, Process)]

#
System::refresh_all

source
fn System::refresh_all(self : System) -> Unit

#
System::refresh_cpu_all

source
fn System::refresh_cpu_all(self : System) -> Unit

#
System::refresh_cpu_frequency

source
fn System::refresh_cpu_frequency(self : System) -> Unit

#
System::refresh_cpu_list

source
fn System::refresh_cpu_list(self : System, refresh_kind : CpuRefreshKind) -> Unit

#
System::refresh_cpu_specifics

source
fn System::refresh_cpu_specifics(self : System, refresh_kind : CpuRefreshKind) -> Unit

#
System::refresh_cpu_usage

source
fn System::refresh_cpu_usage(self : System) -> Unit

#
System::refresh_memory

source
fn System::refresh_memory(self : System) -> Unit

#
System::refresh_memory_specifics

source
fn System::refresh_memory_specifics(self : System, refresh_kind : MemoryRefreshKind) -> Unit

#
System::refresh_processes

source
fn System::refresh_processes(self : System, processes_to_update : ProcessesToUpdate, remove_dead_processes : Bool) -> Int

#
System::refresh_processes_specifics

source
fn System::refresh_processes_specifics(self : System, processes_to_update : ProcessesToUpdate, remove_dead_processes : Bool, refresh_kind : ProcessRefreshKind) -> Int

#
System::refresh_specifics

source
fn System::refresh_specifics(self : System, refreshes : RefreshKind) -> Unit

#
System::total_memory

source
fn System::total_memory(self : System) -> UInt64

#
System::total_swap

source
fn System::total_swap(self : System) -> UInt64

#
System::uptime

source
fn System::uptime() -> UInt64

#
System::used_memory

source
fn System::used_memory(self : System) -> UInt64

#
System::used_swap

source
fn System::used_swap(self : System) -> UInt64

#
ThreadKind

source
pub(all) enum ThreadKind {
  Kernel
  Userland
} derive(Eq, 
Debug)

impl Show for ThreadKind

#
Uid

source
pub(all) struct Uid {
  value : Int
} derive(Compare, Eq, Hash, 
Debug)

impl Show for Uid

#
Uid::from

source
fn Uid::from(value : Int) -> Uid

#
Uid::to_int

source
fn Uid::to_int(self : Uid) -> Int

#
UpdateKind

source
pub(all) enum UpdateKind {
  Never
  Always
  OnlyIfNotSet
} derive(Eq, 
Debug)

impl Show for UpdateKind

#
User

source
pub(all) struct User {
  id : Uid
  group_id : Gid
  name : String
  groups : Array[Group]
} derive(Eq, 
Debug)

impl Show for User

#
User::group_id

source
fn User::group_id(self : User) -> Gid

#
User::groups

source
fn User::groups(self : User) -> Array[Group]

#
User::id

source
fn User::id(self : User) -> Uid

#
User::name

source
fn User::name(self : User) -> String

#
Users

source
pub(all) struct Users {
  users_data : Array[User]
} derive(
Debug)

impl Show for Users

#
Users::get_user_by_id

source
fn Users::get_user_by_id(self : Users, user_id : Uid) -> User?

#
Users::list

source
fn Users::list(self : Users) -> Array[User]

#
Users::list_mut

source
fn Users::list_mut(self : Users) -> Array[User]

#
Users::new

source
fn Users::new() -> Users

#
Users::new_with_refreshed_list

source
fn Users::new_with_refreshed_list() -> Users

#
Users::refresh

source
fn Users::refresh(self : Users) -> Unit

#
MINIMUM_CPU_UPDATE_INTERVAL

source
let MINIMUM_CPU_UPDATE_INTERVAL : Int

#
get_current_pid

source
fn get_current_pid() -> Result[Pid, String]

#
is_supported_system

source
let is_supported_system : Bool

#
set_open_files_limit

source
fn set_open_files_limit(new_limit : Int) -> Bool

#
supported_signals

source
let supported_signals : Array[Signal]

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io