smoke
1.0.0
Ejecute servidores web en navegadores web a través de WebRTC
Smoke permite a los navegadores ejecutar microservidores web a través de WebRTC
import { Network } from '@sinclair/smoke'
// ------------------------------------------------------------------
//
// Create a Virtual Network
//
// ------------------------------------------------------------------
const { Http } = new Network ( )
// ------------------------------------------------------------------
//
// Create a Http Listener on a Virtual Port
//
// ------------------------------------------------------------------
Http . listen ( { port : 5000 } , request => new Response ( 'hello webrtc' ) )
// ------------------------------------------------------------------
//
// Fetch data over WebRTC
//
// ------------------------------------------------------------------
const text = Http . fetch ( 'http://localhost:5000' ) . then ( r => r . text ( ) ) $ npm install @sinclair/smokeSmoke es un marco de almacenamiento y redes de navegador experimental que proporciona emulación Http, Tcp y WebSocket a través de WebRTC y almacenamiento de archivos grandes a través de IndexedDB. Está construido como base para desarrollar servicios web peer to peer en el navegador, siendo cada navegador accesible a través de una red virtual controlada por una aplicación.
Smoke transforma WebRTC en interfaces compatibles con WinterCG, lo que permite que las aplicaciones de servidor web tradicionales sean portátiles entre entornos de servidor y navegador. Está desarrollado para soportar arquitecturas de software alternativas donde los servicios centrados en el usuario pueden alejarse de la nube y ejecutarse de igual a igual en el navegador.
Licencia MIT
Las API de red de Smoke se proporcionan mediante objetos de red. Un objeto de red representa una conexión activa a un concentrador de señalización compartido y expone la funcionalidad Http, Net y Media utilizada para comunicarse con otros objetos de red conectados al mismo concentrador.
import { Network , Hubs } from '@sinclair/smoke'
const { Http , Net , Media , Hub } = new Network ( { hub : new Hubs . Private ( ) } )
const address = await Hub . address ( ) // The address of this Network object.Un centro privado es una retransmisión en memoria que reenvía mensajes WebRTC ICE a través de la API BroadcastChannel del navegador. Un centro privado solo puede transmitir mensajes a la página y otras pestañas que se ejecutan dentro del mismo proceso del navegador. Debido a que los centros privados no pueden facilitar las conexiones realizadas fuera de la página actual, se consideran privados. Este Hub es el predeterminado.
import { Network , Hubs } from '@sinclair/smoke'
const { Http } = new Network ( { hub : new Hubs . Private ( ) } )Actualmente está pendiente la implementación de este hub.
import { Network , Hubs } from '@sinclair/smoke'
const { Http } = new Network ( { hub : new Hubs . Public ( 'ws://server/hub' ) } ) La API Http admite escucha y recuperación Http a través de WebRTC. También proporciona emulación de WebSocket.
const { Http } = new Network ( )Utilice la función de escucha para recibir solicitudes Http de pares remotos.
Http . listen ( { port : 5000 } , request => new Response ( 'hello' ) )Utilice la función de recuperación para realizar una solicitud Http a pares remotos.
const response = await Http . fetch ( 'http://localhost:5000' )
const message = await response . text ( )Utilice la función de actualización para convertir una solicitud Http en un WebSocket
Http . listen ( { port : 5000 } , request => Http . upgrade ( request , ( socket ) => socket . send ( 'hello' ) ) )Utilice la función de conexión para conectarse a un servidor WebSocket remoto.
const socket = await Http . connect ( 'ws://localhost:5000' )
socket . on ( 'message' , ( event ) => console . log ( event . data ) )
socket . on ( 'error' , ( event ) => console . log ( event ) )
socket . on ( 'close' , ( event ) => console . log ( event ) ) La API Net proporciona emulación Tcp a través de RTCDataChannel
const { Net } = new Network ( )Utilice la función de escucha para aceptar un socket entrante.
Net . listen ( { port : 5000 } , async socket => {
const data = await socket . read ( )
await socket . write ( data )
await socket . close ( )
} )Utilice la función de conexión para establecer una conexión de red con un oyente remoto.
const socket = await Net . connect ( { hostname : 'localhost' , port : 5000 } )
await socket . write ( new Uint8Array ( 1000 ) )
const data = await socket . read ( ) // Uint8Array()
const end = await socket . read ( ) // null Media API proporciona funcionalidad para enviar y recibir objetos MediaStream a través de WebRTC.
const { Media } = new Network ( )Utilice la función de escucha para escuchar los objetos MediaStream entrantes
Media . listen ( { port : 6000 } , ( receiver ) => {
const video = document . createElement ( 'video' )
video . srcObject = receiver . mediastream
video . play ( )
document . body . appendChild ( video )
receiver . on ( 'close' , ( ) => document . removeChild ( video ) )
} )Utilice la función de envío para enviar un MediaStream a un oyente
const sender = await Media . send ( { hostname : 'localhost' , port : 6000 } , new MediaStream ( [ ... ] ) )
sender . close ( ) // stop sending live mediaUtilice la función de audio para crear un AudioSource que se pueda transmitir.
const audio = Media . audio ( { src : './audio.mp3' } )
const sender = Media . send ( { hostname : 'localhost' , port : 6000 } , audio . mediastream )Utilice la función de vídeo para crear un VideoSource que se pueda transmitir.
const video = Media . video ( { src : './video.mp4' } )
const sender = Media . send ( { hostname : 'localhost' , port : 6000 } , video . mediastream )Utilice la función de patrón para generar un patrón de prueba de MediaStream. Esta función puede resultar útil para probar la transmisión de medios en vivo sin cámaras web u otras fuentes de medios.
const pattern = Media . pattern ( )
const sender = Media . send ( { port : 5000 } , pattern . mediastream ) Smoke proporciona un sistema de archivos jerárquico capaz de almacenar archivos grandes dentro del navegador. El sistema de archivos está respaldado por IndexedDB y admite lectura y escritura en streaming, enumeración de directorios, copiar, mover, renombrar, así como eventos de visualización de archivos y directorios. Está diseñado para actuar como un almacén de archivos estático para servicios de red, pero puede usarse como un sistema de archivos de propósito general para aplicaciones que necesitan almacenar archivos grandes en el navegador.
Utilice la función de apertura para abrir un sistema de archivos con el nombre de base de datos proporcionado. Si la base de datos no existe se crea.
import { FileSystem } from '@sinclair/smoke'
const Fs = await FileSystem . open ( '<database-name>' )Utilice la función estadística para devolver información sobre un archivo o directorio.
const stat = await Fs . write ( '/path/file.txt' )Utilice la función existe para comprobar que existe una ruta.
const exists = await Fs . exists ( '/path/file.txt' )Utilice la función mkdir para crear un directorio.
await Fs . mkdir ( '/media/videos' )Utilice la función readdir para devolver objetos de estadísticas para la ruta del directorio dada.
const stats = await Fs . readdir ( '/media/videos' )Utilice la función blob para devolver un objeto Blob a una ruta de archivo.
const blob = await Fs . readdir ( '/video.mp4' )
const url = URL . createObjectUrl ( blob )Utilice las funciones write y writeText para escribir el contenido del archivo.
await Fs . write ( '/path/file.dat' , new Uint8Array ( [ 1 , 2 , 3 , 4 ] ) )
await Fs . writeText ( '/path/file.txt' , 'hello world' )Utilice las funciones leer y leerTexto para leer el contenido de un archivo.
const buffer = await fs . read ( '/path/file.dat' )
const content = await Fs . readText ( '/path/file.txt' )Utilice la función de eliminación para eliminar un archivo o directorio.
await Fs . delete ( '/path/file.txt' )Utilice la función de cambio de nombre para cambiar el nombre de un archivo o directorio.
await Fs . writeText ( '/path/fileA.txt' , '...' )
await Fs . rename ( '/path/fileA.txt' , 'fileB.txt' )Utilice la función de copia para copiar un archivo o directorio en un directorio de destino.
await Fs . writeText ( '/path/fileA.txt' , '...' )
await Fs . copy ( '/path/fileA.txt' , '/backup' )Utilice la función de mover para mover un archivo o directorio a un directorio de destino.
await Fs . writeText ( '/path/fileA.txt' , '...' )
await Fs . move ( '/path/fileA.txt' , '/backup' )Utilice la función de vigilancia para observar eventos de archivos y directorios.
Fs . watch ( '/dir' , event => console . log ( event ) ) Smoke está abierto a la contribución de la comunidad. Asegúrese de enviar un problema abierto antes de enviar su solicitud de extracción. El proyecto Smoke prefiere la discusión comunitaria abierta antes de aceptar nuevas funciones.
