Struct Server 

pub struct Server { /* private fields */ }

VFS agent server.

Construct a connected server with new or new_split and call serve. On Unix, bind constructs a listener that accepts sessions until a client requests shutdown.

Implementations

impl Server

pub async fn new<T>(stream: T) -> Result<Self>

where T: AsyncRead + AsyncWrite + Unpin + Send + 'static,

Creates an opaque-only VFS server over a bidirectional byte stream.

pub async fn new_split<R, W>(reader: R, writer: W) -> Result<Self>

where R: AsyncRead + Send + 'static, W: AsyncWrite + Send + 'static,

Creates an opaque-only VFS server on separate reader and writer streams.

pub async fn bind(path: impl AsRef<Path>) -> Result<Self>

Available on Unix only.

Binds a Unix-domain listener for VFS agent connections.

pub async fn bind_with_key( path: impl AsRef<Path>, key: Option<AuthKey>, ) -> Result<Self>

Available on Unix only.

Binds a Unix-domain listener that requires mutual proof of a pre-shared key from every connection.

The socket’s permissions cannot distinguish the intended client when the peer’s uid is not knowable in advance; key is what does. A connection that fails the check is dropped during negotiation, before it can issue any request.

pub async fn from_named_pipe_client(pipe: NamedPipeClient) -> Result<Self>

Available on Windows only.

Creates a VFS RPC server on the client end of a connected Windows named pipe.

pub async fn accept(self) -> Result<()>

Available on Unix only.

Accepts connections until a client requests server shutdown.

Each connection runs in an independent handler task. Routine client disconnects are ignored; unexpected handler failures are reported to standard error.

pub async fn accept_one<F>(self, established: F) -> Result<()>

where F: FnOnce(),

Available on Unix only.

Accepts connections until one completes negotiation, then serves that session alone.

established runs once, as soon as some connection has negotiated successfully — the point at which the listening socket has done its job and the caller can unlink it. Nothing is accepted afterwards.

Connections that fail to negotiate (including failing authentication) are dropped and do not consume the single slot, so an impostor that reaches the socket first cannot deny the intended client its session; it can only waste an attempt. Negotiation has a timeout and a fixed limit on in-flight attempts, so a peer that connects and then says nothing cannot stall or crowd out the real one either.

pub async fn serve(self) -> Result<()>

Serves one connected VFS session until it closes or fails.