use core::fmt;
use std::collections::BTreeMap;
use std::net::{SocketAddr, TcpListener};
#[cfg(unix)]
use crate::handover::HeldListener;
pub struct ListenSockets {
entries: Vec<Entry>,
}
struct Entry {
name: String,
configured: SocketAddr,
listener: TcpListener,
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ListenError {
Bind {
name: String,
address: String,
reason: String,
},
}
impl fmt::Display for ListenError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Bind {
name,
address,
reason,
} => write!(f, "could not listen on {address} for `{name}`: {reason}"),
}
}
}
impl core::error::Error for ListenError {}
impl ListenSockets {
pub fn bind(table: &BTreeMap<String, String>) -> Result<Self, ListenError> {
Self::bind_keeping(None, table)
}
pub fn bind_keeping(
previous: Option<&Self>,
table: &BTreeMap<String, String>,
) -> Result<Self, ListenError> {
let mut entries = Vec::with_capacity(table.len());
for (name, address) in table {
let fail = |reason: String| ListenError::Bind {
name: name.clone(),
address: address.clone(),
reason,
};
let parsed: SocketAddr = address
.parse()
.map_err(|error: core::net::AddrParseError| fail(error.to_string()))?;
let kept = previous
.and_then(|held| held.entries.iter().find(|e| e.configured == parsed))
.and_then(|e| e.listener.try_clone().ok());
let listener = match kept {
Some(listener) => listener,
None => TcpListener::bind(parsed).map_err(|error| fail(error.to_string()))?,
};
entries.push(Entry {
name: name.clone(),
configured: parsed,
listener,
});
}
Ok(Self { entries })
}
#[must_use]
pub fn is_bound_from(&self, table: &BTreeMap<String, String>) -> bool {
self.entries.len() == table.len()
&& self.entries.iter().all(|e| {
table
.get(&e.name)
.and_then(|a| a.parse::<SocketAddr>().ok())
== Some(e.configured)
})
}
pub fn names(&self) -> impl Iterator<Item = &str> {
self.entries.iter().map(|e| e.name.as_str())
}
#[must_use]
pub fn len(&self) -> usize {
self.entries.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn local_addrs(&self) -> std::io::Result<Vec<SocketAddr>> {
self.entries
.iter()
.map(|e| e.listener.local_addr())
.collect()
}
#[cfg(unix)]
pub(crate) fn duplicates(&self) -> std::io::Result<Vec<std::os::fd::OwnedFd>> {
self.entries
.iter()
.map(|e| e.listener.try_clone().map(std::os::fd::OwnedFd::from))
.collect()
}
}
#[cfg(unix)]
impl ListenSockets {
pub(crate) fn hold(&self, sheep: &str) -> std::io::Result<Vec<HeldListener>> {
self.entries
.iter()
.map(|e| {
Ok(HeldListener {
sheep: sheep.to_string(),
name: e.name.clone(),
address: e.configured.to_string(),
fd: e.listener.try_clone()?.into(),
})
})
.collect()
}
pub(crate) fn from_adopted(mut entries: Vec<(String, SocketAddr, TcpListener)>) -> Self {
entries.sort_by(|a, b| a.0.cmp(&b.0));
Self {
entries: entries
.into_iter()
.map(|(name, configured, listener)| Entry {
name,
configured,
listener,
})
.collect(),
}
}
}
#[cfg(all(test, unix))]
impl ListenSockets {
pub(crate) fn from_descriptors(entries: Vec<(&str, std::os::fd::OwnedFd)>) -> Self {
let mut entries: Vec<Entry> = entries
.into_iter()
.map(|(name, fd)| Entry {
name: name.to_string(),
configured: SocketAddr::from(([0, 0, 0, 0], 0)),
listener: TcpListener::from(fd),
})
.collect();
entries.sort_by(|a, b| a.name.cmp(&b.name));
Self { entries }
}
}
impl PartialEq for ListenSockets {
fn eq(&self, other: &Self) -> bool {
self.entries.len() == other.entries.len()
&& self
.entries
.iter()
.zip(&other.entries)
.all(|(a, b)| a.name == b.name && a.configured == b.configured)
}
}
impl Eq for ListenSockets {}
impl fmt::Debug for ListenSockets {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_map()
.entries(
self.entries
.iter()
.map(|e| (&e.name, e.configured.to_string())),
)
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
fn table(entries: &[(&str, &str)]) -> BTreeMap<String, String> {
entries
.iter()
.map(|(k, v)| ((*k).to_string(), (*v).to_string()))
.collect()
}
#[test]
fn it_binds_each_entry_in_name_order() {
let sockets =
ListenSockets::bind(&table(&[("web", "127.0.0.1:0"), ("admin", "127.0.0.1:0")]))
.unwrap();
assert_eq!(sockets.names().collect::<Vec<_>>(), ["admin", "web"]);
assert_eq!(sockets.len(), 2);
let addrs = sockets.local_addrs().unwrap();
assert_ne!(addrs[0].port(), 0, "the OS picked a real port");
assert_ne!(addrs[0], addrs[1]);
}
#[test]
fn a_taken_address_fails_the_bind_and_names_it() {
let held = TcpListener::bind("127.0.0.1:0").unwrap();
let address = held.local_addr().unwrap().to_string();
let error = ListenSockets::bind(&table(&[("http", &address)])).unwrap_err();
let ListenError::Bind {
name,
address: named,
..
} = &error;
assert_eq!((name.as_str(), named.as_str()), ("http", address.as_str()));
assert!(
error
.to_string()
.starts_with(&format!("could not listen on {address} for `http`: ")),
"{error}"
);
}
#[test]
fn an_unparsable_address_fails_the_bind_and_names_it() {
let error = ListenSockets::bind(&table(&[("http", "not-an-address")])).unwrap_err();
assert!(error.to_string().contains("not-an-address"), "{error}");
}
#[test]
fn a_failed_bind_leaves_the_earlier_entries_closed() {
let held = TcpListener::bind("127.0.0.1:0").unwrap();
let taken = held.local_addr().unwrap().to_string();
let free = TcpListener::bind("127.0.0.1:0").unwrap();
let free_addr = free.local_addr().unwrap();
drop(free);
ListenSockets::bind(&table(&[("a", &free_addr.to_string()), ("b", &taken)])).unwrap_err();
TcpListener::bind(free_addr).expect("the first entry's socket closed with the failure");
}
#[test]
fn it_remembers_what_it_was_bound_from() {
let from = table(&[("http", "127.0.0.1:0")]);
let sockets = ListenSockets::bind(&from).unwrap();
assert!(sockets.is_bound_from(&from));
assert!(!sockets.is_bound_from(&table(&[("http", "127.0.0.1:1")])));
assert!(!sockets.is_bound_from(&table(&[("web", "127.0.0.1:0")])));
assert!(!sockets.is_bound_from(&BTreeMap::new()));
}
#[test]
fn an_address_the_previous_set_holds_keeps_its_socket_under_a_new_name() {
let held = ListenSockets::bind(&table(&[("http", "127.0.0.1:0")])).unwrap();
let addr = held.local_addrs().unwrap()[0];
let first = table(&[("http", &addr.to_string())]);
drop(held);
let held = ListenSockets::bind(&first).unwrap();
let renamed = table(&[("web", &addr.to_string())]);
let next = ListenSockets::bind_keeping(Some(&held), &renamed)
.expect("the held address is not bound a second time");
assert_eq!(next.names().collect::<Vec<_>>(), ["web"]);
assert_eq!(next.local_addrs().unwrap(), [addr]);
assert!(
ListenSockets::bind(&renamed).is_err(),
"the old set still holds the address, so a plain bind would fail"
);
}
#[test]
fn a_respelled_address_is_the_same_address() {
let held = ListenSockets::bind(&table(&[("http", "127.0.0.1:0")])).unwrap();
let port = held.local_addrs().unwrap()[0].port();
drop(held);
let held = ListenSockets::bind(&table(&[("http", &format!("127.0.0.1:{port}"))])).unwrap();
let respelled = table(&[("http", &format!("127.0.0.1:0{port}"))]);
assert!(held.is_bound_from(&respelled));
let next = ListenSockets::bind_keeping(Some(&held), &respelled)
.expect("the held address is kept, not bound again");
assert_eq!(next.local_addrs().unwrap(), held.local_addrs().unwrap());
}
#[test]
fn debug_shows_names_and_addresses_only() {
let sockets = ListenSockets::bind(&table(&[("http", "127.0.0.1:0")])).unwrap();
assert_eq!(format!("{sockets:?}"), r#"{"http": "127.0.0.1:0"}"#);
}
#[cfg(unix)]
#[test]
fn a_duplicate_is_the_same_listening_socket() {
let sockets = ListenSockets::bind(&table(&[("http", "127.0.0.1:0")])).unwrap();
let addr = sockets.local_addrs().unwrap()[0];
let duplicates = sockets.duplicates().unwrap();
assert_eq!(duplicates.len(), 1);
let accepting = TcpListener::from(duplicates.into_iter().next().unwrap());
let _client = std::net::TcpStream::connect(addr).unwrap();
let (_conn, _) = accepting.accept().unwrap();
}
}