How to deserialize a Vec<SocketAddr> - rust

Question

I currently deserialize a JSON array into Vec<String> and down stream in my application I convert individual String to SocketAddr.
I would like to do the deserialiation into Vec<SocketAddr> with serde instead.
use serde::Deserialize;
use std::net::SocketAddr;
#[derive(Debug, Deserialize)]
struct Doc {
// It would be nice to have Vec<SocketAddr> instead
hosts: Vec<String>
}
fn main(){
let data = r#"
{"hosts": ["localhost:8000","localhost:8001"]}
"#;
let doc: Doc = serde_json::from_str(data).unwrap();
dbg!(doc);
}

Answer 1

I'd like to disagree with the other two answers: You can absolutely deserialize strings like "localhost:80" to a (Vec of) SocketAddr. But you absolutely shouldn't. Let me explain:
Your problem is that SocketAddr only holds an IP address + port, not hostnames. You can solve this by resolving hostnames into SockAddr through ToSocketAddrs (and then flattening the result because one hostname can resolve to multiple addrs):
#[derive(Debug, Deserialize)]
struct Doc {
#[serde(deserialize_with = "flatten_resolve_addrs")]
hosts: Vec<SocketAddr>,
}
fn flatten_resolve_addrs<'de, D>(de: D) -> Result<Vec<SocketAddr>, D::Error>
where
D: Deserializer<'de>,
{
// Being a little lazy here about allocations and error handling.
// Because again, you shouldn't do this.
let unresolved = Vec::<String>::deserialize(de)?;
let mut resolved = vec![];
for a in unresolved {
let a = a
.to_socket_addrs()
.map_err(|e| serde::de::Error::custom(e))?;
for a in a {
resolved.push(a);
}
}
Ok(resolved)
}
Playground
You shouldn't do this because, deserialization should really round-trip through serialization, and be a pure function of the input bytes, but resolving addresses may access the network. Problems are:
What's the retry logic when resolution fails?
If your code is long running, the resolution result might change (from dns load balancing, dynamic dns, network config changes, …), but you can't re-resolve the addresses.
If your code is started as a system service, it might fail to start up with a deserialization error if the network isn't fully configured yet.
If a connection to one of the specified addresses fails, you have no way of printing a nice error message with the target hostname.
How would you configure a default port for this?
(Doing these things wrong is a pet peeve of mine, you'll find it in nginx, Kubernetes, Zookeeper, …)
Personally, I'd probably keep the Vec<String> for simplicity reasons, but you might also choose to do something like deserializing to Vec<(Either<IpAddr, Box<str>>, Option<u16>)> so you can check whether the strings are valid addresses, but do things like hostname resolution and providing a default port when you connect to those addresses.

Answer 2

Serde supports deserializing to SocketAddr, but your input isn't able to be parsed because localhost is not a valid IPv4 or IPv6 address.
The input needs to be a valid IPv4 or IPv6 address for it to deserialize directly into a SocketAddr. If you have control over your input data, this would work:
use serde::Deserialize;
use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4, ToSocketAddrs};
#[derive(Debug, Deserialize)]
struct Doc {
hosts: Vec<SocketAddr>,
}
fn main() {
let data = r#"
{"hosts": ["127.0.0.1:8000","127.0.0.1:8001"]}
"#;
let doc: Doc = serde_json::from_str(data).unwrap();
dbg!(doc);
}
Here's the output:
[src/main.rs:15] doc = Doc {
hosts: [
127.0.0.1:8000,
127.0.0.1:8001,
],
}

Answer 3

You can deserialize into SocketAddr directly, no extra work required:
use serde::Deserialize;
use std::net::SocketAddr;
#[derive(Debug, Deserialize)]
struct Doc {
// It would be nice to have Vec<SocketAddr> instead
hosts: Vec<SocketAddr>,
}
fn main() {
let data = r#"
{"hosts": ["172.0.0.1:8000"]}
"#;
let doc: Doc = serde_json::from_str(data).unwrap();
dbg!(doc);
}
[src/main.rs:15] doc = Doc {
hosts: [
172.0.0.1:8000,
],
}
Your problem is that "localhost" is not a valid SocketAddr.