Struct NodeBuilder 

pub struct NodeBuilder<SE, SM>
where
    SE: StorageEngine + Debug,
    SM: StateMachine + Debug,
{ /* private fields */ }

Builder for creating a Raft node

Provides a fluent API for configuring and constructing a Node.

Example

use d_engine_server::{NodeBuilder, FileStorageEngine, FileStateMachine};

let node = NodeBuilder::new(None, shutdown_rx)
    .storage_engine(Arc::new(FileStorageEngine::new(...)?))
    .state_machine(Arc::new(FileStateMachine::new(...).await?))
    .start().await?;

Implementations

impl<SE, SM> NodeBuilder<SE, SM>

where SE: StorageEngine + Debug, SM: StateMachine + Debug,

pub fn new(cluster_path: Option<&str>, shutdown_signal: Receiver<()>) -> Self

Creates a new NodeBuilder with cluster configuration loaded from file

Arguments

• cluster_path - Optional path to node-specific cluster configuration
• shutdown_signal - Watch channel for graceful shutdown signaling

Panics

Will panic if configuration loading fails (consider returning Result instead)

pub fn from_cluster_config( cluster_config: ClusterConfig, shutdown_signal: Receiver<()>, ) -> Self

Constructs NodeBuilder from in-memory cluster configuration

Arguments

• cluster_config - Pre-built cluster configuration
• shutdown_signal - Graceful shutdown notification channel

Usage

let builder = NodeBuilder::from_cluster_config(my_config, shutdown_rx);

pub fn init(node_config: RaftNodeConfig, shutdown_signal: Receiver<()>) -> Self

Core initialization logic shared by all construction paths

pub fn storage_engine(self, storage_engine: Arc<SE>) -> Self

Sets a custom storage engine implementation

pub fn state_machine(self, state_machine: Arc<SM>) -> Self

Sets a custom state machine implementation

pub fn node_config(self, node_config: RaftNodeConfig) -> Self

Replaces the entire node configuration

pub fn raft_config(self, config: RaftConfig) -> Self

Replaces the raft configuration

pub async fn build(self) -> Result<Self>

Finalizes the builder and constructs the Raft node instance.

Initializes default implementations for any unconfigured components:

• Creates file-based databases for state machine and logs
• Sets up default gRPC transport
• Initializes commit handling subsystem
• Configures membership management

Panics

Panics if essential components cannot be initialized

pub fn with_custom_state_machine_handler( self, handler: Arc<SMHOF<RaftTypeConfig<SE, SM>>>, ) -> Self

Spawn watch dispatcher as background task.

The dispatcher manages all watch streams for the lifetime of the node. Sets a custom state machine handler implementation.

This allows developers to provide their own implementation of the state machine handler which processes committed log entries and applies them to the state machine.

Arguments

• handler - custom state machine handler that must implement the StateMachineHandler trait

Notes

• The handler must be thread-safe as it will be shared across multiple threads
• If not set, a default implementation will be used during build()
• The handler should properly handle snapshot creation and restoration

pub async fn start(self) -> Result<Arc<Node<RaftTypeConfig<SE, SM>>>>

Builds and starts the Raft node.

This is the primary method to initialize and start a node. It performs:

1. State machine initialization (including lease injection if applicable)
2. Raft core construction
3. Background task spawning (commit handler, replication, election)
4. gRPC server startup for cluster communication

Returns

An Arc<Node> ready for operation

Errors

Returns an error if any initialization step fails

Example

let node = NodeBuilder::init(config, shutdown_rx)
    .storage_engine(storage)
    .state_machine(state_machine)
    .start().await?;