@streamr/dht 100.0.0-pretestnet.0 → 100.0.0-pretestnet.3

package/src/connection/{Simulator → simulator}/SimulatorConnection.ts

@@ -4,7 +4,6 @@ import { Message, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Connection } from '../Connection'
 import { Logger } from '@streamr/utils'
 import { protoToString } from '../../helpers/protoToString'
-import { DisconnectionType } from '../../transport/ITransport'
 import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
@@ -12,19 +11,19 @@ const logger = new Logger(module)
 export class SimulatorConnection extends Connection implements IConnection {
 
     private stopped = false
-    public ownPeerDescriptor: PeerDescriptor
+    public localPeerDescriptor: PeerDescriptor
     private targetPeerDescriptor: PeerDescriptor
     private simulator: Simulator
 
     constructor(
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         targetPeerDescriptor: PeerDescriptor,
         connectionType: ConnectionType,
         simulator: Simulator
     ) {
         super(connectionType)
 
-        this.ownPeerDescriptor = ownPeerDescriptor
+        this.localPeerDescriptor = localPeerDescriptor
         this.setPeerDescriptor(targetPeerDescriptor)
         this.targetPeerDescriptor = targetPeerDescriptor
         this.connectionType = connectionType
@@ -46,36 +45,36 @@ export class SimulatorConnection extends Connection implements IConnection {
             this.simulator.send(this, data)
 
         } else {
-            logger.error(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+            logger.error(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                 'tried to send() on a stopped connection')
         }
     }
 
-    public async close(disconnectionType: DisconnectionType): Promise<void> {
-        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close()')
+    public async close(gracefulLeave: boolean): Promise<void> {
+        logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close()')
 
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', '
+            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', '
                 + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close() not stopped')
             this.stopped = true
 
             try {
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() calling simulator.disconnect()')
                 this.simulator.close(this)
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() simulator.disconnect returned')
             } catch (e) {
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     'close aborted' + e)
             } finally {
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' calling this.doDisconnect')
-                this.doDisconnect(disconnectionType)
+                this.doDisconnect(gracefulLeave)
             }
 
         } else {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                 ' close() tried to close a stopped connection')
         }
     }
@@ -87,7 +86,7 @@ export class SimulatorConnection extends Connection implements IConnection {
             this.simulator.connect(this, this.targetPeerDescriptor, (error?: string) => {
                 if (error) {
                     logger.trace(error)
-                    this.doDisconnect('OTHER')
+                    this.doDisconnect(false)
                 } else {
                     this.emit('connected')
                 }
@@ -109,9 +108,9 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public handleIncomingDisconnection(): void {
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' handleIncomingDisconnection()')
+            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ' handleIncomingDisconnection()')
             this.stopped = true
-            this.doDisconnect('OTHER')
+            this.doDisconnect(false)
         } else {
             logger.trace('tried to call handleIncomingDisconnection() a stopped connection')
         }
@@ -119,22 +118,22 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public destroy(): void {
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' destroy()')
+            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ' destroy()')
             this.removeAllListeners()
-            this.close('OTHER').catch((_e) => { })
+            this.close(false).catch((_e) => { })
         } else {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' tried to call destroy() a stopped connection')
+            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ' tried to call destroy() a stopped connection')
         }
     }
 
-    private doDisconnect(disconnectionType: DisconnectionType) {
-        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' doDisconnect()')
+    private doDisconnect(gracefulLeave: boolean) {
+        logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ' doDisconnect()')
         this.stopped = true
 
-        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', '
+        logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', '
             + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' doDisconnect emitting')
 
-        this.emit('disconnected', disconnectionType)
+        this.emit('disconnected', gracefulLeave)
 
     }
 }

package/src/connection/{Simulator → simulator}/SimulatorConnector.ts

@@ -16,16 +16,16 @@ export class SimulatorConnector {
 
     private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
     private stopped = false
-    private ownPeerDescriptor: PeerDescriptor
+    private localPeerDescriptor: PeerDescriptor
     private simulator: Simulator
     private onIncomingConnection: (connection: ManagedConnection) => boolean
 
     constructor(
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         simulator: Simulator,
         onIncomingConnection: (connection: ManagedConnection) => boolean
     ) {
-        this.ownPeerDescriptor = ownPeerDescriptor
+        this.localPeerDescriptor = localPeerDescriptor
         this.simulator = simulator
         this.onIncomingConnection = onIncomingConnection
     }
@@ -38,9 +38,9 @@ export class SimulatorConnector {
             return existingConnection
         }
 
-        const connection = new SimulatorConnection(this.ownPeerDescriptor, targetPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, this.simulator)
+        const connection = new SimulatorConnection(this.localPeerDescriptor, targetPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, this.simulator)
 
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, connection, undefined)
+        const managedConnection = new ManagedConnection(this.localPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, connection, undefined)
         managedConnection.setPeerDescriptor(targetPeerDescriptor)
 
         this.connectingConnections.set(peerKey, managedConnection)
@@ -57,27 +57,27 @@ export class SimulatorConnector {
     }
 
     public getPeerDescriptor(): PeerDescriptor {
-        return this.ownPeerDescriptor
+        return this.localPeerDescriptor
     }
 
     public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
-        logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' incoming connection, stopped: ' + this.stopped)
+        logger.trace(keyFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming connection, stopped: ' + this.stopped)
         if (this.stopped) {
             return
         }
-        const connection = new SimulatorConnection(this.ownPeerDescriptor,
-            sourceConnection.ownPeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator)
+        const connection = new SimulatorConnection(this.localPeerDescriptor,
+            sourceConnection.localPeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator)
 
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor, ConnectionType.SIMULATOR_SERVER, undefined, connection)
+        const managedConnection = new ManagedConnection(this.localPeerDescriptor, ConnectionType.SIMULATOR_SERVER, undefined, connection)
 
         logger.trace('connected')
 
         managedConnection.once('handshakeRequest', () => {
-            logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' incoming handshake request')
+            logger.trace(keyFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming handshake request')
             logger.trace('incoming handshake request')
 
             if (this.onIncomingConnection(managedConnection)) {
-                logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' calling acceptHandshake')
+                logger.trace(keyFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' calling acceptHandshake')
                 managedConnection.acceptHandshake()
             } else {
                 managedConnection.rejectHandshake('Duplicate connection')
@@ -92,7 +92,7 @@ export class SimulatorConnector {
         this.stopped = true
         const conns = Array.from(this.connectingConnections.values())
         await Promise.allSettled(conns.map((conn) =>
-            conn.close('OTHER')
+            conn.close(false)
         ))
     }
 }

package/src/connection/{Simulator → simulator}/SimulatorTransport.ts

@@ -5,9 +5,9 @@ import { Simulator } from './Simulator'
 import { SimulatorConnectorFacade } from '../ConnectorFacade'
 
 export class SimulatorTransport extends ConnectionManager {
-    constructor(ownPeerDescriptor: PeerDescriptor, simulator: Simulator) {
+    constructor(localPeerDescriptor: PeerDescriptor, simulator: Simulator) {
         super({
-            createConnectorFacade: () => new SimulatorConnectorFacade(ownPeerDescriptor, simulator),
+            createConnectorFacade: () => new SimulatorConnectorFacade(localPeerDescriptor, simulator),
             metricsContext: new MetricsContext()
         })
     }

package/src/connection/{WebRTC/BrowserWebRtcConnection.ts → webrtc/BrowserWebrtcConnection.ts}

@@ -1,25 +1,24 @@
 import EventEmitter from 'eventemitter3'
-import { WebRtcConnectionEvents, IWebRtcConnection, RtcDescription } from './IWebRtcConnection'
+import { WebrtcConnectionEvents, IWebrtcConnection, RtcDescription } from './IWebrtcConnection'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
 import { Logger } from '@streamr/utils'
-import { DisconnectionType } from '../../transport/ITransport'
-import { IceServer } from './WebRtcConnectorRpcLocal'
+import { IceServer } from './WebrtcConnectorRpcLocal'
 
 const logger = new Logger(module)
 
-export const WEB_RTC_CLEANUP = new class {
+export const WEBRTC_CLEANUP = new class {
     // eslint-disable-next-line class-methods-use-this
     cleanUp(): void {
     }
 }
 
-type Events = WebRtcConnectionEvents & ConnectionEvents
+type Events = WebrtcConnectionEvents & ConnectionEvents
 
 interface Params {
     iceServers?: IceServer[]
 }
 
-export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRtcConnection, IConnection {
+export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrtcConnection, IConnection {
 
     public readonly connectionId: ConnectionID
     public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
@@ -39,7 +38,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRt
     constructor(params: Params) {
         super()
         this.connectionId = new ConnectionID()
-        this.iceServers = params.iceServers || []
+        this.iceServers = params.iceServers ?? []
     }
 
     public start(isOffering: boolean): void {
@@ -135,17 +134,17 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRt
 
     // IConnection implementation
     
-    public async close(disconnectionType: DisconnectionType, reason?: string): Promise<void> {
-        this.doClose(disconnectionType, reason)
+    public async close(gracefulLeave: boolean, reason?: string): Promise<void> {
+        this.doClose(gracefulLeave, reason)
     }
     
-    private doClose(disconnectionType: DisconnectionType, reason?: string): void {
+    private doClose(gracefulLeave: boolean, reason?: string): void {
         if (!this.closed) {
             this.closed = true
             this.lastState = 'closed'
 
             this.stopListening()
-            this.emit('disconnected', disconnectionType, undefined, reason)
+            this.emit('disconnected', gracefulLeave, undefined, reason)
             
             this.removeAllListeners()
 
@@ -173,7 +172,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRt
 
     public destroy(): void {
         this.removeAllListeners()
-        this.doClose('OTHER')
+        this.doClose(false)
     }
 
     public send(data: Uint8Array): void {
@@ -192,7 +191,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRt
 
         dataChannel.onclose = () => {
             logger.trace('dc.onClosed')
-            this.doClose('OTHER')
+            this.doClose(false)
         }
 
         dataChannel.onerror = (err) => {

package/src/connection/{WebRTC/IWebRtcConnection.ts → webrtc/IWebrtcConnection.ts}

@@ -1,4 +1,4 @@
-export interface WebRtcConnectionEvents {
+export interface WebrtcConnectionEvents {
     localDescription: (description: string, type: string) => void
     localCandidate: (candidate: string, mid: string) => void
 }
@@ -8,7 +8,7 @@ export enum RtcDescription {
     ANSWER = 'answer'
 }
 
-export interface IWebRtcConnection {
+export interface IWebrtcConnection {
     start(isOffering: boolean): void
 
     on(event: 'localDescription', listener: (description: string, type: string) => void): this

package/src/connection/{WebRTC/NodeWebRtcConnection.ts → webrtc/NodeWebrtcConnection.ts}

@@ -1,19 +1,18 @@
-import { IWebRtcConnection, WebRtcConnectionEvents } from './IWebRtcConnection'
+import { IWebrtcConnection, WebrtcConnectionEvents } from './IWebrtcConnection'
 import { ConnectionType, IConnection, ConnectionID, ConnectionEvents } from '../IConnection'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import EventEmitter from 'eventemitter3'
 import nodeDatachannel, { DataChannel, DescriptionType, PeerConnection } from 'node-datachannel'
 import { Logger } from '@streamr/utils'
-import { IllegalRTCPeerConnectionState } from '../../helpers/errors'
+import { IllegalRtcPeerConnectionState } from '../../helpers/errors'
 import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { DisconnectionType } from '../../transport/ITransport'
 import { iceServerAsString } from './iceServerAsString'
-import { IceServer } from './WebRtcConnectorRpcLocal'
+import { IceServer } from './WebrtcConnector'
 import { PortRange } from '../ConnectionManager'
 
 const logger = new Logger(module)
 
-export const WEB_RTC_CLEANUP = new class {
+export const WEBRTC_CLEANUP = new class {
     // eslint-disable-next-line class-methods-use-this
     cleanUp(): void {
         nodeDatachannel.cleanup()
@@ -33,7 +32,7 @@ export interface Params {
 // Re-defined accoring to https://github.com/microsoft/TypeScript/blob/main/src/lib/dom.generated.d.ts
 // because importing single dom definitions in not possible
 
-enum RTCPeerConnectionStateEnum {
+enum RtcPeerConnectionStateEnum {
     closed = 'closed',
     connected = 'connected',
     connecting = 'connecting',
@@ -44,16 +43,16 @@ enum RTCPeerConnectionStateEnum {
 
 nodeDatachannel.initLogger('Fatal')
 
-type RTCPeerConnectionState = keyof typeof RTCPeerConnectionStateEnum
+type RtcPeerConnectionState = keyof typeof RtcPeerConnectionStateEnum
 
-type Events = WebRtcConnectionEvents & ConnectionEvents
+type Events = WebrtcConnectionEvents & ConnectionEvents
 
-export class NodeWebRtcConnection extends EventEmitter<Events> implements IConnection, IWebRtcConnection {
+export class NodeWebrtcConnection extends EventEmitter<Events> implements IConnection, IWebrtcConnection {
 
     public connectionId: ConnectionID
     private connection?: PeerConnection
     private dataChannel?: DataChannel
-    private lastState: RTCPeerConnectionState = 'connecting'
+    private lastState: RtcPeerConnectionState = 'connecting'
     private remoteDescriptionSet = false
     private connectingTimeoutRef?: NodeJS.Timeout
 
@@ -93,7 +92,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
 
         this.connectingTimeoutRef = setTimeout(() => {
             logger.trace('connectingTimeout, this.closed === ' + this.closed)
-            this.doClose('OTHER')
+            this.doClose(false)
         }, this.connectingTimeout)
 
         this.connection.onStateChange((state: string) => this.onStateChange(state))
@@ -120,10 +119,10 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
                 this.connection.setRemoteDescription(description, type as DescriptionType)
                 this.remoteDescriptionSet = true
             } catch (err) {
-                logger.warn(`Failed to set remote descriptor for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                logger.debug(`Failed to set remote descriptor for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
             }
         } else {
-            this.doClose('OTHER', `Tried to set description for non-existent connection`)
+            this.doClose(false, `Tried to set description for non-existent connection`)
         }
     }
 
@@ -134,14 +133,14 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
                     logger.trace(`Setting remote candidate for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
                     this.connection.addRemoteCandidate(candidate, mid)
                 } catch (err) {
-                    logger.warn(`Failed to set remote candidate for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
-                    this.doClose('OTHER')
+                    logger.debug(`Failed to set remote candidate for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
                 }
             } else {
-                this.doClose('OTHER', `Tried to set candidate before description`)
+                // TODO: should queue candidates until remote description is set?
+                this.doClose(false, `Tried to set candidate before description`)
             }
         } else {
-            this.doClose('OTHER', `Tried to set candidate for non-existent connection`)
+            this.doClose(false, `Tried to set candidate for non-existent connection`)
         }
     }
 
@@ -150,16 +149,16 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
             try {
                 this.dataChannel!.sendMessageBinary(data as Buffer)
             } catch (err) {
-                logger.warn('Failed to send binary message to ' + keyFromPeerDescriptor(this.remotePeerDescriptor) + err)
+                logger.debug('Failed to send binary message to ' + keyFromPeerDescriptor(this.remotePeerDescriptor) + err)
             }
         }
     }
 
-    public async close(disconnectionType: DisconnectionType, reason?: string): Promise<void> {
-        this.doClose(disconnectionType, reason)
+    public async close(gracefulLeave: boolean, reason?: string): Promise<void> {
+        this.doClose(gracefulLeave, reason)
     }
 
-    private doClose(disconnectionType: DisconnectionType, reason?: string): void {
+    private doClose(gracefulLeave: boolean, reason?: string): void {
         if (!this.closed) {
             logger.trace(
                 `Closing Node WebRTC Connection to ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`
@@ -168,7 +167,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
 
             this.closed = true
             
-            this.emit('disconnected', disconnectionType, undefined, reason)
+            this.emit('disconnected', gracefulLeave, undefined, reason)
             this.removeAllListeners()
             
             if (this.connectingTimeoutRef) {
@@ -180,7 +179,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
                     logger.trace('closing datachannel')
                     this.dataChannel.close()
                 } catch (e) {
-                    logger.warn('dc.close() errored: %s', e)
+                    logger.trace('dc.close() errored: %s', e)
                 }
             }
             
@@ -188,7 +187,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
                 try {
                     this.connection.close()
                 } catch (e) {
-                    logger.warn('conn.close() errored: %s', e)
+                    logger.trace('conn.close() errored: %s', e)
                 }
             }
         }
@@ -196,7 +195,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
 
     public destroy(): void {
         this.removeAllListeners()
-        this.doClose('OTHER')
+        this.doClose(false)
     }
 
     private onDataChannel(dataChannel: DataChannel): void {
@@ -213,7 +212,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
 
         dataChannel.onClosed(() => {
             logger.trace(`dc.closed`)
-            this.doClose('OTHER', 'DataChannel closed')
+            this.doClose(false, 'DataChannel closed')
         })
 
         dataChannel.onError((err) => logger.error('error', { err }))
@@ -239,17 +238,17 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
 
     private onStateChange(state: string): void {
         logger.trace('onStateChange ' + state)
-        if (!Object.keys(RTCPeerConnectionStateEnum).filter((s) => isNaN(+s)).includes(state)) {
-            throw new IllegalRTCPeerConnectionState('NodeWebRtcConnection used an unknown state: ' + state)
+        if (!Object.keys(RtcPeerConnectionStateEnum).filter((s) => isNaN(+s)).includes(state)) {
+            throw new IllegalRtcPeerConnectionState('NodeWebrtcConnection used an unknown state: ' + state)
         } else {
-            this.lastState = state as RTCPeerConnectionState
+            this.lastState = state as RtcPeerConnectionState
         }
         
-        if (state === RTCPeerConnectionStateEnum.closed
-            || state === RTCPeerConnectionStateEnum.disconnected
-            || state === RTCPeerConnectionStateEnum.failed
+        if (state === RtcPeerConnectionStateEnum.closed
+            || state === RtcPeerConnectionStateEnum.disconnected
+            || state === RtcPeerConnectionStateEnum.failed
         ) {
-            this.doClose('OTHER')
+            this.doClose(false)
         }
         
     }