WIP - Reflect changes in python binding

binding/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "raftify-py"
-version = "0.1.67"
+version = "0.1.78"
 authors = ["Lablup Inc."]
 license = "Apache-2.0"
 repository = "https://github.com/lablup/raftify"
@@ -19,7 +19,8 @@ pyo3-asyncio = { version = "0.20.0", features = ["tokio-runtime"] }
 pythonize = "0.20.0"
 tokio = { version = "1.4", features = ["full"] }
 async-trait = "0.1.48"
-raftify = { version = "0.1.67", default-features = false }
+raftify = { version = "0.1.78", features = ["heed_storage"] , default-features = false }
+raftify_cli = { version = "0.1.1" }
 slog = { version = "2.2", features = ["max_level_trace", "release_max_level_trace"] }
 slog-envlogger = "2.1.0"
 slog-term = "2.9.0"

binding/python/src/bindings/state_machine.rs → binding/python/src/bindings/abstract_types.rs

@@ -2,7 +2,13 @@ use async_trait::async_trait;
 use once_cell::sync::Lazy;
 use pyo3::{prelude::*, types::PyBytes};
 use pyo3_asyncio::TaskLocals;
-use raftify::{AbstractLogEntry, AbstractStateMachine, Error, Result};
+use raftify::{
+    raft::{
+        prelude::{ConfState, Entry, HardState, Snapshot},
+        GetEntriesContext, RaftState, Storage,
+    },
+    AbstractLogEntry, AbstractStateMachine, Error, Result,
+};
 use std::{fmt, sync::Mutex};
 
 use super::{

binding/python/src/bindings/cli.rs

@@ -1,14 +1,17 @@
 use pyo3::prelude::*;
 use pyo3_asyncio::tokio::future_into_py;
-use raftify::cli::cli_handler;
+use raftify::HeedStorage;
+use raftify_cli::cli_handler;
 
-use super::state_machine::{PyFSM, PyLogEntry};
+use super::abstract_types::{PyFSM, PyLogEntry};
 
 // When args is None, std::env::args is automatically used.
 #[pyfunction]
 pub fn cli_main<'a>(args: Option<Vec<String>>, py: Python<'a>) -> PyResult<&'a PyAny> {
     future_into_py(py, async move {
-        cli_handler::<PyLogEntry, PyFSM>(args).await.unwrap();
+        cli_handler::<PyLogEntry, HeedStorage, PyFSM>(args)
+            .await
+            .unwrap();
         Ok(())
     })
 }

binding/python/src/bindings/config.rs

@@ -15,10 +15,9 @@ pub struct PyConfig {
     pub lmdb_map_size: u64,
     pub cluster_id: String,
     pub conf_change_request_timeout: f32,
+    pub bootstrap_from_snapshot: bool,
     pub initial_peers: Option<PyPeers>,
     pub snapshot_interval: Option<f32>,
-    pub restore_wal_from: Option<u64>,
-    pub restore_wal_snapshot_from: Option<u64>,
 }
 
 #[pymethods]
@@ -36,8 +35,7 @@ impl PyConfig {
         conf_change_request_timeout: Option<f32>,
         initial_peers: Option<PyPeers>,
         snapshot_interval: Option<f32>,
-        restore_wal_from: Option<u64>,
-        restore_wal_snapshot_from: Option<u64>,
+        bootstrap_from_snapshot: Option<bool>,
     ) -> Self {
         let cfg = Config::default();
 
@@ -56,8 +54,8 @@ impl PyConfig {
             conf_change_request_timeout.unwrap_or(cfg.conf_change_request_timeout);
         let initial_peers = initial_peers;
         let snapshot_interval = snapshot_interval;
-        let restore_wal_from = restore_wal_from;
-        let restore_wal_snapshot_from = restore_wal_snapshot_from;
+        let bootstrap_from_snapshot =
+            bootstrap_from_snapshot.unwrap_or(cfg.bootstrap_from_snapshot);
 
         Self {
             raft_config,
@@ -71,8 +69,7 @@ impl PyConfig {
             conf_change_request_timeout,
             initial_peers,
             snapshot_interval,
-            restore_wal_from,
-            restore_wal_snapshot_from,
+            bootstrap_from_snapshot,
         }
     }
 }
@@ -91,8 +88,7 @@ impl From<PyConfig> for Config {
             conf_change_request_timeout: config.conf_change_request_timeout,
             initial_peers: config.initial_peers.map(|peers| peers.inner),
             raft_config: config.raft_config.inner,
-            restore_wal_from: config.restore_wal_from,
-            restore_wal_snapshot_from: config.restore_wal_snapshot_from,
+            bootstrap_from_snapshot: config.bootstrap_from_snapshot,
         }
     }
 }

binding/python/src/bindings/mod.rs

@@ -1,3 +1,4 @@
+pub mod abstract_types;
 pub mod cli;
 pub mod cluster_join_ticket;
 pub mod confchange_request;
@@ -11,7 +12,6 @@ pub mod raft_bootstrapper;
 pub mod raft_client;
 pub mod raft_node;
 pub mod raft_rs;
-pub mod role;
+pub mod initial_role;
 pub mod slogger;
-pub mod state_machine;
 pub mod utils;

binding/python/src/bindings/peer.rs

@@ -2,7 +2,7 @@ use pyo3::prelude::*;
 use pyo3_asyncio::tokio::future_into_py;
 use raftify::Peer;
 
-use super::role::PyInitialRole;
+use super::initial_role::PyInitialRole;
 
 #[derive(Clone)]
 #[pyclass(name = "Peer")]

binding/python/src/bindings/peers.rs

@@ -7,7 +7,7 @@ use raftify::Peers;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, hash::BuildHasherDefault};
 
-use super::{peer::PyPeer, role::PyInitialRole};
+use super::{peer::PyPeer, initial_role::PyInitialRole};
 
 #[derive(Serialize, Deserialize, Clone)]
 #[pyclass(dict, name = "Peers")]

binding/python/src/bindings/raft_bootstrapper.rs

@@ -1,20 +1,20 @@
 use pyo3::{exceptions::PyException, prelude::*, types::PyString};
 use pyo3_asyncio::tokio::future_into_py;
-use raftify::Raft;
+use raftify::{HeedStorage, Raft};
 use std::sync::Arc;
 
 use super::{
+    abstract_types::{PyFSM, PyLogEntry},
     cluster_join_ticket::PyClusterJoinTicket,
     config::PyConfig,
     logger::PyLogger,
     raft_node::PyRaftNode,
-    state_machine::{PyFSM, PyLogEntry},
 };
 
 #[derive(Clone)]
 #[pyclass(name = "Raft")]
 pub struct PyRaftFacade {
-    inner: Raft<PyLogEntry, PyFSM>,
+    inner: Raft<PyLogEntry, HeedStorage, PyFSM>,
 }
 
 #[pymethods]
@@ -30,9 +30,16 @@ impl PyRaftFacade {
         let fsm = PyFSM::new(fsm);
         let addr = addr.to_string();
 
+        let storage = HeedStorage::create(
+            &config.log_dir.clone(),
+            &config.clone().into(),
+            Arc::new(PyLogger::new(logger.clone())),
+        ).expect("Failed to create heed storage");
+
         let raft = Raft::bootstrap(
             node_id,
             addr,
+            storage,
             fsm,
             config.into(),
             Arc::new(PyLogger::new(logger)),
@@ -49,9 +56,12 @@ impl PyRaftFacade {
         py: Python<'a>,
     ) -> PyResult<&'a PyAny> {
         future_into_py(py, async move {
-            let ticket = Raft::<PyLogEntry, PyFSM>::request_id(raft_addr, peer_addr.to_owned())
-                .await
-                .unwrap();
+            let ticket = Raft::<PyLogEntry, HeedStorage, PyFSM>::request_id(
+                raft_addr,
+                peer_addr.to_owned(),
+            )
+            .await
+            .unwrap();
             Ok(PyClusterJoinTicket { inner: ticket })
         })
     }

binding/python/src/bindings/raft_node.rs

@@ -1,23 +1,23 @@
 use pyo3::{prelude::*, types::PyString};
 use pyo3_asyncio::tokio::future_into_py;
-use raftify::RaftNode;
+use raftify::{HeedStorage, RaftNode};
 
 use super::{
+    abstract_types::{PyFSM, PyLogEntry},
     cluster_join_ticket::PyClusterJoinTicket,
     peers::PyPeers,
     raft_rs::eraftpb::{conf_change_v2::PyConfChangeV2, message::PyMessage},
-    role::PyInitialRole,
-    state_machine::{PyFSM, PyLogEntry},
+    initial_role::PyInitialRole,
 };
 
 #[derive(Clone)]
 #[pyclass(name = "RaftNode")]
 pub struct PyRaftNode {
-    pub inner: RaftNode<PyLogEntry, PyFSM>,
+    pub inner: RaftNode<PyLogEntry, HeedStorage, PyFSM>,
 }
 
 impl PyRaftNode {
-    pub fn new(inner: RaftNode<PyLogEntry, PyFSM>) -> Self {
+    pub fn new(inner: RaftNode<PyLogEntry, HeedStorage, PyFSM>) -> Self {
         PyRaftNode { inner }
     }
 }

binding/python/src/lib.rs

@@ -20,7 +20,7 @@ fn raftify(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_class::<bindings::raft_node::PyRaftNode>()?;
     m.add_class::<bindings::raft_rs::config::PyRaftConfig>()?;
     m.add_class::<bindings::raft_rs::readonly_option::PyReadOnlyOption>()?;
-    m.add_class::<bindings::role::PyInitialRole>()?;
+    m.add_class::<bindings::initial_role::PyInitialRole>()?;
 
     m.add_class::<bindings::raft_rs::eraftpb::conf_change_single::PyConfChangeSingle>()?;
     m.add_class::<bindings::raft_rs::eraftpb::conf_change_transition::PyConfChangeTransition>()?;
@@ -37,12 +37,12 @@ fn raftify(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(bindings::cli::cli_main, m)?)?;
 
     m.add_function(wrap_pyfunction!(
-        bindings::state_machine::set_log_entry_deserializer,
+        bindings::abstract_types::set_log_entry_deserializer,
         m
     )?)?;
 
     m.add_function(wrap_pyfunction!(
-        bindings::state_machine::set_fsm_deserializer,
+        bindings::abstract_types::set_fsm_deserializer,
         m
     )?)?;
 

raftify-cli/src/commands/debug.rs

@@ -29,7 +29,7 @@ pub fn debug_persisted<LogStorage: StableStorage>(path: &str, logger: slog::Logg
             }),
         )?,
         StorageType::InMemory => {
-            panic!("Inmemory storage does not support this feature");
+            panic!("InMemory storage does not support this feature");
         }
         _ => {
             panic!("Unsupported storage type");