Struct Server 

pub struct Server { /* private fields */ }

Configured-but-not-running server.

Build one with ServerBuilder, then call Server::start to spawn the background tasks.

Implementations

impl Server

pub fn vector_registry(&self) -> &Arc<VectorRegistry>

Borrow the crate::vector::registry::VectorRegistry this server was built with. The crate::embed::ServerBuilder installs a fresh registry by default; call crate::embed::ServerBuilder::with_vector_registry to share one across multiple servers.

pub fn pool_name(&self) -> &str

The pool name configured in the YAML / builder.

pub async fn start(self) -> Result<ServerHandle, EmbedError>

Spawn background tasks on the current tokio runtime and return a ServerHandle.

start is non-blocking. The returned handle is Clone + Send + Sync.

In-process only

The embedded server in this stage is in-process only: the listen: and dyn_listen: sockets bind so that configured ports are reservable and post-bind reporting works, but cross-process clients connecting to those ports see open-then-immediate-close (with a runtime warning logged on each accept). The sanctioned way to drive an embedded Server from in-process code is ServerHandle::inject_request. Cross-process traffic is supported by the dynomited binary, which wires the proxy module directly. Wiring the embedded accept loop to the dispatcher is tracked as a follow-up; the contract is documented in docs/parity.md.

Examples

use dynomite::embed::ServerBuilder;
use dynomite::conf::DataStore;
let server = ServerBuilder::new("dyn_o_mite")
    .listen("127.0.0.1:0".parse().unwrap())
    .dyn_listen("127.0.0.1:0".parse().unwrap())
    .data_store(DataStore::Redis)
    .servers(vec![dynomite::conf::ConfServer::parse("127.0.0.1:6379:1").unwrap()])
    .tokens_str("0")
    .enable_gossip(false)
    .build()
    .unwrap();
let handle = server.start().await.unwrap();
handle.shutdown().await.unwrap();

impl Server

pub fn builder(pool_name: impl Into<String>) -> ServerBuilder

Convenience entry point.

Examples

use dynomite::embed::Server;
let _b = Server::builder("dyn_o_mite");

pub async fn start_with( builder: ServerBuilder, ) -> Result<ServerHandle, EmbedError>

One-shot “validate, build, and start” helper.

Equivalent to calling builder.build()?.start().await. The chained-call form remains available for embedders that want to inspect the Server before spawning tasks; this helper exists because most embedders only ever build then immediately start.

Errors

Returns the same EmbedError variants that ServerBuilder::build and Server::start surface.

Examples

use dynomite::embed::{Server, ServerBuilder};
use dynomite::conf::DataStore;
let builder = ServerBuilder::new("dyn_o_mite")
    .listen("127.0.0.1:0".parse().unwrap())
    .dyn_listen("127.0.0.1:0".parse().unwrap())
    .data_store(DataStore::Redis)
    .servers(vec![dynomite::conf::ConfServer::parse("127.0.0.1:6379:1").unwrap()])
    .tokens_str("0");
let handle = Server::start_with(builder).await.unwrap();
handle.shutdown().await.unwrap();

Trait Implementations

impl Debug for Server

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

Formats the value using the given formatter.