diff --git a/crates/common/src/network/bind_health.rs b/crates/common/src/network/bind_health.rs new file mode 100644 index 00000000..44f94162 --- /dev/null +++ b/crates/common/src/network/bind_health.rs @@ -0,0 +1,265 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! inbuxa: listeners that can't open (#485). +//! +//! A listener whose port is taken is retried for a while: after a restart +//! the old process often still holds it for a few seconds. Any other bind +//! error is reported at once. A listener that stays shut is: +//! +//! - logged as an error (`network.listen-error`), as before; +//! - kept in [`ListenerFailures`], which `/healthz/ready` reads, so a probe +//! takes the node out of service without restarting it in a loop; +//! - written to the store under this node's id, so `x:ClusterNode` shows it +//! in the console whichever node the console talks to. +//! +//! The process stays up: one blocked port shouldn't take every other +//! protocol down with it. `INBUXA_LISTENER_FAILURE=exit` makes a listener +//! that can't open at startup end the process instead (exit code 1), for +//! setups that would rather have their supervisor restart it. Listeners put +//! back later by the legacy-protocols switch (LP-5) only ever report. + +use crate::Server; +use parking_lot::Mutex; +use std::{ + collections::BTreeMap, + sync::atomic::{AtomicBool, Ordering}, + time::{Duration, Instant}, +}; +use store::{ + Deserialize, SUBSPACE_INBUXA, Store, ValueKey, + write::{AnyClass, BatchBuilder, ValueClass}, +}; +use trc::AddContext; + +/// How long a port in use is retried. +pub const RETRY_FOR: Duration = Duration::from_secs(30); +const FIRST_BACKOFF: Duration = Duration::from_millis(500); +const MAX_BACKOFF: Duration = Duration::from_secs(5); + +/// Set once the listeners configured at startup have been spawned. Anything +/// spawned after that (LP-5) never ends the process. +pub static STARTED: AtomicBool = AtomicBool::new(false); + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum FailureMode { + Report, + Exit, +} + +impl FailureMode { + pub fn parse(value: Option<&str>) -> Result { + match value.map(str::trim).unwrap_or_default() { + "" | "report" => Ok(FailureMode::Report), + "exit" => Ok(FailureMode::Exit), + other => Err(format!( + "INBUXA_LISTENER_FAILURE is '{other}'; it takes 'report' (the default) or 'exit'" + )), + } + } + + pub fn from_env() -> Self { + Self::parse(types::branding::env_var("LISTENER_FAILURE").ok().as_deref()).unwrap_or_else( + |err| { + trc::event!(Server(trc::ServerEvent::StartupError), Details = err,); + FailureMode::Report + }, + ) + } +} + +/// Listeners of this node that aren't open, keyed "listener-id address". +#[derive(Default)] +pub struct ListenerFailures { + failed: Mutex>, +} + +impl ListenerFailures { + /// Records why a listener isn't open. True when that changed anything. + pub fn set(&self, key: &str, reason: &str) -> bool { + self.failed + .lock() + .insert(key.to_string(), reason.to_string()) + .is_none_or(|before| before != reason) + } + + /// The listener opened, or went away. True when it had been recorded. + pub fn clear(&self, key: &str) -> bool { + self.failed.lock().remove(key).is_some() + } + + /// Forgets every address of a listener, when it's stopped on purpose. + pub fn clear_listener(&self, id: &str) -> bool { + let prefix = format!("{id} "); + let mut failed = self.failed.lock(); + let before = failed.len(); + failed.retain(|key, _| !key.starts_with(&prefix)); + failed.len() != before + } + + pub fn is_empty(&self) -> bool { + self.failed.lock().is_empty() + } + + /// One line per listener: "id address: reason". + pub fn lines(&self) -> Vec { + self.failed + .lock() + .iter() + .map(|(key, reason)| format!("{key}: {reason}")) + .collect() + } +} + +/// Under `O`, listener status (store-layout SL-16), by node id. +fn status_class(node_id: u16) -> ValueClass { + let mut key = b"Ol".to_vec(); + key.extend_from_slice(&node_id.to_be_bytes()); + ValueClass::Any(AnyClass { + subspace: SUBSPACE_INBUXA, + key, + }) +} + +struct Lines(Vec); + +impl Deserialize for Lines { + fn deserialize(bytes: &[u8]) -> trc::Result { + Ok(Lines( + String::from_utf8_lossy(bytes) + .lines() + .filter(|line| !line.is_empty()) + .map(str::to_string) + .collect(), + )) + } +} + +/// Writes this node's unbound listeners where every node can read them; +/// none clears the record. +pub async fn publish(store: &Store, node_id: u16, lines: &[String]) -> trc::Result<()> { + let mut batch = BatchBuilder::new(); + if lines.is_empty() { + batch.clear(status_class(node_id)); + } else { + batch.set(status_class(node_id), lines.join("\n").into_bytes()); + } + store + .write(batch.build_all()) + .await + .caused_by(trc::location!()) + .map(|_| ()) +} + +/// A node's unbound listeners, as it last wrote them. +pub async fn read(store: &Store, node_id: u16) -> trc::Result> { + Ok(store + .get_value::(ValueKey::from(status_class(node_id))) + .await + .caused_by(trc::location!())? + .map(|Lines(lines)| lines) + .unwrap_or_default()) +} + +impl Server { + /// Writes this node's current failures to the store. A store that's + /// down is logged and left: readiness reads memory, not the store. + pub async fn publish_listener_failures(&self) { + let Ok(node_id) = u16::try_from(self.core.network.node_id) else { + return; + }; + let lines = self.inner.data.listener_control.failures().lines(); + if let Err(err) = publish(&self.core.storage.data, node_id, &lines).await { + trc::error!(err.details("Failed to record this node's listener status")); + } + } +} + +/// How long to wait before the next try at a port in use, or `None` once +/// `retry_for` has passed since `started`. +pub fn next_backoff( + started: Instant, + retry_for: Duration, + previous: Option, +) -> Option { + let next = previous.map_or(FIRST_BACKOFF, |d| (d * 2).min(MAX_BACKOFF)); + let left = retry_for.checked_sub(started.elapsed())?; + (!left.is_zero()).then(|| next.min(left)) +} + +/// True for the bind errors worth waiting out. +pub fn is_retryable(err: &std::io::Error) -> bool { + err.kind() == std::io::ErrorKind::AddrInUse +} + +/// Whether startup is over, for [`STARTED`]. +pub fn startup_done() { + STARTED.store(true, Ordering::Release); +} + +pub fn is_startup() -> bool { + !STARTED.load(Ordering::Acquire) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn failure_mode_from_its_setting() { + assert_eq!(FailureMode::parse(None), Ok(FailureMode::Report)); + assert_eq!(FailureMode::parse(Some("report")), Ok(FailureMode::Report)); + assert_eq!(FailureMode::parse(Some(" exit ")), Ok(FailureMode::Exit)); + assert!(FailureMode::parse(Some("crash")).is_err()); + } + + #[test] + fn failures_by_listener() { + let failures = ListenerFailures::default(); + assert!(failures.is_empty()); + assert!(failures.set("imaps [::]:993", "address in use")); + assert!(!failures.set("imaps [::]:993", "address in use")); + assert!(failures.set("imaps [::]:993", "permission denied")); + assert!(failures.set("imaps-alt [::]:1993", "address in use")); + assert_eq!( + failures.lines(), + vec![ + "imaps [::]:993: permission denied".to_string(), + "imaps-alt [::]:1993: address in use".to_string() + ] + ); + // Stopping "imaps" leaves "imaps-alt" alone + assert!(failures.clear_listener("imaps")); + assert_eq!(failures.lines().len(), 1); + assert!(failures.clear("imaps-alt [::]:1993")); + assert!(failures.is_empty()); + } + + #[test] + fn backoff_doubles_and_stops() { + let now = Instant::now(); + let first = next_backoff(now, RETRY_FOR, None).unwrap(); + assert_eq!(first, FIRST_BACKOFF); + assert_eq!( + next_backoff(now, RETRY_FOR, Some(first)), + Some(FIRST_BACKOFF * 2) + ); + assert_eq!( + next_backoff(now, RETRY_FOR, Some(MAX_BACKOFF)), + Some(MAX_BACKOFF) + ); + let long_ago = Instant::now() - RETRY_FOR - Duration::from_secs(1); + assert_eq!(next_backoff(long_ago, RETRY_FOR, Some(first)), None); + } + + #[test] + fn only_address_in_use_is_retried() { + use std::io::{Error, ErrorKind}; + assert!(is_retryable(&Error::from(ErrorKind::AddrInUse))); + assert!(!is_retryable(&Error::from(ErrorKind::PermissionDenied))); + assert!(!is_retryable(&Error::from(ErrorKind::AddrNotAvailable))); + } +} diff --git a/crates/common/src/network/control.rs b/crates/common/src/network/control.rs index a26addf1..849a8745 100644 --- a/crates/common/src/network/control.rs +++ b/crates/common/src/network/control.rs @@ -55,6 +55,8 @@ pub struct ListenerInfo { pub struct ListenerControl { running: RwLock>, spawner: OnceLock, + // inbuxa: #485, listeners that couldn't open + failures: super::bind_health::ListenerFailures, } impl ListenerControl { @@ -105,9 +107,16 @@ impl ListenerControl { true } + /// Listeners that couldn't open (#485). + pub fn failures(&self) -> &super::bind_health::ListenerFailures { + &self.failures + } + /// Stops one listener by id. Returns what was stopped, or `None` when no /// listener of that id is running. pub fn stop(&self, id: &str) -> Option { + // inbuxa: #485: a listener stopped on purpose isn't a failure + self.failures.clear_listener(id); let running = self.running.write().remove(id).map(|running| { let _ = running.shutdown_tx.send(true); ListenerInfo { diff --git a/crates/common/src/network/listen.rs b/crates/common/src/network/listen.rs index 513788be..1b4475cd 100644 --- a/crates/common/src/network/listen.rs +++ b/crates/common/src/network/listen.rs @@ -63,32 +63,11 @@ impl Listener { ttl: listener.ttl, }; - // Bind socket - let listener = match listener.listen() { - Ok(listener) => { - trc::event!( - Network(trc::NetworkEvent::ListenStart), - ListenerId = instance.id.clone(), - LocalIp = local_addr.ip(), - LocalPort = local_addr.port(), - Tls = is_tls, - ); - - listener - } - Err(err) => { - trc::event!( - Network(trc::NetworkEvent::ListenError), - ListenerId = instance.id.clone(), - LocalIp = local_addr.ip(), - LocalPort = local_addr.port(), - Tls = is_tls, - Reason = err, - ); - - continue; - } - }; + // inbuxa: #485: a listener opens in its own task, so a port still + // held by the previous process can be waited out without holding + // up the rest. Only listeners configured at startup may end the + // process, and only when INBUXA_LISTENER_FAILURE=exit. + let at_startup = super::bind_health::is_startup(); // Spawn listener let mut shutdown_rx = instance.shutdown_rx.clone(); @@ -96,6 +75,56 @@ impl Listener { let instance = instance.clone(); let inner = inner.clone(); tokio::spawn(async move { + let key = format!("{} {}", instance.id, local_addr); + let listener = match open(listener, &inner, &key).await { + Ok(listener) => { + trc::event!( + Network(trc::NetworkEvent::ListenStart), + ListenerId = instance.id.clone(), + LocalIp = local_addr.ip(), + LocalPort = local_addr.port(), + Tls = is_tls, + ); + + if inner.data.listener_control.failures().clear(&key) { + inner.build_server().publish_listener_failures().await; + } + listener + } + Err(err) => { + trc::event!( + Network(trc::NetworkEvent::ListenError), + ListenerId = instance.id.clone(), + LocalIp = local_addr.ip(), + LocalPort = local_addr.port(), + Tls = is_tls, + Reason = err.clone(), + ); + + if inner.data.listener_control.failures().set(&key, &err) { + inner.build_server().publish_listener_failures().await; + } + if at_startup + && super::bind_health::FailureMode::from_env() + == super::bind_health::FailureMode::Exit + { + trc::event!( + Server(trc::ServerEvent::StartupError), + Details = "A listener couldn't open and INBUXA_LISTENER_FAILURE=exit: stopping", + ListenerId = instance.id.clone(), + Reason = err.clone(), + ); + eprintln!( + "Listener {key} couldn't open ({err}) and INBUXA_LISTENER_FAILURE=exit: stopping." + ); + // Give the log a moment to write the events above + tokio::time::sleep(Duration::from_millis(500)).await; + std::process::exit(1); + } + return; + } + }; + let (span_start, span_end) = match self.protocol { ServerProtocol::Smtp | ServerProtocol::Lmtp => ( EventType::Smtp(SmtpEvent::ConnectionStart), @@ -430,7 +459,74 @@ impl Listeners { } } +/// inbuxa: #485: listens on a socket, binding it again if the bind at +/// startup failed. A port in use is retried for `RETRY_FOR`, and recorded +/// as a failure meanwhile, so the node reports not ready while it waits. +async fn open( + listener: TcpListener, + inner: &Arc, + key: &str, +) -> Result { + let inner_ = inner.clone(); + let key_ = key.to_string(); + open_retrying(listener, super::bind_health::RETRY_FOR, move |retrying| { + if inner_ + .data + .listener_control + .failures() + .set(&key_, &retrying) + { + let inner = inner_.clone(); + tokio::spawn(async move { + inner.build_server().publish_listener_failures().await; + }); + } + }) + .await +} + +/// Binds (if the bind at startup failed) and listens. A port in use is +/// retried with backoff for `retry_for`, calling `on_retry` once with the +/// reason when the waiting starts; any other bind error fails at once. +async fn open_retrying( + listener: TcpListener, + retry_for: Duration, + mut on_retry: impl FnMut(String), +) -> Result { + use super::bind_health::{is_retryable, next_backoff}; + + let started = std::time::Instant::now(); + let mut backoff = None; + while !listener.is_bound() { + let Err(err) = listener.socket.bind(listener.addr) else { + break; + }; + let reason = format!("Failed to bind to {}: {}", listener.addr, err); + if !is_retryable(&err) { + return Err(reason); + } + let Some(wait) = next_backoff(started, retry_for, backoff) else { + return Err(format!( + "{reason} (still in use after {} s)", + retry_for.as_secs() + )); + }; + if backoff.is_none() { + on_retry(format!("{reason}; retrying")); + } + backoff = Some(wait); + tokio::time::sleep(wait).await; + } + listener.listen() +} + impl TcpListener { + fn is_bound(&self) -> bool { + self.socket + .local_addr() + .is_ok_and(|bound| bound.port() != 0) + } + pub fn listen(self) -> Result { // inbuxa: a socket whose bind failed is still unbound, and listen() // on it makes the kernel pick a random port on every interface @@ -508,7 +604,9 @@ impl ServerInstance { #[cfg(test)] mod tests { + use super::open_retrying; use crate::config::server::TcpListener; + use std::time::Duration; use tokio::net::TcpSocket; fn listener(socket: TcpSocket, addr: &str) -> TcpListener { @@ -529,6 +627,61 @@ mod tests { assert!(err.contains("isn't bound"), "{err}"); } + // inbuxa: #485 + #[tokio::test] + async fn a_port_in_use_is_waited_for() { + let held = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + let addr = held.local_addr().unwrap().to_string(); + let socket = TcpSocket::new_v4().unwrap(); + let mut retried = Vec::new(); + let opening = tokio::spawn(async move { + let result = + open_retrying(listener(socket, &addr), Duration::from_secs(20), |reason| { + retried.push(reason) + }) + .await; + (result, retried) + }); + tokio::time::sleep(Duration::from_millis(1500)).await; + drop(held); + let (result, retried) = opening.await.unwrap(); + assert!(result.is_ok(), "{result:?}"); + assert_eq!(retried.len(), 1, "{retried:?}"); + assert!(retried[0].contains("retrying"), "{retried:?}"); + } + + #[tokio::test] + async fn a_port_held_too_long_fails() { + let held = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + let addr = held.local_addr().unwrap().to_string(); + let socket = TcpSocket::new_v4().unwrap(); + let started = std::time::Instant::now(); + let err = open_retrying(listener(socket, &addr), Duration::from_secs(2), |_| {}) + .await + .unwrap_err(); + assert!(err.contains("still in use after 2 s"), "{err}"); + assert!(started.elapsed() < Duration::from_secs(5)); + drop(held); + } + + #[tokio::test] + async fn other_bind_errors_are_not_retried() { + // An address this host doesn't have + let socket = TcpSocket::new_v4().unwrap(); + let started = std::time::Instant::now(); + let mut retried = 0; + let err = open_retrying( + listener(socket, "192.0.2.1:2525"), + Duration::from_secs(20), + |_| retried += 1, + ) + .await + .unwrap_err(); + assert!(err.contains("Failed to bind"), "{err}"); + assert_eq!(retried, 0); + assert!(started.elapsed() < Duration::from_secs(2)); + } + #[tokio::test] async fn a_bound_socket_listens_even_on_port_zero() { let socket = TcpSocket::new_v4().unwrap(); diff --git a/crates/common/src/network/mod.rs b/crates/common/src/network/mod.rs index 23194074..2b70c3ea 100644 --- a/crates/common/src/network/mod.rs +++ b/crates/common/src/network/mod.rs @@ -35,6 +35,7 @@ use utils::snowflake::SnowflakeIdGenerator; pub mod acme; pub mod asn; pub mod autoconfig; +pub mod bind_health; // inbuxa: #485, listeners that can't open pub mod control; pub mod dkim; pub mod dns; diff --git a/crates/http/src/request.rs b/crates/http/src/request.rs index dcffe90a..a59b9085 100644 --- a/crates/http/src/request.rs +++ b/crates/http/src/request.rs @@ -606,6 +606,17 @@ impl ParseHttp for Server { return Ok(JsonProblemResponse(StatusCode::OK).into_http_response()); } "ready" => { + // inbuxa: #485: not ready while a configured + // listener isn't open, naming each one + let unbound = self.inner.data.listener_control.failures().lines(); + if !unbound.is_empty() { + return Ok(http_proto::JsonResponse::with_status( + StatusCode::SERVICE_UNAVAILABLE, + serde_json::json!({ "unboundListeners": unbound }), + ) + .no_cache() + .into_http_response()); + } // inbuxa: ready only while the data store answers // (a cached, time-limited read); liveness stays 200 return Ok(JsonProblemResponse({ diff --git a/crates/jmap/src/registry/mapping/cluster.rs b/crates/jmap/src/registry/mapping/cluster.rs index bfe05edf..ab346280 100644 --- a/crates/jmap/src/registry/mapping/cluster.rs +++ b/crates/jmap/src/registry/mapping/cluster.rs @@ -2,10 +2,12 @@ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC * * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL + * + * Modified by Coffey Labs in 2026 for INBUXA. */ use jmap_proto::{object::registry::RegistryComparator, types::state::State}; -use registry::{jmap::IntoValue, schema::prelude::Property}; +use registry::{jmap::IntoValue, schema::prelude::Property, types::map::Map}; use store::ahash::AHashSet; use crate::{ @@ -25,8 +27,15 @@ pub(crate) async fn cluster_node_get( .map(|id| id.id()) .collect::>(); - for node in nodes { + for mut node in nodes { if ids.is_empty() || ids.remove(&node.node_id) { + // inbuxa: #485: what each node last said it couldn't open + if let Ok(node_id) = u16::try_from(node.node_id) { + node.unbound_listeners = Map::new( + common::network::bind_health::read(&get.server.core.storage.data, node_id) + .await?, + ); + } get.insert(node.node_id.into(), node.into_value()); } } diff --git a/crates/main/src/main.rs b/crates/main/src/main.rs index 83bcb9b7..d4a05c6d 100644 --- a/crates/main/src/main.rs +++ b/crates/main/src/main.rs @@ -121,6 +121,14 @@ async fn main() -> std::io::Result<()> { spawn_listener(&spawn_inner, server, acceptor, shutdown_rx); }); + // inbuxa: #485: listeners spawned from here on (LP-5) never end the + // process; and a node starts with no failures left from its last run + common::network::bind_health::startup_done(); + { + let server = init.inner.build_server(); + tokio::spawn(async move { server.publish_listener_failures().await }); + } + // Leave behind how to spawn a listener, so putting one back opens its port // without a restart (LP-5). Only this file knows the session manager for a // protocol, so only this file can say. diff --git a/crates/migration/src/fork_subspaces.rs b/crates/migration/src/fork_subspaces.rs index 2773d14e..e0bce5bf 100644 --- a/crates/migration/src/fork_subspaces.rs +++ b/crates/migration/src/fork_subspaces.rs @@ -89,6 +89,7 @@ pub const OWNERS: &[(u8, Owner)] = &[ ), (b'M', Owner::Stays("masked email")), (b'N', Owner::Stays("passkeys")), + (b'O', Owner::Stays("listener status")), (b'P', Owner::Stays("permissions and protocol policies")), (b'Q', Owner::Stays("acceptance records")), (b'R', Owner::Stays("mail flow rules")), diff --git a/crates/registry/src/schema/properties.rs b/crates/registry/src/schema/properties.rs index 48444539..aacc8f9b 100644 --- a/crates/registry/src/schema/properties.rs +++ b/crates/registry/src/schema/properties.rs @@ -1174,6 +1174,7 @@ pub enum Property { TrustReplies = 774, TsigAlgorithm = 338, Ttl = 310, + UnboundListeners = 947, UnpackDirectory = 54, UpdateRecords = 812, UploadQuota = 445, diff --git a/crates/registry/src/schema/properties_impl.rs b/crates/registry/src/schema/properties_impl.rs index 1f214f53..e0652db0 100644 --- a/crates/registry/src/schema/properties_impl.rs +++ b/crates/registry/src/schema/properties_impl.rs @@ -1322,6 +1322,7 @@ impl EnumImpl for Property { b"tsigAlgorithm" => Property::TsigAlgorithm, b"ttl" => Property::Ttl, b"unpackDirectory" => Property::UnpackDirectory, + b"unboundListeners" => Property::UnboundListeners, b"updateRecords" => Property::UpdateRecords, b"uploadQuota" => Property::UploadQuota, b"uploadTtl" => Property::UploadTtl, @@ -2274,6 +2275,7 @@ impl EnumImpl for Property { Property::TsigAlgorithm => "tsigAlgorithm", Property::Ttl => "ttl", Property::UnpackDirectory => "unpackDirectory", + Property::UnboundListeners => "unboundListeners", Property::UpdateRecords => "updateRecords", Property::UploadQuota => "uploadQuota", Property::UploadTtl => "uploadTtl", @@ -3057,6 +3059,7 @@ impl EnumImpl for Property { 944 => Some(Property::PasskeysAllowed), 945 => Some(Property::PasskeyRpId), 946 => Some(Property::MaxPasskeys), + 947 => Some(Property::UnboundListeners), 615 => Some(Property::RequireClientRegistration), 608 => Some(Property::RequireScopes), 525 => Some(Property::RequireTls), @@ -3268,7 +3271,7 @@ impl EnumImpl for Property { } } - const COUNT: usize = 947; + const COUNT: usize = 948; } impl serde::Serialize for Property { diff --git a/crates/registry/src/schema/structs.rs b/crates/registry/src/schema/structs.rs index 2f8a169f..92aad407 100644 --- a/crates/registry/src/schema/structs.rs +++ b/crates/registry/src/schema/structs.rs @@ -760,6 +760,9 @@ pub struct ClusterNode { pub last_renewal: UTCDateTime, #[serde(rename = "status")] pub status: ClusterNodeStatus, + // inbuxa: #485, listeners this node couldn't bind, as "id address: reason" + #[serde(rename = "unboundListeners")] + pub unbound_listeners: Map, } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] diff --git a/crates/registry/src/schema/structs_impl.rs b/crates/registry/src/schema/structs_impl.rs index 8f9bcc97..d665f19a 100644 --- a/crates/registry/src/schema/structs_impl.rs +++ b/crates/registry/src/schema/structs_impl.rs @@ -5455,6 +5455,7 @@ impl Pickle for ClusterNode { self.hostname.pickle(out); self.last_renewal.pickle(out); self.status.pickle(out); + self.unbound_listeners.pickle(out); } fn unpickle(stream: &mut crate::pickle::PickledStream<'_>) -> Option { @@ -5463,6 +5464,7 @@ impl Pickle for ClusterNode { this.hostname = Pickle::unpickle(stream)?; this.last_renewal = Pickle::unpickle(stream)?; this.status = Pickle::unpickle(stream)?; + this.unbound_listeners = Pickle::unpickle(stream)?; Some(this) } } @@ -5474,6 +5476,7 @@ impl Default for ClusterNode { hostname: Default::default(), last_renewal: Default::default(), status: Default::default(), + unbound_listeners: Default::default(), } } } @@ -5485,6 +5488,10 @@ impl IntoValue for ClusterNode { map.insert_unchecked(Property::Hostname, self.hostname.into_value()); map.insert_unchecked(Property::LastRenewal, self.last_renewal.into_value()); map.insert_unchecked(Property::Status, self.status.into_value()); + map.insert_unchecked( + Property::UnboundListeners, + self.unbound_listeners.into_value(), + ); JmapValue::Object(map) } } @@ -5500,6 +5507,9 @@ impl RegistryJsonPropertyPatch for ClusterNode { Some(Property::Hostname) => self.hostname.patch(pointer, value), Some(Property::LastRenewal) => self.last_renewal.patch(pointer, value), Some(Property::Status) => self.status.patch(pointer, value), + Some(Property::UnboundListeners) => self + .unbound_listeners + .patch(pointer.assert_read_only()?, value), Some(Property::Type) => Ok(MaybeUnpatched::Unpatched { property: Property::Type, value, diff --git a/crates/store/src/build/cluster.rs b/crates/store/src/build/cluster.rs index cd5064d2..7b77327a 100644 --- a/crates/store/src/build/cluster.rs +++ b/crates/store/src/build/cluster.rs @@ -418,6 +418,8 @@ impl From for ClusterNode { last_renewal: UTCDateTime::from_timestamp(slot.last_renewal.cast_signed()), node_id: slot.node_id as u64, hostname: slot.hostname, + // INBUXA: #485, filled in from the store when the node is read + unbound_listeners: Default::default(), } } } diff --git a/resources/schema/schema.json.gz b/resources/schema/schema.json.gz index 32fd1c70..b0f8aaae 100644 Binary files a/resources/schema/schema.json.gz and b/resources/schema/schema.json.gz differ diff --git a/resources/schema/schema.json.sha256 b/resources/schema/schema.json.sha256 index 2030c4cf..4d83e19c 100644 --- a/resources/schema/schema.json.sha256 +++ b/resources/schema/schema.json.sha256 @@ -1 +1 @@ -KXw6nEosTA5QQYzIzA68OlHDImM7fjTIYCHRdaLTO8w \ No newline at end of file +s1j6j79sdVPo9onPNL8iJOJRz_V5NLJAaU6MHps8z54 \ No newline at end of file