354 lines
14 KiB
Nix
354 lines
14 KiB
Nix
{ config, lib, pkgs, ... }:
|
|
|
|
let
|
|
cfg = config.services.skyg-linux-tracker;
|
|
inherit (lib) mkOption mkEnableOption mkIf mkMerge types;
|
|
|
|
name = "skyg-linux-tracker";
|
|
credDir = "/run/credentials/${name}.service";
|
|
toml = pkgs.formats.toml { };
|
|
|
|
scheme = if cfg.tls.enable then "https" else "http";
|
|
hostName = config.networking.fqdnOrHostName;
|
|
# Names clients use, with the port, so both the Host and the Origin
|
|
# allowlists on /mcp accept them. Entries with a scheme are origins only.
|
|
withPort = h: if lib.hasInfix ":" h then h else "${h}:${toString cfg.port}";
|
|
hosts = lib.unique (map withPort (
|
|
lib.optional (hostName != "") hostName
|
|
++ lib.filter (h: !lib.hasInfix "://" h) cfg.allowedHosts
|
|
));
|
|
|
|
moduleDefaults = {
|
|
server = {
|
|
bind = cfg.bind;
|
|
port = cfg.port;
|
|
allowed_hosts = hosts;
|
|
allowed_origins = map (h: "${scheme}://${h}") (lib.filter (h: !lib.hasInfix "://" h) hosts)
|
|
++ lib.filter (h: lib.hasInfix "://" h) cfg.allowedHosts;
|
|
} // lib.optionalAttrs cfg.tls.enable {
|
|
tls = {
|
|
enabled = true;
|
|
cert_file = "${credDir}/cert";
|
|
key_file = "${credDir}/key";
|
|
};
|
|
};
|
|
auth.db_path = "/var/lib/${name}/db.sqlite";
|
|
} // lib.optionalAttrs cfg.docker.enable {
|
|
sources.docker_socket = "/var/run/docker.sock";
|
|
} // lib.optionalAttrs (cfg.peers.enable || cfg.peers.settings != { } || cfg.peers.peers != { }) {
|
|
peers = peersSection;
|
|
};
|
|
|
|
# Declared peers that stay in the rendered config. A peer with `enable =
|
|
# false` is left out entirely: no credential is shipped for it, and the
|
|
# service refuses to start while an enabled peer's token file is missing.
|
|
enabledPeerNames = lib.attrNames (lib.filterAttrs (_: peer: peer.enable) cfg.peers.peers);
|
|
|
|
# The config file holds paths only. Each peer reads its bearer token from
|
|
# the credential directory, which systemd populates from `tokenFile`, so
|
|
# the service user never needs access to the agenix output.
|
|
renderedPeers = map (
|
|
peerName:
|
|
{
|
|
name = peerName;
|
|
url = cfg.peers.peers.${peerName}.url;
|
|
token_file = "${credDir}/peer-${peerName}";
|
|
allow_plain_http = cfg.peers.peers.${peerName}.allowPlainHttp;
|
|
}
|
|
// lib.optionalAttrs (cfg.peers.peers.${peerName}.caFile != null) {
|
|
ca_file = cfg.peers.peers.${peerName}.caFile;
|
|
}
|
|
) enabledPeerNames;
|
|
|
|
# Only rendered when the feature is in use, so a peer-less deployment keeps
|
|
# the same generated config as before.
|
|
peersSection =
|
|
{ enabled = cfg.peers.enable; }
|
|
// cfg.peers.settings
|
|
// lib.optionalAttrs (renderedPeers != [ ]) { peer = renderedPeers; };
|
|
|
|
settings = lib.recursiveUpdate moduleDefaults cfg.settings;
|
|
configFile = toml.generate "${name}.toml" settings;
|
|
|
|
port = settings.server.port;
|
|
bind = settings.server.bind;
|
|
authEnabled = settings.auth.enabled or true;
|
|
isLoopback = a: lib.hasPrefix "127." a || a == "::1";
|
|
|
|
# Names become file names and TOML keys; the regex is the one the binary
|
|
# enforces, so a bad name fails at build time instead of at startup.
|
|
validPeerName = n: builtins.match "[a-z0-9][a-z0-9_-]{0,31}" n != null;
|
|
# A path literal is rejected by the string type; an interpolated one
|
|
# (`"${./secret}"`) becomes a store path. Reject that too: a token in the
|
|
# store would defeat the whole credential scheme.
|
|
outsideStore = p: !lib.hasPrefix "${builtins.storeDir}/" p;
|
|
peerTokenOk = peer:
|
|
lib.hasPrefix "/" peer.tokenFile && outsideStore peer.tokenFile;
|
|
freeformPeers = cfg.settings.peers.peer or [ ];
|
|
in
|
|
{
|
|
options.services.skyg-linux-tracker = {
|
|
enable = mkEnableOption "skyg-linux-tracker, a read-only systemd/journal/Docker monitor (REST, MCP, OTel)";
|
|
|
|
package = mkOption {
|
|
type = types.package;
|
|
description = "The skyg-linux-tracker package (provides `slinuxm`).";
|
|
};
|
|
|
|
port = mkOption {
|
|
type = types.port;
|
|
default = 1984;
|
|
description = "TCP port for the REST API and /mcp.";
|
|
};
|
|
|
|
bind = mkOption {
|
|
type = types.str;
|
|
default = "127.0.0.1";
|
|
description = ''
|
|
Listen address. A non-loopback address requires authentication to stay
|
|
enabled. Bearer tokens over plain HTTP are readable on a LAN; prefer
|
|
loopback plus a TLS proxy or Tailscale, or enable `tls`.
|
|
'';
|
|
};
|
|
|
|
tls = {
|
|
enable = mkEnableOption "native TLS for REST and /mcp";
|
|
certFile = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = "Absolute path, kept out of the store (use a string, not a path literal). PEM certificate chain. Passed through systemd LoadCredential, so the service user needs no access to the original file.";
|
|
};
|
|
keyFile = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = "Absolute path, kept out of the store (use a string, not a path literal). PEM private key. Passed through systemd LoadCredential.";
|
|
};
|
|
};
|
|
|
|
openFirewall = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = "Open the port on all interfaces.";
|
|
};
|
|
|
|
firewallInterfaces = mkOption {
|
|
type = types.listOf types.str;
|
|
default = [ ];
|
|
example = [ "enp3s0" ];
|
|
description = "Open the port only on these interfaces (the recommended LAN setup).";
|
|
};
|
|
|
|
allowedHosts = mkOption {
|
|
type = types.listOf types.str;
|
|
default = [ ];
|
|
example = [ "monitor.lan:1984" ];
|
|
description = "Extra Host/Origin names accepted on /mcp. `networking.hostName` is added automatically.";
|
|
};
|
|
|
|
docker.enable = mkEnableOption ''
|
|
Docker access by adding the service user to the `docker` group.
|
|
WARNING: that group is root-equivalent; prefer a read-only socket proxy
|
|
and `settings.sources.docker_socket`'';
|
|
|
|
settings = mkOption {
|
|
type = toml.type;
|
|
default = { };
|
|
example = { limits.max_lines = 500; };
|
|
description = "Freeform config merged over the module defaults and written to /etc/skyg-linux-tracker.toml. Never put secrets here.";
|
|
};
|
|
|
|
environmentFile = mkOption {
|
|
type = types.nullOr types.path;
|
|
default = null;
|
|
example = "/run/secrets/skyg-linux-tracker.env";
|
|
description = "systemd EnvironmentFile for secrets such as `SKYG_OTEL__HEADERS__AUTHORIZATION`, kept out of the store.";
|
|
};
|
|
|
|
peers = {
|
|
enable = mkEnableOption "the consolidator (health checks and GET proxying to the peers declared below)";
|
|
|
|
settings = mkOption {
|
|
type = toml.type;
|
|
default = { };
|
|
example = { tcp_interval_secs = 10; api_interval_secs = 30; fail_threshold = 2; };
|
|
description = ''
|
|
Freeform `[peers]` tuning (snake_case keys as in config.example.toml),
|
|
merged over the defaults. Never put a token here: secrets come from
|
|
`peers.peers.<name>.tokenFile`.
|
|
'';
|
|
};
|
|
|
|
peers = mkOption {
|
|
type = types.attrsOf (types.submodule {
|
|
options = {
|
|
url = mkOption {
|
|
type = types.str;
|
|
example = "https://minipc1:1984";
|
|
description = "Base URL of the peer. `http` to a non-loopback host also needs `allowPlainHttp`.";
|
|
};
|
|
tokenFile = mkOption {
|
|
type = types.str;
|
|
example = "/run/agenix/peer-minipc1";
|
|
description = ''
|
|
Path of a file holding this peer's bearer token, normally
|
|
`config.age.secrets.<name>.path`. Must be an absolute path
|
|
outside the Nix store: the file is passed to the service with
|
|
systemd `LoadCredential`, so the token never enters the store,
|
|
the generated config or the service user's readable files.
|
|
'';
|
|
};
|
|
caFile = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
example = "/etc/ssl/private-ca.pem";
|
|
description = "Optional PEM CA bundle used to verify this peer's TLS certificate.";
|
|
};
|
|
enable = mkOption {
|
|
type = types.bool;
|
|
default = true;
|
|
description = "Set to false to keep the declaration without contacting the peer.";
|
|
};
|
|
allowPlainHttp = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = "Allow plain http to a non-loopback host. The bearer token travels in cleartext.";
|
|
};
|
|
};
|
|
});
|
|
default = { };
|
|
description = "Peers this instance consolidates, keyed by peer name (`^[a-z0-9][a-z0-9_-]{0,31}$`).";
|
|
};
|
|
};
|
|
};
|
|
|
|
config = mkIf cfg.enable {
|
|
assertions = [
|
|
{
|
|
assertion = isLoopback bind || authEnabled;
|
|
message = "services.skyg-linux-tracker: a non-loopback bind (${bind}) requires auth.enabled = true.";
|
|
}
|
|
{
|
|
assertion = !cfg.docker.enable || config.virtualisation.docker.enable;
|
|
message = "services.skyg-linux-tracker.docker.enable needs virtualisation.docker.enable (or use a socket proxy via settings.sources.docker_socket instead).";
|
|
}
|
|
{
|
|
assertion = !cfg.tls.enable || (cfg.tls.certFile != null && cfg.tls.keyFile != null);
|
|
message = "services.skyg-linux-tracker.tls.enable requires tls.certFile and tls.keyFile.";
|
|
}
|
|
{
|
|
assertion = cfg.peers.peers == { } || cfg.peers.enable;
|
|
message = "services.skyg-linux-tracker.peers.peers.<name> requires peers.enable = true.";
|
|
}
|
|
{
|
|
assertion = !cfg.peers.enable || cfg.peers.peers != { } || freeformPeers != [ ];
|
|
message = "services.skyg-linux-tracker.peers.enable requires at least one peer under peers.peers.<name>.";
|
|
}
|
|
{
|
|
assertion = cfg.peers.peers == { } || !((cfg.settings.peers or { }) ? peer);
|
|
message = "services.skyg-linux-tracker: declare peers with peers.peers.<name>, not settings.peers.peer.";
|
|
}
|
|
{
|
|
# Option attribute names are unique by construction, so only the
|
|
# character set needs checking.
|
|
assertion = lib.all validPeerName (lib.attrNames cfg.peers.peers);
|
|
message = "services.skyg-linux-tracker.peers.peers.<name>: names must match ^[a-z0-9][a-z0-9_-]{0,31}$.";
|
|
}
|
|
{
|
|
assertion = lib.all peerTokenOk (lib.attrValues cfg.peers.peers);
|
|
message = "services.skyg-linux-tracker.peers.peers.<name>.tokenFile must be an absolute path outside the Nix store (use config.age.secrets.<name>.path).";
|
|
}
|
|
{
|
|
assertion = lib.all (peer: peer.caFile == null || lib.hasPrefix "/" peer.caFile) (lib.attrValues cfg.peers.peers);
|
|
message = "services.skyg-linux-tracker.peers.peers.<name>.caFile must be an absolute path when set.";
|
|
}
|
|
];
|
|
|
|
users.users.${name} = {
|
|
isSystemUser = true;
|
|
group = name;
|
|
extraGroups = lib.optional cfg.docker.enable "docker";
|
|
};
|
|
users.groups.${name} = { };
|
|
|
|
# Same path the app reads by default, so `slinuxm` and the service agree.
|
|
environment.etc."${name}.toml".source = configFile;
|
|
|
|
# Plain binary, no wrapper. Mint tokens with
|
|
# sudo -u skyg-linux-tracker slinuxm token create <name>
|
|
environment.systemPackages = [ cfg.package ];
|
|
|
|
networking.firewall = lib.mkMerge [
|
|
(mkIf cfg.openFirewall { allowedTCPPorts = [ port ]; })
|
|
{
|
|
interfaces = lib.genAttrs cfg.firewallInterfaces (_: {
|
|
allowedTCPPorts = [ port ];
|
|
});
|
|
}
|
|
];
|
|
|
|
systemd.services.${name} = {
|
|
description = "skyg-linux-tracker: read-only systemd, journal and Docker monitor (REST, MCP, OTel)";
|
|
wantedBy = [ "multi-user.target" ];
|
|
after = [ "network.target" ] ++ lib.optional cfg.docker.enable "docker.service";
|
|
# A peer (or TLS) change only needs SIGHUP: the server re-reads those
|
|
# from the config file. SIGHUP cannot re-bind the listener or reopen the
|
|
# database, so such changes need `systemctl restart` by hand. Changes to
|
|
# the unit itself (package, credential paths) still restart.
|
|
restartTriggers = lib.optional (!cfg.peers.enable) configFile;
|
|
reloadTriggers = lib.optional cfg.peers.enable configFile;
|
|
|
|
# Mirrors systemd/skyg-linux-tracker.service; keep the two in step.
|
|
serviceConfig = {
|
|
Type = "simple";
|
|
ExecStart = "${lib.getExe cfg.package} serve --config /etc/${name}.toml";
|
|
ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
|
|
# Credentials are copied at start; refresh them so a reload rotates
|
|
# the certificate and the peer tokens.
|
|
RefreshOnReload = mkIf (cfg.tls.enable || cfg.peers.enable) "credentials";
|
|
Restart = "on-failure";
|
|
RestartSec = 5;
|
|
TimeoutStopSec = 30;
|
|
|
|
User = name;
|
|
Group = name;
|
|
SupplementaryGroups = [ "systemd-journal" ] ++ lib.optional cfg.docker.enable "docker";
|
|
StateDirectory = name;
|
|
StateDirectoryMode = "0700";
|
|
EnvironmentFile = mkIf (cfg.environmentFile != null) cfg.environmentFile;
|
|
LoadCredential = mkMerge [
|
|
(mkIf cfg.tls.enable [
|
|
"cert:${toString cfg.tls.certFile}"
|
|
"key:${toString cfg.tls.keyFile}"
|
|
])
|
|
(mkIf cfg.peers.enable (map (
|
|
peerName: "peer-${peerName}:${cfg.peers.peers.${peerName}.tokenFile}"
|
|
) enabledPeerNames))
|
|
];
|
|
|
|
NoNewPrivileges = true;
|
|
ProtectSystem = "strict";
|
|
ProtectHome = true;
|
|
PrivateTmp = true;
|
|
PrivateDevices = true;
|
|
ProtectKernelTunables = true;
|
|
ProtectKernelModules = true;
|
|
ProtectControlGroups = true;
|
|
ProtectClock = true;
|
|
RestrictAddressFamilies = [ "AF_UNIX" "AF_INET" "AF_INET6" ];
|
|
RestrictNamespaces = true;
|
|
RestrictRealtime = true;
|
|
LockPersonality = true;
|
|
MemoryDenyWriteExecute = true;
|
|
SystemCallArchitectures = "native";
|
|
SystemCallFilter = [ "@system-service" "~@privileged @resources" ];
|
|
ProtectProc = "invisible";
|
|
ProcSubset = "pid";
|
|
RestrictSUIDSGID = true;
|
|
UMask = "0077";
|
|
CapabilityBoundingSet = "";
|
|
AmbientCapabilities = "";
|
|
};
|
|
};
|
|
};
|
|
}
|