Come codificare i flussi duplex bidirezionali in NodeJS

Question

Nelle ultime versioni di NodeJS (v0.10.X al momento della scrittura), l'API di Streams ha subito una nuova riprogettazione e vorrei iniziare a utilizzarla ora.

Desidero avvolgere sia l'input sia l'output di un socket con un oggetto che implementa un protocollo.

La cosiddetta interfaccia Duplex, sembra essere solo un flusso leggibile e scrivibile (come una presa).

Non è chiaro se i duplex devono essere come A o B o se non è importante.

+---+  +---+ 
-->| A |-->  | |--> 
    +---+  | B | 
       | |<-- 
       +---+ 

Qual è la struttura di codice/interfaccia corretta per un oggetto che ha due scrivibili e due leggibili?

+--------+ +----------+ +---- 
|  r|-->|w  r|-->|w  
| socket | | protocol | | rest of app 
|  w|<--|r  w|<--|r  
+--------+ +----------+ +---- 

Il problema con il diagramma sopra è che l'oggetto necessita di due distinte read metodi e due write metodi.

In cima alla mia testa, potevo fare in modo che il protocollo producesse gli oggetti duplex "di sinistra" e "di destra" o gli oggetti duplex "dentro" e "fuori" (per suddividerlo in un modo diverso).

Sono uno di questi il ​​modo preferito oppure esiste una soluzione migliore?

Answer 1

  |  app  | 
      +---------------+ 
      ^  | 
       |  V  
      +-----+ +-----+ 
      |  | |  | 
+----------|  |-|  |-+ 
| protocol | .up | |.down| | 
+----------|  |-|  |-+ 
      |  | |  | 
      +-----+ +-----+ 
      ^  | 
       |  V 
      +---------------+ 
      |  socket | 

La mia soluzione era quella di fare una classe protocollo, che ha creato un up Transform e giù Transform.

Il costruttore del protocollo passa un riferimento (a se stesso) durante la costruzione delle trasformazioni Up e Down. Il metodo _transform in ciascuna delle trasformazioni su e giù può quindi chiamare push su se stesso, sull'altro Transform o entrambi come richiesto. Lo stato comune può essere mantenuto nell'oggetto Protocol.

Answer 2

Un flusso duplex è come il diagramma B, almeno per l'utente. Una visione più completa di un flusso consisterebbe nell'includere il produttore (fonte) con il consumatore (utente). Vedi il mio precedente answer. Cerca di non pensare sia alla lettura/scrittura dal punto di vista del consumatore.

Quello che state facendo è la costruzione di uno strato sottile sopra la presa per il protocollo, in modo che il disegno è corretto:

      -------+  +----------+  +------ 
           r|---->|   r|---->|  
         socket |  | protocol |  | rest of app 
           w|<----|   w|<----|  
         -------+  +----------+  +------ 

È possibile utilizzare duplex o trasformare per la parte di protocollo.

    +---------+--------+---------+  +------------------+ 
       | _write->|  |   |r  | Transform -> |r 
       |-----------Duplex-----------|  +------------------+  
       |   |  | <-_read |w  | <- Transform |w 
       +---------+--------+---------+  +------------------+ 

processo essendo l'elaborazione relativa al protocollo sui dati in entrata/in uscita utilizzando _read, _write interno. Oppure puoi trasformare flussi. Dovresti collegare il protocollo al socket e al socket.