web udp

web-udp

Web-UDP est une bibliothèque utilisée pour établir des canaux de données peu fiables dans les environnements Node / navigateur. L'objectif clé de ce projet de fournir une petite API stable que n'importe qui peut utiliser pour travailler avec des données en temps réel sur le Web.

La bibliothèque est actuellement implémentée comme une abstraction en plus des RTCDatachannels non ordonnés et peu fiables. Étant donné que WeBrTC est une dépendance, un serveur de signalisation basé sur WebSocket est inclus avec le package pour faciliter les connexions entre les clients. Les connexions client / serveur sont disponibles à l'aide du package WRTC.

API

 Signal < T > . subscribe ( subscriber : T => any )
Signal < T > . unsubscribe ( subscriber : T => any )

Client ( options ?: { url ?: string } )
Client . connect ( to ?: string = "__MASTER__" , options ?: {
  binaryType ?: "arraybuffer" | "blob" ,
  maxRetransmits ?: number ,
  maxPacketLifeTime ?: number ,
  metadata ?: any ,
  UNSAFE_ordered ?: boolean
} ) : Promise < Connection >
Client . route ( ) : Promise < string >
Client . connections : Signal < Connection >

Connection . send ( message : any ) : void
Connection . close ( ) : void
Connection . closed : Signal
Connection . errors : Signal < { err : string } >
Connection . messages : Signal < any >
Connection . metadata : any

// Node
Server ( { server : http . Server , keepAlivePeriod ?: number = 30000 } )
Server . client ( ) : Client
Server . connections : Signal < Connection > 

Installation

npm i @web-udp/client
npm i @web-udp/server

Exemples

Client / serveur

Vous trouverez ci-dessous un exemple simple d'un serveur de ping:

 // client.js

import { Client } from "@web-udp/client"

async function main ( ) {
  const udp = new Client ( )
  const connection = await udp . connect ( )

  connection . send ( "ping" )
  connection . messages . subscribe ( console . log )
} 

 // server.js

const server = require ( "http" ) . createServer ( )
const { Server } = require ( "@web-udp/server" )

const udp = new Server ( { server } )

udp . connections . subscribe ( connection => {
  connection . messages . subscribe ( message => {
    if ( message === "ping" ) {
      connection . send ( "pong" )
    }
  } )

  connection . closed . subscribe ( ( ) => console . log ( "A connection closed." ) )

  connection . errors . subscribe ( err => console . log ( err ) )
} )

server . listen ( 8000 )

Métadonnées

L'option metadata dans Client.connect est utilisée pour envoyer des données de poignée de main arbitraires immédiatement après l'établissement d'une connexion. Lorsqu'une nouvelle connexion est établie, le client distant peut accéder à ces données sur la propriété metadata de l'objet Connexion sans avoir à s'abonner aux messages du client distant. Les métadonnées de poignée de main sont transmises sur un RTCDataChannel sécurisé, ce qui en fait un bon candidat pour des données sensibles comme les mots de passe.

Dans l'exemple ci-dessous, un serveur gère l'authentification avant de s'abonner aux messages du client:

 // client.js

const connection = await udp . connect ( {
  metadata : {
    credentials : {
      username : "foo" ,
      password : "bar" ,
    } ,
  } ,
} ) 

 // server.js

udp . connections . subscribe ( connection => {
  let user

  try {
    user = await fakeAuth . login ( connection . metadata . credentials )
  } catch ( err ) {
    // Authentication failed, close connection immediately.
    connection . send ( fakeProtocol . loginFailure ( ) )
    connection . close ( )
    return
  }
  // The user authenticated successfully.
  connection . send ( fakeProtocol . loginSuccess ( user ) )
  connection . messages . subscribe ( ... )
} )

P2P

web-udp prend également en charge la communication entre pairs. L'exemple ci-dessous démontre deux clients connectés dans le même onglet de navigateur:

 <!-- index.html -->

< script src =" /node_modules/@web-udp/client/dist/index.js " > </ script >
< script src =" client.js " > </ script > 

 // client.js

async function main ( ) {
  const left = new Udp . Client ( )
  const right = new Udp . Client ( )
  const route = await left . route ( )
  const connection = await right . connect ( route )

  left . connections . subscribe ( connection =>
    connection . messages . subscribe ( console . log ) ,
  )

  connection . send ( "HELLO" )
} 

 // server.js

const server = require ( "http" ) . createServer ( )
const { Server } = require ( "@web-udp/server" )

Server ( { server } )

server . listen ( 8000 ) 

Fiabilité

Client.connect prend éventuellement les options RTCDatachannel maxPacketLifeTime et maxRetransmits . Ces options peuvent être utilisées pour activer un canal de données non ordonné et fiable.

Problèmes connus

WebSockets est utilisé comme transport de signalisation. Cette prise est maintenue ouverte après la création du canal de données pour transmettre son événement proche (par exemple, lorsqu'un onglet de navigateur est fermé) afin de terminer les connexions web-udp suspendues. Un signal Keepalive est envoyé périodiquement pour garder la prise ouverte dans le cas des hôtes avec des délais d'attente de connexion. La période à laquelle le signal Keepalive est envoyée peut être configurée via l'option keepAlivePeriod du serveur.

Licence

Copyright 2023 Eric McDaniel

L'autorisation est accordée gratuitement à toute personne qui obtient une copie de ce logiciel et des fichiers de documentation associés (le "logiciel"), pour traiter le logiciel sans restriction, y compris sans limiter les droits d'utilisation, de copie, de modification, de fusion, de publication, de distribution, de sublince et / ou de vendre des copies des conditions suivantes.

L'avis de droit d'auteur ci-dessus et le présent avis d'autorisation sont inclus dans toutes les copies ou des parties substantielles du logiciel.

Le logiciel est fourni "tel quel", sans garantie d'aucune sorte, express ou implicite, y compris, mais sans s'y limiter, les garanties de qualité marchande, d'adéquation à un usage particulier et de non-contrefaçon. En aucun cas, les auteurs ou les détenteurs de droits d'auteur ne seront pas responsables de toute réclamation, dommage ou autre responsabilité, que ce soit dans une action de contrat, de délit ou autre, découlant de, hors du logiciel ou de l'utilisation ou d'autres relations dans le logiciel.