refactor: you really shouldn't optimize prematurely :(

src/traft/rpc/sharding.rs

@@ -64,7 +64,6 @@ impl super::Request for Request {
 #[rustfmt::skip]
 pub mod cfg {
     use crate::traft::error::Error;
-    use crate::traft::storage::peer_field;
     use crate::traft::storage::{Peers, Storage};
 
     use ::tarantool::tlua;
@@ -123,19 +122,18 @@ pub mod cfg {
         }
 
         pub fn new(peers: &Peers, replicaset_weights: ReplicasetWeights) -> Result<Self, Error> {
-            use peer_field::{InstanceId, InstanceUuid, PeerAddress, ReplicasetUuid, ReplicasetId, IsMaster};
-            type Fields = (InstanceId, InstanceUuid, PeerAddress, ReplicasetUuid, ReplicasetId, IsMaster);
             let mut sharding: HashMap<String, Replicaset> = HashMap::new();
-            for (id, uuid, addr, rset, rset_id, is_master) in peers.peers_fields::<Fields>()? {
-                let replicaset = sharding.entry(rset).or_insert_with(||
-                    Replicaset::with_weight(replicaset_weights.get(&rset_id).copied())
+            for peer in peers.iter()? {
+                let replicaset_id = peer.replicaset_id;
+                let replicaset = sharding.entry(peer.replicaset_uuid).or_insert_with(||
+                    Replicaset::with_weight(replicaset_weights.get(&replicaset_id).copied())
                 );
                 replicaset.replicas.insert(
-                    uuid,
+                    peer.instance_uuid,
                     Replica {
-                        uri: format!("guest:@{addr}"),
-                        name: id.into(),
-                        master: is_master,
+                        uri: format!("guest:@{}", peer.peer_address),
+                        name: peer.instance_id.into(),
+                        master: peer.is_master,
                     },
                 );
             }

src/traft/storage.rs

@@ -327,6 +327,12 @@ impl Peers {
         Ok(PeersFields::new(iter))
     }
 
+    #[inline]
+    pub fn iter(&self) -> tarantool::Result<PeerIter> {
+        let iter = self.space().select(IteratorType::All, &())?;
+        Ok(PeerIter::new(iter))
+    }
+
     #[inline]
     pub fn all_peers(&self) -> tarantool::Result<Vec<traft::Peer>> {
         self.space()
@@ -555,6 +561,31 @@ impl PeerId for traft::InstanceId {
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// PeerIter
+////////////////////////////////////////////////////////////////////////////////
+
+pub struct PeerIter {
+    iter: IndexIterator,
+}
+
+impl PeerIter {
+    fn new(iter: IndexIterator) -> Self {
+        Self { iter }
+    }
+}
+
+impl Iterator for PeerIter {
+    type Item = traft::Peer;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter
+            .next()
+            .as_ref()
+            .map(Tuple::decode)
+            .map(Result::unwrap)
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // PeersFields
 ////////////////////////////////////////////////////////////////////////////////