Sistema

Consultar información del sistema en tiempo de ejecución incluyendo uso de memoria, estadísticas de recolección de basura, detalles de CPU y metadatos de proceso.

Carga

local system = require("system")

Apagado

Desencadenar el apagado del sistema con código de salida. Útil para aplicaciones de terminal; llamar desde actores en ejecución terminará todo el sistema:

local ok, err = system.exit(0)

Devuelve: boolean, error

Listar Módulos

Obtener todos los módulos Lua cargados con metadatos:

local mods, err = system.modules()

Devuelve: table[], error

Cada tabla de módulo contiene:

Estadísticas de Memoria

Obtener estadísticas detalladas de memoria:

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

Devuelve: table, error

La tabla de estadísticas contiene:

Asignación Actual

Obtener los bytes actualmente asignados:

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

Devuelve: number, error

Objetos del Heap

Obtener el número de objetos de heap asignados:

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

Devuelve: number, error

Límite de Memoria

Establecer el límite de memoria (devuelve el valor anterior):

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

Devuelve: number, error

Obtener el límite de memoria actual:

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

Devuelve: number, error

Forzar GC

Forzar la recolección de basura:

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

Devuelve: boolean, error

Porcentaje Objetivo del GC

Establecer el porcentaje objetivo del GC (devuelve el valor anterior). Un valor de 100 significa que el GC se activa cuando el heap se duplica:

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

Devuelve: number, error

Obtener el porcentaje objetivo del GC actual:

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

Devuelve: number, error

Recuento de Goroutines

Obtener el número de goroutines activas:

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

Devuelve: number, error

GOMAXPROCS

Obtener o establecer el valor de GOMAXPROCS:

-- Obtener valor actual
local current, err = system.runtime.max_procs()

-- Establecer nuevo valor
local prev, err = system.runtime.max_procs(4)

Devuelve: number, error

Recuento de CPUs

Obtener el número de CPUs lógicas:

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

Devuelve: number, error

ID de Proceso

Obtener el ID del proceso actual:

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

Devuelve: number, error

Hostname

Obtener el hostname del sistema:

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

Devuelve: string, error

Directorio de Trabajo

Obtener el directorio de trabajo actual del runtime:

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

Devuelve: string, error

Hosts de Proceso

Listar todos los hosts de proceso con estadísticas de workers y colas:

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

Devuelve: table[], error

Cada tabla de host contiene:

Listar procesos ejecutándose en un host específico:

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

Devuelve: table[], error

Cada tabla de proceso contiene:

Estado del Servicio

Obtener el estado de un servicio supervisado específico:

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

Devuelve: table, error

La tabla de estado contiene:

Todos los Estados de Servicios

Obtener los estados de todos los servicios supervisados:

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

Devuelve: table[], error

Cada tabla de estado tiene el mismo formato que system.supervisor.state().

Primitivas del Cluster

Las sub-tablas system.node, system.cluster, system.raft y system.lock exponen la capa de clustering. Son más útiles cuando el clustering está habilitado; en un nodo independiente degradan de forma predecible — system.raft.* reporta "raft not available", system.cluster reporta solo el nodo local, y system.lock requiere el registro global que proporciona el clustering.

Todas las llamadas de lectura son locales y baratas: reportan la vista de este nodo del estado confirmado, sin bloquear nunca en la red.

Identidad del nodo

system.node reporta la propia identidad de este nodo en el cluster.

local id, err = system.node.id()      -- ID de este nodo
local addr, err = system.node.addr()  -- dirección de red anunciada
local role, err = system.node.role()  -- "leader" | "voter" | "standby" | "non-member"

Permiso: system.read sobre node.

Membresía del cluster

system.cluster reporta la vista a nivel de cluster: quiénes son los miembros y quién lidera.

local members, err = system.cluster.members()  -- array de tablas de nodo
local leader, err = system.cluster.leader()    -- ID del nodo líder, o "" si desconocido
local n, err = system.cluster.size()           -- recuento de miembros visibles

system.cluster.members() devuelve un array de tablas de nodo. El nodo local se incluye una vez y aparece primero.

Permiso: system.read sobre cluster.

Estado de Raft

system.raft lee la vista local de este nodo del núcleo de consenso Raft. Cada función devuelve nil, error ("raft not available") cuando Raft no está ejecutándose en este nodo.

local leader, err = system.raft.is_leader()      -- boolean
local member, err = system.raft.is_member()      -- boolean: voter o standby
local role, err = system.raft.role()             -- mismos valores que system.node.role()
local term, err = system.raft.term()             -- término Raft actual
local idx, err = system.raft.commit_index()      -- índice de log confirmado más alto
local stats, err = system.raft.stats()           -- mapa de estadísticas raw (string -> string)

Permiso: system.read sobre raft, excepto system.raft.stats() que requiere system.read sobre raft_stats.

Bloqueos distribuidos

system.lock proporciona exclusión mutua a nivel de cluster. Un bloqueo es un nombre globalmente único propiedad del proceso que llama. Está construido sobre el ámbito de nombre Strong, por lo que puede existir como máximo un titular en todo el cluster, y el bloqueo se libera automáticamente cuando el proceso titular sale o su nodo se va — no hay bloqueo atascado que limpiar.

local ok, err = system.lock.acquire("orders.migration")
if ok then
  -- sección crítica: solo un titular en todo el cluster
  system.lock.release("orders.migration")
end

Acquire es fail-fast: si el bloqueo ya está tomado devuelve false inmediatamente en lugar de bloquear, por lo que los callers implementan su propio retry y backoff. Solo el titular actual puede liberar; liberar un bloqueo que no se posee es un no-op seguro.

Permiso: system.lock sobre el name del bloqueo (de modo que la política puede restringir qué nombres puede bloquear un caller).

Permisos

Las operaciones del sistema están sujetas a evaluación de política de seguridad.

Errores

Consulte Manejo de Errores para trabajar con errores.