node: add server_version field to Node.

This is a non-breaking change, because `Node` already has some private fields.

I decided not to include `server_version` in `PeerEndpoint` to avoid needless
cloning.

To obtain the server_version from `Peer`, one can use `Peer::into_peer_endpoint_tokens_and_server_version()`.
This consumes the `Peer` and moves the `server_version` to the caller.

Author: muzarski

scylla/src/cluster/metadata.rs

@@ -179,7 +179,9 @@ impl Peer {
         }
     }
 
-    pub(crate) fn into_peer_endpoint_and_tokens(self) -> (PeerEndpoint, Vec<Token>) {
+    pub(crate) fn into_peer_endpoint_tokens_and_server_version(
+        self,
+    ) -> (PeerEndpoint, Vec<Token>, Option<String>) {
         (
             PeerEndpoint {
                 host_id: self.host_id,
@@ -188,6 +190,7 @@ impl Peer {
                 rack: self.rack,
             },
             self.tokens,
+            self.server_version,
         )
     }
 }

scylla/src/cluster/node.rs

@@ -75,6 +75,7 @@ impl Display for NodeAddr {
 #[derive(Debug)]
 pub struct Node {
     pub host_id: Uuid,
+    pub server_version: Option<String>,
     pub address: NodeAddr,
     pub datacenter: Option<String>,
     pub rack: Option<String>,
@@ -92,6 +93,7 @@ impl Node {
     /// Creates a new node which starts connecting in the background.
     pub(crate) fn new(
         peer: PeerEndpoint,
+        server_version: Option<String>,
         pool_config: &PoolConfig,
         keyspace_name: Option<VerifiedKeyspaceName>,
         enabled: bool,
@@ -117,6 +119,7 @@ impl Node {
 
         Node {
             host_id,
+            server_version,
             address,
             datacenter,
             rack,
@@ -133,13 +136,18 @@ impl Node {
     ///
     /// - `node` - previous definition of that node
     /// - `address` - new address to connect to
-    pub(crate) fn inherit_with_ip_changed(node: &Node, endpoint: PeerEndpoint) -> Self {
+    pub(crate) fn inherit_with_ip_changed(
+        node: &Node,
+        endpoint: PeerEndpoint,
+        server_version: Option<String>,
+    ) -> Self {
         let address = endpoint.address;
         if let Some(ref pool) = node.pool {
             pool.update_endpoint(endpoint);
         }
         Self {
             address,
+            server_version,
             down_marker: false.into(),
             datacenter: node.datacenter.clone(),
             rack: node.rack.clone(),
@@ -367,6 +375,7 @@ mod tests {
         ) -> Self {
             Self {
                 host_id: id.unwrap_or(Uuid::new_v4()),
+                server_version: None,
                 address: address.unwrap_or(NodeAddr::Translatable(SocketAddr::from((
                     [255, 255, 255, 255],
                     0,

scylla/src/cluster/state.rs

@@ -84,21 +84,28 @@ impl ClusterState {
 
             let node: Arc<Node> = match known_peers.get(&peer_host_id) {
                 Some(node) if node.datacenter == peer.datacenter && node.rack == peer.rack => {
-                    let (peer_endpoint, tokens) = peer.into_peer_endpoint_and_tokens();
+                    let (peer_endpoint, tokens, server_version) =
+                        peer.into_peer_endpoint_tokens_and_server_version();
                     peer_tokens = tokens;
                     if node.address == peer_address {
                         node.clone()
                     } else {
                         // If IP changes, the Node struct is recreated, but the underlying pool is preserved and notified about the IP change.
-                        Arc::new(Node::inherit_with_ip_changed(node, peer_endpoint))
+                        Arc::new(Node::inherit_with_ip_changed(
+                            node,
+                            peer_endpoint,
+                            server_version,
+                        ))
                     }
                 }
                 _ => {
                     let is_enabled = host_filter.map_or(true, |f| f.accept(&peer));
-                    let (peer_endpoint, tokens) = peer.into_peer_endpoint_and_tokens();
+                    let (peer_endpoint, tokens, server_version) =
+                        peer.into_peer_endpoint_tokens_and_server_version();
                     peer_tokens = tokens;
                     Arc::new(Node::new(
                         peer_endpoint,
+                        server_version,
                         pool_config,
                         used_keyspace.clone(),
                         is_enabled,

scylla/src/routing/locator/test.rs

@@ -191,6 +191,7 @@ pub(crate) fn create_ring(metadata: &Metadata) -> impl Iterator<Item = (Token, A
     for peer in &metadata.peers {
         let node = Arc::new(Node::new(
             peer.to_peer_endpoint(),
+            None,
             &pool_config,
             None,
             true,