werift 0.14.4-debug0 → 0.15.0-alpha.0

package/src/sdp.ts

@@ -1,6 +1,6 @@
 import { randomBytes } from "crypto";
 import { Uint64BE } from "int64-buffer";
-import { range } from "lodash";
+import range from "lodash/range";
 import { isIPv4 } from "net";
 
 import {

package/src/transport/dtls.ts

@@ -2,6 +2,7 @@ import { Certificate, PrivateKey } from "@fidm/x509";
 import debug from "debug";
 import Event from "rx.mini";
 import { setTimeout } from "timers/promises";
+import { v4 } from "uuid";
 
 import {
   DtlsClient,
@@ -34,6 +35,7 @@ import { RTCIceTransport } from "./ice";
 const log = debug("werift:packages/webrtc/src/transport/dtls.ts");
 
 export class RTCDtlsTransport {
+  id = v4();
   state: DtlsState = "new";
   role: DtlsRole = "auto";
   srtpStarted = false;
@@ -46,7 +48,7 @@ export class RTCDtlsTransport {
 
   readonly onStateChange = new Event<[DtlsState]>();
 
-  private localCertificate?: RTCCertificate = this.certificates[0];
+  localCertificate?: RTCCertificate = this.certificates[0];
   private remoteParameters?: RTCDtlsParameters;
 
   constructor(
@@ -79,6 +81,7 @@ export class RTCDtlsTransport {
         signatureHash
       );
     }
+    return this.localCertificate;
   }
 
   setRemoteParams(remoteParameters: RTCDtlsParameters) {

package/src/transport/sctp.ts

@@ -24,51 +24,71 @@ import { RTCDtlsTransport } from "./dtls";
 const log = debug("werift/webrtc/transport/sctp");
 
 export class RTCSctpTransport {
+  dtlsTransport!: RTCDtlsTransport;
+  sctp!: SCTP;
+
   readonly onDataChannel = new Event<[RTCDataChannel]>();
   readonly uuid = uuid.v4();
-  readonly sctp = new SCTP(new BridgeDtls(this.dtlsTransport), this.port);
+
   mid?: string;
   bundled = false;
   dataChannels: { [key: number]: RTCDataChannel } = {};
 
   private dataChannelQueue: [RTCDataChannel, number, Buffer][] = [];
   private dataChannelId?: number;
+  private eventDisposer: (() => void)[] = [];
+
+  constructor(public port = 5000) {}
+
+  setDtlsTransport(dtlsTransport: RTCDtlsTransport) {
+    if (this.dtlsTransport && this.dtlsTransport.id === dtlsTransport.id) {
+      return;
+    }
+
+    this.eventDisposer.forEach((dispose) => dispose());
+
+    this.dtlsTransport = dtlsTransport;
+    this.sctp = new SCTP(new BridgeDtls(this.dtlsTransport), this.port);
+
+    this.eventDisposer = [
+      ...[
+        this.sctp.onReceive.subscribe(this.datachannelReceive),
+        this.sctp.onReconfigStreams.subscribe((ids: number[]) => {
+          ids.forEach((id) => {
+            const dc = this.dataChannels[id];
+            if (!dc) return;
+            // todo fix
+            dc.setReadyState("closing");
+            dc.setReadyState("closed");
+            delete this.dataChannels[id];
+          });
+        }),
+        this.sctp.stateChanged.connected.subscribe(() => {
+          Object.values(this.dataChannels).forEach((channel) => {
+            if (channel.negotiated && channel.readyState !== "open") {
+              channel.setReadyState("open");
+            }
+          });
+          this.dataChannelFlush();
+        }),
+        this.sctp.stateChanged.closed.subscribe(() => {
+          Object.values(this.dataChannels).forEach((dc) => {
+            dc.setReadyState("closed");
+          });
+          this.dataChannels = {};
+        }),
+        this.dtlsTransport.onStateChange.subscribe((state) => {
+          if (state === "closed") {
+            this.sctp.setState(SCTP_STATE.CLOSED);
+          }
+        }),
+      ].map((e) => e.unSubscribe),
+      () => (this.sctp.onSackReceived = async () => {}),
+    ];
 
-  constructor(public dtlsTransport: RTCDtlsTransport, public port = 5000) {
-    this.sctp.onReceive.subscribe(this.datachannelReceive);
-    this.sctp.onReconfigStreams.subscribe((ids: number[]) => {
-      ids.forEach((id) => {
-        const dc = this.dataChannels[id];
-        if (!dc) return;
-        // todo fix
-        dc.setReadyState("closing");
-        dc.setReadyState("closed");
-        delete this.dataChannels[id];
-      });
-    });
-    this.sctp.stateChanged.connected.subscribe(() => {
-      Object.values(this.dataChannels).forEach((channel) => {
-        if (channel.negotiated && channel.readyState !== "open") {
-          channel.setReadyState("open");
-        }
-      });
-      this.dataChannelFlush();
-    });
-    this.sctp.stateChanged.closed.subscribe(() => {
-      Object.values(this.dataChannels).forEach((dc) => {
-        dc.setReadyState("closed");
-      });
-      this.dataChannels = {};
-    });
     this.sctp.onSackReceived = async () => {
       await this.dataChannelFlush();
     };
-
-    this.dtlsTransport.onStateChange.subscribe((state) => {
-      if (state === "closed") {
-        this.sctp.setState(SCTP_STATE.CLOSED);
-      }
-    });
   }
 
   private get isServer() {