System

Abfragen von Laufzeit-Systeminformationen einschließlich Speicherverbrauch, Garbage-Collection-Statistiken, CPU-Details und Prozess-Metadaten.

Laden

local system = require("system")

Shutdown

Systemshutdown mit Exit-Code auslösen. Nützlich für Terminal-Apps; Aufruf aus laufenden Actors beendet das gesamte System:

local ok, err = system.exit(0)

Gibt zurück: boolean, error

Module auflisten

Alle geladenen Lua-Module mit Metadaten abrufen:

local mods, err = system.modules()

Gibt zurück: table[], error

Jede Modul-Tabelle enthält:

Speicherstatistiken

Detaillierte Speicherstatistiken abrufen:

local stats, err = system.memory.stats()

Gibt zurück: table, error

Stats-Tabelle enthält:

Aktuelle Zuweisung

Aktuell zugewiesene Bytes abrufen:

local bytes, err = system.memory.allocated()

Gibt zurück: number, error

Heap-Objekte

Anzahl zugewiesener Heap-Objekte abrufen:

local count, err = system.memory.heap_objects()

Gibt zurück: number, error

Speicherlimit

Speicherlimit setzen (gibt vorherigen Wert zurück):

local prev, err = system.memory.set_limit(1024 * 1024 * 100)

Gibt zurück: number, error

Aktuelles Speicherlimit abrufen:

local limit, err = system.memory.get_limit()

Gibt zurück: number, error

GC erzwingen

Garbage Collection erzwingen:

local ok, err = system.gc.collect()

Gibt zurück: boolean, error

GC-Zielprozentsatz

GC-Zielprozentsatz setzen (gibt vorherigen Wert zurück). Ein Wert von 100 bedeutet, dass GC ausgelöst wird, wenn sich der Heap verdoppelt:

local prev, err = system.gc.set_percent(200)

Gibt zurück: number, error

Aktuellen GC-Zielprozentsatz abrufen:

local percent, err = system.gc.get_percent()

Gibt zurück: number, error

Goroutine-Anzahl

Anzahl aktiver Goroutines abrufen:

local count, err = system.runtime.goroutines()

Gibt zurück: number, error

GOMAXPROCS

GOMAXPROCS-Wert abrufen oder setzen:

-- Aktuellen Wert abrufen
local current, err = system.runtime.max_procs()

-- Neuen Wert setzen
local prev, err = system.runtime.max_procs(4)

Gibt zurück: number, error

CPU-Anzahl

Anzahl logischer CPUs abrufen:

local cpus, err = system.runtime.cpu_count()

Gibt zurück: number, error

Prozess-ID

Aktuelle Prozess-ID abrufen:

local pid, err = system.process.pid()

Gibt zurück: number, error

Hostname

System-Hostname abrufen:

local hostname, err = system.process.hostname()

Gibt zurück: string, error

Arbeitsverzeichnis

Aktuelles Arbeitsverzeichnis der Laufzeit abrufen:

local dir, err = system.process.cwd()

Gibt zurück: string, error

Prozess-Hosts

Alle Prozess-Hosts mit Worker- und Queue-Statistiken auflisten:

local hosts, err = system.hosts.list()

Gibt zurück: table[], error

Jede Host-Tabelle enthält:

Auf einem bestimmten Host laufende Prozesse auflisten:

local procs, err = system.hosts.processes("app:host")

Gibt zurück: table[], error

Jede Prozess-Tabelle enthält:

Service-Status

Status für einen spezifischen überwachten Service abrufen:

local state, err = system.supervisor.state("namespace:service")

Gibt zurück: table, error

Status-Tabelle enthält:

Alle Service-Status

Status für alle überwachten Services abrufen:

local states, err = system.supervisor.states()

Gibt zurück: table[], error

Jede Status-Tabelle hat das gleiche Format wie system.supervisor.state().

Cluster-Primitive

Die Subtabellen system.node, system.cluster, system.raft und system.lock legen die Clustering-Schicht frei. Sie sind am nützlichsten, wenn Clustering aktiviert ist; auf einem Einzelknoten degradieren sie vorhersagbar — system.raft.* meldet "raft not available", system.cluster meldet nur den lokalen Knoten, und system.lock erfordert die globale Registry, die Clustering bereitstellt.

Alle Leseaufrufe sind lokal und günstig: sie melden die Sicht dieses Knotens auf den committierten Zustand, ohne je das Netzwerk zu blockieren.

Knotenidentität

system.node meldet die eigene Identität dieses Knotens im Cluster.

local id, err = system.node.id()      -- ID dieses Knotens
local addr, err = system.node.addr()  -- beworbene Netzwerkadresse
local role, err = system.node.role()  -- "leader" | "voter" | "standby" | "non-member"

Berechtigung: system.read auf node.

Cluster-Mitgliedschaft

system.cluster meldet die clusterweite Sicht: wer die Mitglieder sind und wer führt.

local members, err = system.cluster.members()  -- Array von Knoten-Tabellen
local leader, err = system.cluster.leader()    -- Leader-Knoten-ID oder "" wenn unbekannt
local n, err = system.cluster.size()           -- Anzahl sichtbarer Mitglieder

system.cluster.members() gibt ein Array von Knoten-Tabellen zurück. Der lokale Knoten ist einmal enthalten und sortiert zuerst.

Berechtigung: system.read auf cluster.

Raft-Zustand

system.raft liest die lokale Sicht dieses Knotens auf den Raft-Konsenskern. Jede Funktion gibt nil, error ("raft not available") zurück, wenn Raft auf diesem Knoten nicht läuft.

local leader, err = system.raft.is_leader()      -- boolean
local member, err = system.raft.is_member()      -- boolean: Voter oder Standby
local role, err = system.raft.role()             -- gleiche Werte wie system.node.role()
local term, err = system.raft.term()             -- aktueller Raft-Term
local idx, err = system.raft.commit_index()      -- höchster committierter Log-Index
local stats, err = system.raft.stats()           -- rohe Stats-Map (string -> string)

Berechtigung: system.read auf raft, außer system.raft.stats(), das system.read auf raft_stats erfordert.

Verteilte Sperren

system.lock bietet clusterweiten gegenseitigen Ausschluss. Eine Sperre ist ein global eindeutiger Name, der dem aufrufenden Prozess gehört. Sie baut auf dem Strong-Namens-Scope auf, sodass höchstens ein Halter clusterweit existieren kann, und die Sperre wird automatisch freigegeben, wenn der Halterprozess endet oder sein Knoten ausscheidet — es gibt keine steckengebliebene Sperre zu bereinigen.

local ok, err = system.lock.acquire("orders.migration")
if ok then
  -- kritischer Abschnitt: nur ein Halter clusterweit
  system.lock.release("orders.migration")
end

Erwerben ist fail-fast: wenn die Sperre bereits gehalten wird, gibt es sofort false zurück statt zu blockieren, sodass Aufrufer eigenes Retry und Backoff implementieren. Nur der aktuelle Halter kann freigeben; eine Sperre freizugeben, die man nicht hält, ist ein sicheres No-Op.

Berechtigung: system.lock auf dem Sperren-name (sodass eine Richtlinie einschränken kann, welche Namen ein Aufrufer sperren darf).

Berechtigungen

Systemoperationen unterliegen der Sicherheitsrichtlinienauswertung.

Fehler

Siehe Fehlerbehandlung für die Arbeit mit Fehlern.