chore: monorepo inicial con arje + minga + yahweh absorbidos
Workspace en 4 ejes (core/modules/apps/shared):
- core/: 24 crates de arje (Init systemd-compatible: ente-card, ente-zero,
ente-kernel, ente-bus, ente-cas, ente-soma, ente-wasm, ente-snapshot,
ente-brain, ente-echo, ente-policy-provider, + 12 crates *-compat)
- modules/semantic_dht/: 5 crates de minga (minga-core con AST/CAS/MST,
minga-p2p con libp2p Kad, minga-store, minga-vfs, minga-cli)
- modules/ui_engine/: 11 crates de yahweh (libs/{core,theme,bus,providers},
widgets/{tree,splitter,tabs,tiled,container_core,text_input})
- apps/: 5 crates de yahweh (file_explorer, database_explorer, text_viewer,
image_viewer, yahweh-shell)
- shared_wit/protocol.wit: handshake/lifecycle inicial
Cargo.toml unificado: thiserror bumped a 2 (transparente para arje), tokio
"full", paths intra-workspace de yahweh redirigidos a su nueva ubicación.
cargo check --workspace: 0 errores, 17 warnings (dead code preexistente).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Sergio
@@ -0,0 +1,25 @@
|
||||
[package]
|
||||
name = "ente-journald-compat"
|
||||
version = "0.0.1"
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
publish.workspace = true
|
||||
|
||||
[[bin]]
|
||||
name = "ente-journald-compat"
|
||||
path = "src/main.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "ente-journalctl"
|
||||
path = "src/journalctl.rs"
|
||||
|
||||
[dependencies]
|
||||
ente-card = { path = "../ente-card" }
|
||||
ente-bus = { path = "../ente-bus" }
|
||||
ente-cas = { path = "../ente-cas" }
|
||||
nix = { workspace = true }
|
||||
libc = { workspace = true }
|
||||
anyhow = { workspace = true }
|
||||
tokio = { workspace = true }
|
||||
tracing = { workspace = true }
|
||||
tracing-subscriber = { workspace = true }
|
||||
@@ -0,0 +1,289 @@
|
||||
//! ente-journalctl: query CLI sobre el journal persistido en CAS.
|
||||
//!
|
||||
//! Lee el index `~/.local/share/ente/journal/index.log` (líneas
|
||||
//! `timestamp_ms:source:unit:sha_hex`), filtra, y para cada match
|
||||
//! restituye el blob desde CAS y lo imprime.
|
||||
//!
|
||||
//! Uso:
|
||||
//! ente-journalctl # todo el journal
|
||||
//! ente-journalctl --unit foo.service # filtra por unit
|
||||
//! ente-journalctl --since 60 # últimos 60 segundos
|
||||
//! ente-journalctl --grep "panic" # contiene "panic"
|
||||
//! ente-journalctl --tail 20 # últimas 20 entries
|
||||
//! ente-journalctl --json # output JSON-lines
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
struct Args {
|
||||
unit: Option<String>,
|
||||
since_secs: Option<u64>,
|
||||
grep: Option<String>,
|
||||
tail: Option<usize>,
|
||||
source: Option<String>,
|
||||
output: OutputFormat,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
enum OutputFormat {
|
||||
Pretty,
|
||||
Json,
|
||||
/// systemd journal export format: `KEY=value\n` por field, blank line
|
||||
/// entre entries. Documented at https://systemd.io/JOURNAL_EXPORT_FORMATS/
|
||||
/// Compatible con `journalctl --input-format=export`.
|
||||
Export,
|
||||
}
|
||||
|
||||
fn parse_args() -> Args {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let mut a = Args {
|
||||
unit: None, since_secs: None, grep: None, tail: None,
|
||||
source: None, output: OutputFormat::Pretty,
|
||||
};
|
||||
while let Some(arg) = args.next() {
|
||||
match arg.as_str() {
|
||||
"--unit" | "-u" => a.unit = args.next(),
|
||||
"--since" | "-S" => a.since_secs = args.next().and_then(|s| s.parse().ok()),
|
||||
"--grep" | "-g" => a.grep = args.next(),
|
||||
"--tail" | "-n" => a.tail = args.next().and_then(|s| s.parse().ok()),
|
||||
"--source" => a.source = args.next(),
|
||||
"--json" => a.output = OutputFormat::Json,
|
||||
"--output" | "-o" => {
|
||||
a.output = match args.next().as_deref() {
|
||||
Some("pretty") | None => OutputFormat::Pretty,
|
||||
Some("json") | Some("json-lines") => OutputFormat::Json,
|
||||
Some("export") => OutputFormat::Export,
|
||||
Some(other) => {
|
||||
eprintln!("output desconocido: {other}");
|
||||
eprintln!("válidos: pretty | json | export");
|
||||
std::process::exit(2);
|
||||
}
|
||||
};
|
||||
}
|
||||
"-h" | "--help" => { print_help(); std::process::exit(0); }
|
||||
other => {
|
||||
eprintln!("argumento desconocido: {other}");
|
||||
print_help();
|
||||
std::process::exit(2);
|
||||
}
|
||||
}
|
||||
}
|
||||
a
|
||||
}
|
||||
|
||||
fn print_help() {
|
||||
eprintln!("ente-journalctl — query CLI del journal persistido en CAS");
|
||||
eprintln!();
|
||||
eprintln!("Filtros:");
|
||||
eprintln!(" --unit, -u <name> Filtra por unidad (e.g. foo.service)");
|
||||
eprintln!(" --source <s> journal | syslog");
|
||||
eprintln!(" --since, -S <secs> Sólo últimos N segundos");
|
||||
eprintln!(" --grep, -g <text> Contiene <text> en el body decoded");
|
||||
eprintln!(" --tail, -n <N> Últimas N entries");
|
||||
eprintln!("Output:");
|
||||
eprintln!(" --output, -o <fmt> pretty | json | export (systemd journal export)");
|
||||
eprintln!(" --json alias de --output json");
|
||||
}
|
||||
|
||||
fn index_path() -> PathBuf {
|
||||
let base = if let Ok(d) = std::env::var("XDG_DATA_HOME") { d }
|
||||
else if let Ok(h) = std::env::var("HOME") { format!("{h}/.local/share") }
|
||||
else { "/var/lib".into() };
|
||||
PathBuf::from(base).join("ente").join("journal").join("index.log")
|
||||
}
|
||||
|
||||
fn now_ms() -> u128 {
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_millis())
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct IndexEntry {
|
||||
timestamp_ms: u128,
|
||||
source: String,
|
||||
unit: String,
|
||||
sha_hex: String,
|
||||
}
|
||||
|
||||
fn parse_line(line: &str) -> Option<IndexEntry> {
|
||||
let mut parts = line.splitn(4, ':');
|
||||
let ts: u128 = parts.next()?.parse().ok()?;
|
||||
let source = parts.next()?.to_string();
|
||||
let unit = parts.next()?.to_string();
|
||||
let sha = parts.next()?.to_string();
|
||||
if sha.len() != 64 { return None; }
|
||||
Some(IndexEntry { timestamp_ms: ts, source, unit, sha_hex: sha })
|
||||
}
|
||||
|
||||
fn parse_sha(hex: &str) -> Option<[u8; 32]> {
|
||||
if hex.len() != 64 { return None; }
|
||||
let mut sha = [0u8; 32];
|
||||
for i in 0..32 {
|
||||
sha[i] = u8::from_str_radix(&hex[i*2..i*2+2], 16).ok()?;
|
||||
}
|
||||
Some(sha)
|
||||
}
|
||||
|
||||
fn main() -> anyhow::Result<()> {
|
||||
let args = parse_args();
|
||||
let path = index_path();
|
||||
if !path.exists() {
|
||||
eprintln!("index no existe: {} — ¿journald-compat ha corrido?", path.display());
|
||||
std::process::exit(1);
|
||||
}
|
||||
let raw = std::fs::read_to_string(&path)?;
|
||||
let mut entries: Vec<IndexEntry> = raw.lines()
|
||||
.filter_map(parse_line)
|
||||
.collect();
|
||||
|
||||
// Filtros
|
||||
let now = now_ms();
|
||||
if let Some(secs) = args.since_secs {
|
||||
let cutoff = now.saturating_sub(secs as u128 * 1000);
|
||||
entries.retain(|e| e.timestamp_ms >= cutoff);
|
||||
}
|
||||
if let Some(unit) = &args.unit {
|
||||
entries.retain(|e| &e.unit == unit);
|
||||
}
|
||||
if let Some(src) = &args.source {
|
||||
entries.retain(|e| &e.source == src);
|
||||
}
|
||||
// tail después de filtros temporales/identidad pero antes de grep —
|
||||
// grep es post porque requiere cargar bytes del CAS.
|
||||
|
||||
let mut out: Vec<(IndexEntry, String)> = entries.into_iter()
|
||||
.filter_map(|e| {
|
||||
let sha = parse_sha(&e.sha_hex)?;
|
||||
let bytes = ente_cas::resolve(&sha).ok()?;
|
||||
let body = String::from_utf8_lossy(&bytes).into_owned();
|
||||
Some((e, body))
|
||||
})
|
||||
.collect();
|
||||
|
||||
if let Some(g) = &args.grep {
|
||||
out.retain(|(_, body)| body.contains(g.as_str()));
|
||||
}
|
||||
if let Some(n) = args.tail {
|
||||
let len = out.len();
|
||||
if len > n { out.drain(..len - n); }
|
||||
}
|
||||
|
||||
for (e, body) in out {
|
||||
match args.output {
|
||||
OutputFormat::Pretty => print_pretty(&e, &body),
|
||||
OutputFormat::Json => print_json(&e, &body),
|
||||
OutputFormat::Export => print_export(&e, &body),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn print_pretty(e: &IndexEntry, body: &str) {
|
||||
let secs = e.timestamp_ms / 1000;
|
||||
let ms = e.timestamp_ms % 1000;
|
||||
let header = if e.unit == "-" {
|
||||
format!("{}.{:03} [{}]", secs, ms, e.source)
|
||||
} else {
|
||||
format!("{}.{:03} [{}] {{{}}}", secs, ms, e.source, e.unit)
|
||||
};
|
||||
println!("{header}");
|
||||
// Si es journald native (KEY=value lines), extraer MESSAGE.
|
||||
if body.contains('=') && body.lines().any(|l| l.contains('=')) {
|
||||
for line in body.lines() {
|
||||
if let Some((k, v)) = line.split_once('=') {
|
||||
if k.trim() == "MESSAGE" {
|
||||
println!(" {v}");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for line in body.trim_end().lines() {
|
||||
println!(" {line}");
|
||||
}
|
||||
}
|
||||
|
||||
/// systemd journal export format. Cada entry es un bloque de líneas
|
||||
/// `KEY=value\n` separado por blank line. Para values con newlines o
|
||||
/// bytes binarios, el formato usa una variante con length-prefix
|
||||
/// (8 bytes LE u64) — por simplicidad sólo emitimos values con texto
|
||||
/// que no contienen newlines o caracteres no-printables. Extraemos
|
||||
/// MESSAGE/PRIORITY/_SYSTEMD_UNIT del body si es journald native.
|
||||
///
|
||||
/// Compatible con `journalctl --input-format=export -m`.
|
||||
fn print_export(e: &IndexEntry, body: &str) {
|
||||
// Timestamps: __REALTIME_TIMESTAMP en µs, __MONOTONIC_TIMESTAMP también.
|
||||
let realtime_us = e.timestamp_ms.saturating_mul(1000);
|
||||
println!("__CURSOR=s={};t={};x={}",
|
||||
&e.sha_hex[..16], // pseudo-cursor: prefix del SHA
|
||||
realtime_us,
|
||||
&e.sha_hex[..8]);
|
||||
println!("__REALTIME_TIMESTAMP={}", realtime_us);
|
||||
println!("__MONOTONIC_TIMESTAMP={}", realtime_us);
|
||||
|
||||
let host = gethostname_safe();
|
||||
if !host.is_empty() {
|
||||
println!("_HOSTNAME={host}");
|
||||
}
|
||||
|
||||
if e.unit != "-" {
|
||||
println!("_SYSTEMD_UNIT={}", e.unit);
|
||||
}
|
||||
println!("_TRANSPORT={}", match e.source.as_str() {
|
||||
"syslog" => "syslog",
|
||||
"journal" => "journal",
|
||||
_ => "stdout",
|
||||
});
|
||||
|
||||
// Si el body es journald native (KEY=value lines), emitir cada uno
|
||||
// verbatim — son los fields originales del producer. Filtrar líneas
|
||||
// que no son seguras para export (con newlines en value, etc).
|
||||
if body.contains('=') && body.lines().any(|l| l.contains('=')) {
|
||||
for line in body.lines() {
|
||||
if line.contains('=') && line.bytes().all(safe_export_byte) {
|
||||
println!("{line}");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Syslog text — empaquetar como MESSAGE.
|
||||
let msg = body.trim_end()
|
||||
.replace('\n', " "); // collapsa newlines
|
||||
if msg.bytes().all(safe_export_byte) {
|
||||
println!("MESSAGE={msg}");
|
||||
}
|
||||
}
|
||||
// Blank line separa entries.
|
||||
println!();
|
||||
}
|
||||
|
||||
fn safe_export_byte(b: u8) -> bool {
|
||||
// ASCII printable, espacio, tab. No newlines (manejados aparte).
|
||||
(0x20..=0x7E).contains(&b) || b == b'\t'
|
||||
}
|
||||
|
||||
fn gethostname_safe() -> String {
|
||||
let mut buf = [0u8; 256];
|
||||
let r = unsafe {
|
||||
libc::gethostname(buf.as_mut_ptr() as *mut _, buf.len())
|
||||
};
|
||||
if r != 0 { return String::new(); }
|
||||
let len = buf.iter().position(|&b| b == 0).unwrap_or(buf.len());
|
||||
std::str::from_utf8(&buf[..len]).unwrap_or("").to_string()
|
||||
}
|
||||
|
||||
fn print_json(e: &IndexEntry, body: &str) {
|
||||
// JSON-lines básico, sin dependencia de serde — formato simple y estable.
|
||||
let escaped_body = body
|
||||
.replace('\\', "\\\\")
|
||||
.replace('"', "\\\"")
|
||||
.replace('\n', "\\n")
|
||||
.replace('\r', "\\r")
|
||||
.replace('\t', "\\t");
|
||||
let unit_field = if e.unit == "-" { "null".to_string() }
|
||||
else { format!("\"{}\"", e.unit) };
|
||||
println!(
|
||||
r#"{{"timestamp_ms":{},"source":"{}","unit":{},"sha":"{}","body":"{}"}}"#,
|
||||
e.timestamp_ms, e.source, unit_field, e.sha_hex, escaped_body
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
//! ente-journald-compat: stub que absorbe escrituras al journal socket.
|
||||
//!
|
||||
//! Listen en `/run/systemd/journal/socket` (datagram) — todo lo que llega
|
||||
//! se decodifica best-effort y se emite como tracing event.
|
||||
//!
|
||||
//! Sin esto, apps que usan `sd_journal_send` o syslog fallan al escribir.
|
||||
//! Para una implementación real: persistir a CAS por timestamp+sha,
|
||||
//! exponer query API, indexar por unidad/usuario.
|
||||
|
||||
use ente_bus::{BusClient, BusRequest, BusResponse};
|
||||
use ente_card::Capability;
|
||||
use std::os::fd::{AsRawFd, OwnedFd};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Mutex;
|
||||
use tokio::io::unix::AsyncFd;
|
||||
use tokio::signal::unix::{signal, SignalKind};
|
||||
use tracing::{debug, info, warn};
|
||||
use tracing_subscriber::EnvFilter;
|
||||
|
||||
const JOURNAL_SOCKET: &str = "/run/systemd/journal/socket";
|
||||
const DEV_LOG: &str = "/dev/log";
|
||||
|
||||
#[tokio::main(flavor = "current_thread")]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
init_tracing();
|
||||
info!("ente-journald-compat: arrancando");
|
||||
announce_to_fractal().await;
|
||||
|
||||
// Intentamos vincular ambos sockets. Cada uno puede fallar
|
||||
// independientemente; si alguno funciona, seguimos.
|
||||
let mut bound = 0usize;
|
||||
if let Some(stream) = bind_dgram(JOURNAL_SOCKET) {
|
||||
bound += 1;
|
||||
spawn_listener(stream, "journal");
|
||||
} else {
|
||||
warn!(path = JOURNAL_SOCKET, "no se pudo bind — necesita CAP_NET_BIND_SERVICE o /run writable");
|
||||
}
|
||||
if let Some(stream) = bind_dgram(DEV_LOG) {
|
||||
bound += 1;
|
||||
spawn_listener(stream, "syslog");
|
||||
} else {
|
||||
warn!(path = DEV_LOG, "no se pudo bind /dev/log");
|
||||
}
|
||||
|
||||
if bound == 0 {
|
||||
warn!("ningún socket bound — modo idle");
|
||||
} else {
|
||||
info!(sockets_bound = bound, "journald-compat listening");
|
||||
}
|
||||
|
||||
wait_for_term().await
|
||||
}
|
||||
|
||||
fn bind_dgram(path: &str) -> Option<AsyncFd<OwnedFdWrap>> {
|
||||
use nix::sys::socket::{bind, socket, AddressFamily, SockFlag, SockType, UnixAddr};
|
||||
let _ = std::fs::remove_file(path);
|
||||
if let Some(parent) = Path::new(path).parent() {
|
||||
let _ = std::fs::create_dir_all(parent);
|
||||
}
|
||||
let fd = match socket(
|
||||
AddressFamily::Unix,
|
||||
SockType::Datagram,
|
||||
SockFlag::SOCK_NONBLOCK | SockFlag::SOCK_CLOEXEC,
|
||||
None,
|
||||
) {
|
||||
Ok(f) => f,
|
||||
Err(e) => { warn!(?e, "socket() falló"); return None; }
|
||||
};
|
||||
let addr = match UnixAddr::new(path) {
|
||||
Ok(a) => a,
|
||||
Err(e) => { warn!(?e, "UnixAddr falló"); return None; }
|
||||
};
|
||||
if let Err(e) = bind(fd.as_raw_fd(), &addr) {
|
||||
warn!(?e, %path, "bind falló");
|
||||
return None;
|
||||
}
|
||||
AsyncFd::new(OwnedFdWrap(fd)).ok()
|
||||
}
|
||||
|
||||
struct OwnedFdWrap(OwnedFd);
|
||||
impl AsRawFd for OwnedFdWrap {
|
||||
fn as_raw_fd(&self) -> std::os::fd::RawFd { self.0.as_raw_fd() }
|
||||
}
|
||||
|
||||
fn spawn_listener(async_fd: AsyncFd<OwnedFdWrap>, source: &'static str) {
|
||||
tokio::spawn(async move {
|
||||
let mut buf = vec![0u8; 64 * 1024];
|
||||
loop {
|
||||
let mut guard = match async_fd.readable().await {
|
||||
Ok(g) => g,
|
||||
Err(e) => { warn!(?e, source, "readable failed"); return; }
|
||||
};
|
||||
let raw_fd = guard.get_inner().as_raw_fd();
|
||||
loop {
|
||||
let n = unsafe {
|
||||
libc::recv(raw_fd, buf.as_mut_ptr() as *mut _, buf.len(), 0)
|
||||
};
|
||||
if n <= 0 { break; }
|
||||
handle_message(&buf[..n as usize], source);
|
||||
}
|
||||
guard.clear_ready();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Mutex sobre el archivo index para escrituras concurrentes desde
|
||||
/// múltiples listeners (journal + syslog).
|
||||
static INDEX_FILE: Mutex<()> = Mutex::new(());
|
||||
|
||||
/// Path del index file: `$XDG_DATA_HOME/ente/journal/index.log` (default
|
||||
/// `~/.local/share/ente/journal/index.log`).
|
||||
fn index_path() -> PathBuf {
|
||||
let base = if let Ok(d) = std::env::var("XDG_DATA_HOME") { d }
|
||||
else if let Ok(h) = std::env::var("HOME") { format!("{h}/.local/share") }
|
||||
else { "/var/lib".into() };
|
||||
PathBuf::from(base).join("ente").join("journal").join("index.log")
|
||||
}
|
||||
|
||||
fn now_ms() -> u128 {
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_millis())
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
/// Persiste el blob crudo al CAS y appendea una línea al index:
|
||||
/// `<timestamp_ms>:<source>:<unit>:<sha_hex>`. Errores se logean pero
|
||||
/// no abortan — perder un mensaje no debe romper journald.
|
||||
fn persist_to_cas(buf: &[u8], source: &'static str, unit: Option<&str>) {
|
||||
let sha = match ente_cas::store(buf) {
|
||||
Ok(s) => s,
|
||||
Err(e) => { warn!(?e, "CAS store falló"); return; }
|
||||
};
|
||||
let line = format!(
|
||||
"{}:{}:{}:{}\n",
|
||||
now_ms(), source, unit.unwrap_or("-"), ente_cas::hex(&sha)
|
||||
);
|
||||
let path = index_path();
|
||||
let _guard = INDEX_FILE.lock().unwrap();
|
||||
if let Some(parent) = path.parent() {
|
||||
let _ = std::fs::create_dir_all(parent);
|
||||
}
|
||||
use std::io::Write;
|
||||
let mut f = match std::fs::OpenOptions::new()
|
||||
.create(true).append(true)
|
||||
.open(&path)
|
||||
{
|
||||
Ok(f) => f,
|
||||
Err(e) => { warn!(?e, path = %path.display(), "abrir index"); return; }
|
||||
};
|
||||
if let Err(e) = f.write_all(line.as_bytes()) {
|
||||
warn!(?e, "write index");
|
||||
}
|
||||
}
|
||||
|
||||
/// Decodifica best-effort. Formato journald nativo: lines de "KEY=value"
|
||||
/// (binario para values con newlines, pero raro). Formato syslog: texto
|
||||
/// con prefijo "<priority>tag: message".
|
||||
fn handle_message(buf: &[u8], source: &'static str) {
|
||||
if let Ok(s) = std::str::from_utf8(buf) {
|
||||
if s.contains('=') && s.lines().any(|l| l.contains('=')) {
|
||||
let mut message = None;
|
||||
let mut priority = None;
|
||||
let mut unit: Option<String> = None;
|
||||
for line in s.lines() {
|
||||
if let Some((k, v)) = line.split_once('=') {
|
||||
match k {
|
||||
"MESSAGE" => message = Some(v.to_string()),
|
||||
"PRIORITY" => priority = Some(v.to_string()),
|
||||
"_SYSTEMD_UNIT" | "UNIT" => unit = Some(v.to_string()),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
persist_to_cas(buf, source, unit.as_deref());
|
||||
if let Some(msg) = message {
|
||||
info!(target: "journal", source, ?priority, ?unit, "{msg}");
|
||||
} else {
|
||||
debug!(source, len = buf.len(), "journal native sin MESSAGE");
|
||||
}
|
||||
} else {
|
||||
persist_to_cas(buf, source, None);
|
||||
info!(target: "syslog", source, "{}", s.trim_end());
|
||||
}
|
||||
} else {
|
||||
persist_to_cas(buf, source, None);
|
||||
debug!(source, len = buf.len(), "journal binario (no UTF-8)");
|
||||
}
|
||||
}
|
||||
|
||||
async fn announce_to_fractal() {
|
||||
if let Ok(mut client) = BusClient::from_env().await {
|
||||
let req = BusRequest::Announce {
|
||||
capabilities: vec![Capability::Journal],
|
||||
};
|
||||
match client.call(req).await {
|
||||
Ok(BusResponse::Ok) => info!("Announce → bus interno OK"),
|
||||
Ok(other) => warn!(?other, "Announce respuesta inesperada"),
|
||||
Err(e) => warn!(?e, "Announce falló"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn wait_for_term() -> anyhow::Result<()> {
|
||||
let mut term = signal(SignalKind::terminate())?;
|
||||
let mut int_ = signal(SignalKind::interrupt())?;
|
||||
tokio::select! {
|
||||
_ = term.recv() => info!("SIGTERM"),
|
||||
_ = int_.recv() => info!("SIGINT"),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn init_tracing() {
|
||||
let filter = EnvFilter::try_from_default_env()
|
||||
.unwrap_or_else(|_| EnvFilter::new("ente_journald_compat=info,journal=info,syslog=info"));
|
||||
tracing_subscriber::fmt().with_env_filter(filter).with_target(true).init();
|
||||
}
|
||||
Reference in New Issue
Block a user