Struct App 

pub struct App<Signer, Context, KnownVerifiers, Routes> { /* private fields */ }

The application builder and, once started, runtime.

Construct with App::new, configure with App::route, App::on_start, and App::mtu, then call App::start to connect to NFD and begin serving. See the module docs for a full example.

Implementations

impl<Signer, Context> App<Signer, Context, KnownVerifiers, BTreeMap<Name, RouteHandler<Context>>>

where Signer: SignMethod + Send + Sync + 'static, Context: Clone + Send + 'static,

pub fn new(signer: Signer, context: Context) -> Self

Starts building an app that signs outgoing Data with signer and clones context into every route and lifecycle callback.

The NFD socket path is fixed to /var/run/nfd/nfd.sock, the standard location for a local NFD install; it isn’t configurable.

impl<Signer, Context, Verifiers> App<Signer, Context, Verifiers, BTreeMap<Name, RouteHandler<Context>>>

where Signer: SignMethod + Send + Sync + 'static, Context: Clone + Send + 'static, Verifiers: ToVerifier + Send + Sync + 'static,

pub fn route<Callback, Verifier, Params, Output, G>( self, name: impl ToName, verifier: Verifier, func: Callback, ) -> Self

where Callback: IntoInterestCallbackFunction<Params, Context> + Send + Sync + 'static + Fn(AppHandler, Interest<Params>, Context) -> G, G: Future<Output = Option<Data<Output>>> + Send + 'static, Verifier: InterestVerifier + Send + Sync + 'static, Params: TlvDecode + Send + 'static, Output: TlvEncode + 'static,

Registers func to handle Interests whose name has name as a prefix, gated by verifier. Routes are stored in Name order and matched in reverse, so where more than one registered prefix matches an incoming Interest, the route that sorts last is tried first (see the dispatch loop this feeds into, in App::start).

pub fn on_start<F>(self, on_start: F) -> Self

where F: OnStartFn<Context> + 'static,

Registers on_start to run once routes are registered with NFD and the app is ready to serve. This is the usual place to kick off consumer-side work, since it’s the first point at which AppHandler is available.

pub fn mtu(self, mtu: usize) -> Self

Sets the maximum packet size in bytes before NDNLPv2 fragmentation kicks in on send (default 8800, matching NDN’s usual default MTU).

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

Connects to NFD, registers all configured routes, runs on_start, and then serves until AppHandler::shutdown is called or an unrecoverable connection error occurs.