peerix - v0.8.0
    Preparing search index...

    Class CentrifugeDriver

    Centrifuge-based signaling driver.

    This driver uses Centrifugo as the underlying messaging system, allowing signaling messages to be exchanged through a Centrifuge-based server. Subscribing waits until the subscription is ready and fails if that takes longer than 10 seconds. A subscription the server ends is retried with exponential backoff, and rooms announce themselves again once it is restored.

    This driver requires the centrifuge module in the browser.

    import { Centrifuge } from "centrifuge";

    // connect to a Centrifuge server
    const centrifuge = new Centrifuge("ws://localhost:8000/connection/websocket");
    centrifuge.connect();

    // create a new driver instance
    const driver = new CentrifugeDriver({ centrifuge });

    Running a Centrifugo server locally for testing:

    podman run --rm --ulimit nofile=65536:65536 -p 8000:8000 \
    -e CENTRIFUGO_CLIENT_ALLOWED_ORIGINS='*' \
    -e CENTRIFUGO_CLIENT_INSECURE=true \
    docker.io/centrifugo/centrifugo centrifugo

    Hierarchy (View Summary)

    Index
    • Creates a new instance of the driver.

      Parameters

      • options: { centrifuge: CentrifugeClient; prefix?: string }

        Configuration options for the driver.

        • centrifuge: CentrifugeClient

          The Centrifuge client instance.

        • Optionalprefix?: string

          Optional prefix for Centrifuge channels.

      Returns CentrifugeDriver

      If centrifuge is not a valid Centrifuge client.

    • get active(): boolean

      Indicates whether the driver is currently active. Subclasses must keep it in sync with their connection: signaling messages are only published while the driver is active, and joined rooms announce themselves again when it becomes active. A namespace that fails on its own leaves the driver active, and emitting active once it is subscribed again makes rooms announce themselves to the peers they missed.

      Returns boolean

    • set active(value: boolean): void

      Sets the active state of the driver and emits corresponding events.

      Parameters

      • value: boolean

      Returns void

    • Destroys the driver instance, cleaning up any resources. Emits inactive if the driver was active, then removes all event handlers.

      Returns void

    • Registers an event handler for the specified internal event.

      Type Parameters

      Parameters

      • event: K

        The event name.

      • handler: (...args: DriverEvents[K]) => void

        The event handler function.

      • Optionaloptions: { signal?: AbortSignal }

        Listener options.

        • Optionalsignal?: AbortSignal

          Removes the handler when aborted.

      Returns () => void

      A function that removes the handler.

    • Publishes a signaling message to the specified namespace.

      Parameters

      • namespace: string

        The namespace to publish the message to.

      • data: number[]

        The message data to publish.

      Returns Promise<void>

      Nothing directly; resolves once the message is delivered (async drivers may return a promise).

    • Subscribes to signaling messages for the specified namespace.

      Parameters

      • namespace: string

        The namespace to subscribe to.

      • handler: (data: number[]) => void

        The handler function to call when a message is received.

      Returns Promise<void>

      Nothing directly; resolves once the subscription is established (async drivers may return a promise).

    • Unsubscribes from signaling messages for the specified namespace.

      Parameters

      • namespace: string

        The namespace to unsubscribe from.

      • handler: (data: number[]) => void

        The handler function to remove.

      Returns Promise<void>

      Nothing directly; resolves once the unsubscription is confirmed (async drivers may return a promise).