wip: vshard config

src/main.rs

@@ -174,6 +174,23 @@ fn picolib_setup(args: &args::Run) {
                 Ok(())
             }),
         );
+        luamod.set(
+            "vshard_cfg",
+            tlua::function0(|| -> Result<traft::rpc::sharding::cfg::Cfg, Error> {
+                let node = traft::node::global()?;
+                traft::rpc::sharding::cfg::Cfg::from_storage(&node.storage.peers)
+            }),
+        );
+        l.exec(
+            "
+            picolib.test_space = function(name)
+                local s = box.schema.space.create(name, {is_sync = true, if_not_exists = true})
+                s:create_index('pk', {if_not_exists = true})
+                return s
+            end
+        ",
+        )
+        .unwrap();
     }
     luamod.set("log", &[()]);
     #[rustfmt::skip]

src/traft/rpc/mod.rs

@@ -5,6 +5,7 @@ use std::fmt::Debug;
 use serde::de::DeserializeOwned;
 
 pub mod replication;
+pub mod sharding;
 
 /// Types implementing this trait represent an RPC's (remote procedure call)
 /// arguments. This trait contains information about the request.

src/traft/rpc/sharding.rs

+#[rustfmt::skip]
+pub mod cfg {
+    use crate::traft::error::Error;
+    use crate::traft::storage::peer_field;
+    use crate::traft::storage::Peers;
+
+    use ::tarantool::tlua;
+
+    use std::collections::HashMap;
+
+    #[derive(Default, Clone, Debug, PartialEq, Eq)]
+    #[derive(tlua::PushInto, tlua::Push, tlua::LuaRead)]
+    pub struct Cfg {
+        sharding: HashMap<String, Replicaset>,
+        discovery_mode: DiscoveryMode,
+    }
+
+    #[derive(Default, Clone, Debug, PartialEq, Eq)]
+    #[derive(tlua::PushInto, tlua::Push, tlua::LuaRead)]
+    struct Replicaset {
+        replicas: HashMap<String, Replica>,
+    }
+
+    #[derive(Default, Clone, Debug, PartialEq, Eq)]
+    #[derive(tlua::PushInto, tlua::Push, tlua::LuaRead)]
+    struct Replica {
+        uri: String,
+        name: String,
+        master: bool,
+    }
+
+    #[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
+    #[derive(tlua::PushInto, tlua::Push, tlua::LuaRead)]
+    pub enum DiscoveryMode {
+        #[default]
+        Off,
+        On,
+        Once,
+    }
+
+    impl Cfg {
+        pub fn from_storage(peers: &Peers) -> Result<Self, Error> {
+            use peer_field::{InstanceId, InstanceUuid, PeerAddress, ReplicasetUuid, IsMaster};
+            type Fields = (InstanceId, InstanceUuid, PeerAddress, ReplicasetUuid, IsMaster);
+            let mut sharding: HashMap<String, Replicaset> = HashMap::new();
+            for (id, uuid, addr, rset, is_master) in peers.peers_fields::<Fields>()? {
+                let replicaset = sharding.entry(rset).or_default();
+                replicaset.replicas.insert(
+                    uuid,
+                    Replica {
+                        uri: format!("guest:@{addr}"),
+                        name: id.into(),
+                        master: is_master,
+                    },
+                );
+            }
+            Ok(Self {
+                sharding,
+                discovery_mode: DiscoveryMode::Off,
+            })
+        }
+    }
+}