Struct Engine 

pub struct Engine { /* private fields */ }

The sharded engine. Owns handles to all shard tasks and routes requests by key hash.

Clone is cheap — it just clones the Vec<ShardHandle> (which are mpsc senders under the hood).

Implementations

impl Engine

pub fn new(shard_count: usize) -> Self

Creates an engine with shard_count shards using default config.

Each shard is spawned as a tokio task immediately. Panics if shard_count is zero.

pub fn with_config(shard_count: usize, config: EngineConfig) -> Self

Creates an engine with shard_count shards and the given config.

Spawns a single background drop thread shared by all shards for lazy-freeing large values.

Panics if shard_count is zero.

pub fn prepare( shard_count: usize, config: EngineConfig, ) -> (Self, Vec<PreparedShard>)

Creates the engine and prepared shards without spawning any tasks.

The caller is responsible for running each PreparedShard on the desired runtime via shard::run_prepared. This is the entry point for thread-per-core deployment where each OS thread runs its own single-threaded tokio runtime and one shard.

Panics if shard_count is zero.

pub fn with_available_cores() -> Self

Creates an engine with one shard per available CPU core.

Falls back to a single shard if the core count can’t be determined.

pub fn with_available_cores_config(config: EngineConfig) -> Self

Creates an engine with one shard per available CPU core and the given config.

pub fn shard_count(&self) -> usize

Returns the number of shards.

pub fn subscribe_replication(&self) -> Option<Receiver<ReplicationEvent>>

Creates a new broadcast receiver for replication events.

Returns None if no replication channel was configured. Each caller gets an independent receiver starting from the current broadcast position — not from the beginning of the stream.

pub fn subscribe_expired(&self) -> Option<Receiver<String>>

Creates a new broadcast receiver for expired key names.

Returns None if no expired-key channel was configured. Used by the server to subscribe a background task that fires keyspace notifications.

pub async fn send_to_shard( &self, shard_idx: usize, request: ShardRequest, ) -> Result<ShardResponse, ShardError>

Sends a request to a specific shard by index.

Used by SCAN to iterate through shards sequentially.

pub async fn route( &self, key: &str, request: ShardRequest, ) -> Result<ShardResponse, ShardError>

Routes a request to the shard that owns key.

pub async fn broadcast<F>( &self, make_req: F, ) -> Result<Vec<ShardResponse>, ShardError>

where F: Fn() -> ShardRequest,

Sends a request to every shard and collects all responses.

Dispatches to all shards first (so they start processing in parallel), then collects the replies. Used for commands like DBSIZE and INFO that need data from all shards.

pub async fn route_multi<F>( &self, keys: &[String], make_req: F, ) -> Result<Vec<ShardResponse>, ShardError>

where F: Fn(String) -> ShardRequest,

Routes requests for multiple keys concurrently.

Dispatches all requests without waiting, then collects responses. The response order matches the key order. Used for multi-key commands like DEL and EXISTS.

pub fn same_shard(&self, key1: &str, key2: &str) -> bool

Returns true if both keys are owned by the same shard.

pub fn shard_for_key(&self, key: &str) -> usize

Determines which shard owns a given key.

pub async fn dispatch_to_shard( &self, shard_idx: usize, request: ShardRequest, ) -> Result<Receiver<ShardResponse>, ShardError>

Sends a request to a shard and returns the reply channel without waiting for the response. Used by the connection handler to dispatch commands and collect responses separately.

pub async fn dispatch_reusable_to_shard( &self, shard_idx: usize, request: ShardRequest, reply: Sender<ShardResponse>, ) -> Result<(), ShardError>

Sends a request to a shard using a caller-owned mpsc reply channel.

Avoids the per-command oneshot allocation on the P=1 path.

pub async fn dispatch_batch_to_shard( &self, shard_idx: usize, requests: Vec<ShardRequest>, ) -> Result<Vec<Receiver<ShardResponse>>, ShardError>

Sends a batch of requests to a single shard as one channel message.

Returns one receiver per request, preserving order. This is the pipeline batching optimization: N commands targeting the same shard consume 1 channel slot instead of N, eliminating head-of-line blocking under high pipeline depths.

Trait Implementations

impl Clone for Engine

fn clone(&self) -> Engine

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Engine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.