web udp

Web-UDP

Web-UDP es una biblioteca utilizada para establecer canales de datos poco confiables en entornos de nodo/navegador. El objetivo clave de este proyecto para proporcionar una API pequeña y estable que cualquiera puede usar para trabajar con datos en tiempo real en la web.

Actualmente, la biblioteca se implementa como una abstracción además de RTCDACHAnels desordenados y poco confiables. Dado que WEBRTC es una dependencia, se incluye un servidor de señalización basado en WebSocket con el paquete para facilitar las conexiones entre los clientes. Las conexiones de cliente/servidor están disponibles con la ayuda del paquete 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 > 

Instalación

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

Ejemplos

Cliente/servidor

A continuación se muestra un ejemplo simple de un servidor 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 )

Metadatos

La opción metadata en Client.connect se utiliza para enviar datos de apretón de manos arbitrarios inmediatamente después de establecer una conexión. Cuando se establece una nueva conexión, el cliente remoto puede acceder a estos datos en la propiedad metadata del objeto de conexión sin tener que suscribirse a los mensajes del cliente remoto. Los metadatos de Handshake se transmiten a través de un RTCDataChannel seguro, por lo que es un buen candidato para datos confidenciales como contraseñas.

En el siguiente ejemplo, un servidor maneja la autenticación antes de suscribirse a los mensajes del cliente:

 // 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 también admite la comunicación entre pares. El siguiente ejemplo demuestra dos clientes conectados en la misma pestaña del navegador:

 <!-- 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 ) 

Fiabilidad

Client.connect Opcionalmente toma las opciones rtcdatachannel maxPacketLifeTime y maxRetransmits . Estas opciones se pueden usar para habilitar un canal de datos no ordenado y confiable.

Problemas conocidos

Las redes web se utilizan como transporte de señalización. Este socket se mantiene abierto después de que se establece Datachannel para reenviar su evento cercano (por ejemplo, cuando una pestaña del navegador está cerrada) para terminar las conexiones web-udp colgantes. Se envía periódicamente una señal Keepalive para mantener el enchufe abierto en el caso de los hosts con tiempos de espera de conexión. El período en que se envía la señal Keepalive se puede configurar a través de la opción keepAlivePeriod del servidor.

Licencia

Copyright 2023 Eric McDaniel

El permiso se otorga, de forma gratuita, a cualquier persona que obtenga una copia de este software y archivos de documentación asociados (el "software"), para tratar en el software sin restricción, incluidos los derechos de los derechos de usar, copiar, modificar, fusionar, publicar, distribuir, sublicense y/o vender copias del software, y para permitir que las personas a quienes se les proporciona el software para hacer, sujeto a las siguientes condiciones: las siguientes condiciones: las siguientes condiciones: las siguientes condiciones:

El aviso de derechos de autor anterior y este aviso de permiso se incluirán en todas las copias o porciones sustanciales del software.

El software se proporciona "tal cual", sin garantía de ningún tipo, expresa o implícita, incluidas, entre otros, las garantías de comerciabilidad, idoneidad para un propósito particular y no infracción. En ningún caso los autores o titulares de derechos de autor serán responsables de cualquier reclamo, daños u otra responsabilidad, ya sea en una acción de contrato, agravio o de otra manera, que surge, de o en relación con el software o el uso u otros tratos en el software.