Options
All
  • Public
  • Public/Protected
  • All
Menu

@ndn/fw

This package is part of NDNts, Named Data Networking libraries for the modern web.

This package implements the forwarding plane, the central piece of NDN stack. It exports a Forwarder type that represents the forwarding plane, and a FwFace type that represents a face attached to the forwarding plane.

Concepts

You may be wondering: why there's a forwarding plane in my application? The main purpose is to demultiplex incoming packets. Suppose a producer application can serve multiple kinds of data, the forwarding plane can dispatch incoming Interests of each kind of data to the correct Interest handler function in the application, so that the application does not perform this dispatching itself.

This leads to our definition of the face: a face is a duplex stream of packets. It could be a connection to another network node or standalone forwarder, as implemented in @ndn/l3face package. It could also be a part of application logic, as implemented in @ndn/endpoint package. Creating a FwFace for application logic is relatively cheap: if you need to receive different kinds of packets in separate callback functions, you should create one face per callback function, instead of sharing the same face and attempting to dispatch packets yourself.

A packet transmitted or received on an FwFace is typically an Interest or a Data. From application logic, it is possible to associate arbitrary metadata, called a token, on an outgoing Interest, and receive them back on the corresponding Data. You can also send a CancelInterest command to cancel a pending Interest, and receive a RejectInterest notice when the Interest is canceled or has expired. Obviously, these tokens and commands are not encodable, so they are only available for communication between application logic and the forwarding plane, but cannot appear beyond the NDNts application.

Forwarding Behavior

It's sad but NDN does not have a formal forwarding behavior specification. This package implements a simplified version of NDN forwarding behavior specified in NDN-LAN dissertation chapter 3. The main differences from a full forwarder include:

  • Forwarding strategy is dumb.
  • No Interest aggregation.
  • No Content Store (CS). If your application needs data packet caching, use @ndn/repo package.
  • No forwarding hint processing.
  • No Nack generation or processing.

These are subject to change.

Index

References

CancelInterest

Re-exports CancelInterest

Forwarder

Re-exports Forwarder

FwFace

Re-exports FwFace

FwPacket

Re-exports FwPacket

FwTracer

Renames and re-exports Tracer

ReadvertiseDestination

Re-exports ReadvertiseDestination

RejectInterest

Re-exports RejectInterest

TapFace

Re-exports TapFace

Type aliases

L3Pkt

L3Pkt: Interest | Data | Nack

Variables

Const STOP

STOP: unique symbol = Symbol("FaceImpl.Stop")

Const getNow

getNow: Elapsor = hirestime()

Const logger

logger: Logger = log.getLogger("@ndn/fw")

Functions

computeAnnouncement

interestToString

  • interestToString(__namedParameters: { canBePrefix: boolean; mustBeFresh: boolean; name: Name }): string
  • Parameters

    • __namedParameters: { canBePrefix: boolean; mustBeFresh: boolean; name: Name }
      • canBePrefix: boolean
      • mustBeFresh: boolean
      • name: Name

    Returns string

Legend

  • Namespace
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Interface
  • Interface with type parameter
  • Class
  • Class with type parameter
  • Enumeration

Generated using TypeDoc