fix: Reorder the closing of services, prevent sagas running multiple times and close backend server properly

packages/backend/src/backendManager.ts

@@ -109,12 +109,12 @@ export const runBackendMobile = async () => {
     { logger: ['warn', 'error', 'log', 'debug', 'verbose'] }
   )
 
-  rn_bridge.channel.on('close', async () => {
+  rn_bridge.channel.on('close', () => {
     const connectionsManager = app.get<ConnectionsManagerService>(ConnectionsManagerService)
-    await connectionsManager.pause()
+    connectionsManager.pause()
   })
 
-  rn_bridge.channel.on('open', async (msg: OpenServices) => {
+  rn_bridge.channel.on('open', (msg: OpenServices) => {
     const connectionsManager = app.get<ConnectionsManagerService>(ConnectionsManagerService)
     const torControl = app.get<TorControl>(TorControl)
     const proxyAgent = app.get<{ proxy: { port: string } }>(SOCKS_PROXY_AGENT)
@@ -123,7 +123,7 @@ export const runBackendMobile = async () => {
     torControl.torControlParams.auth.value = msg.authCookie
     proxyAgent.proxy.port = msg.httpTunnelPort
 
-    await connectionsManager.resume()
+    connectionsManager.resume()
   })
 }
 

packages/backend/src/nest/connections-manager/connections-manager.service.ts

@@ -223,47 +223,51 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
     }
   }
 
-  public async closeAllServices(options: { saveTor: boolean } = { saveTor: false }) {
+  public async closeAllServices(
+    options: { saveTor: boolean; purgeLocalDb: boolean } = { saveTor: false, purgeLocalDb: false }
+  ) {
+    this.logger('Closing services')
+
+    await this.closeSocket()
+
     if (this.tor && !options.saveTor) {
       this.logger('Killing tor')
       await this.tor.kill()
     } else if (options.saveTor) {
       this.logger('Saving tor')
     }
     if (this.storageService) {
-      this.logger('Stopping orbitdb')
+      this.logger('Stopping OrbitDB')
       await this.storageService?.stopOrbitDb()
     }
-    if (this.serverIoProvider?.io) {
-      this.logger('Closing socket server')
-      this.serverIoProvider.io.close()
-    }
-    if (this.localDbService) {
-      this.logger('Closing local storage')
-      await this.localDbService.close()
-    }
     if (this.libp2pService) {
       this.logger('Stopping libp2p')
       await this.libp2pService.close()
     }
+    if (this.localDbService) {
+      if (options.purgeLocalDb) {
+        this.logger('Purging local DB')
+        await this.localDbService.purge()
+      }
+      this.logger('Closing local DB')
+      await this.localDbService.close()
+    }
   }
 
-  public closeSocket() {
-    this.serverIoProvider.io.close()
+  public async closeSocket() {
+    await this.socketService.close()
   }
 
   public async pause() {
     this.logger('Pausing!')
-    this.logger('Closing socket!')
-    this.closeSocket()
+    await this.closeSocket()
     this.logger('Pausing libp2pService!')
     this.peerInfo = await this.libp2pService?.pause()
     this.logger('Found the following peer info on pause: ', this.peerInfo)
   }
 
   public async resume() {
     this.logger('Resuming!')
-    this.logger('Reopening socket!')
     await this.openSocket()
     this.logger('Attempting to redial peers!')
     if (this.peerInfo && (this.peerInfo?.connected.length !== 0 || this.peerInfo?.dialed.length !== 0)) {
@@ -286,24 +290,17 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
     await this.socketService.init()
   }
 
-  public async leaveCommunity(): Promise<boolean> {
+  public async leaveCommunity() {
     this.logger('Running leaveCommunity')
 
-    this.logger('Resetting tor')
-    this.tor.resetHiddenServices()
-
-    this.logger('Closing the socket')
-    this.closeSocket()
-
-    this.logger('Purging local DB')
-    await this.localDbService.purge()
-
-    this.logger('Closing services')
-    await this.closeAllServices({ saveTor: true })
+    await this.closeAllServices({ saveTor: true, purgeLocalDb: true })
 
     this.logger('Purging data')
     await this.purgeData()
 
+    this.logger('Resetting Tor')
+    this.tor.resetHiddenServices()
+
     this.logger('Resetting state')
     await this.resetState()
 

packages/backend/src/nest/socket/socket.service.ts

@@ -27,13 +27,17 @@ import { CONFIG_OPTIONS, SERVER_IO_PROVIDER } from '../const'
 import { ConfigOptions, ServerIoProviderTypes } from '../types'
 import { suspendableSocketEvents } from './suspendable.events'
 import Logger from '../common/logger'
+import { sleep } from '../common/sleep'
+import type net from 'node:net'
 
 @Injectable()
 export class SocketService extends EventEmitter implements OnModuleInit {
   private readonly logger = Logger(SocketService.name)
 
   public resolveReadyness: (value: void | PromiseLike<void>) => void
   public readyness: Promise<void>
+  private listening: boolean
+  private closeSockets: () => void
 
   constructor(
     @Inject(SERVER_IO_PROVIDER) public readonly serverIoProvider: ServerIoProviderTypes,
@@ -44,12 +48,14 @@ export class SocketService extends EventEmitter implements OnModuleInit {
     this.readyness = new Promise<void>(resolve => {
       this.resolveReadyness = resolve
     })
+
+    this.listening = false
+    this.closeSockets = this.attachListeners()
   }
 
   async onModuleInit() {
     this.logger('init: Started')
 
-    this.attachListeners()
     await this.init()
 
     this.logger('init: Finished')
@@ -71,7 +77,7 @@ export class SocketService extends EventEmitter implements OnModuleInit {
     this.logger('init: Frontend connected')
   }
 
-  private readonly attachListeners = (): void => {
+  private readonly attachListeners = (): (() => void) => {
     // Attach listeners here
     this.serverIoProvider.io.on(SocketActionTypes.CONNECTION, socket => {
       this.logger('Socket connection')
@@ -195,25 +201,72 @@ export class SocketService extends EventEmitter implements OnModuleInit {
         this.emit(SocketActionTypes.LOAD_MIGRATION_DATA, data)
       })
     })
+
+    // Ensure the underlying connections get closed. See:
+    // https://github.com/socketio/socket.io/issues/1602
+    //
+    // I also tried `this.serverIoProvider.io.disconnectSockets(true)`
+    // which didn't work for me.
+    const sockets = new Set<net.Socket>()
+
+    this.serverIoProvider.server.on('connection', conn => {
+      sockets.add(conn)
+      conn.on('close', () => {
+        sockets.delete(conn)
+      })
+    })
+
+    return () => sockets.forEach(s => s.destroy())
+  }
+
+  public getConnections = (): Promise<number> => {
+    return new Promise(resolve => {
+      this.serverIoProvider.server.getConnections((err, count) => {
+        if (err) throw new Error(err.message)
+        resolve(count)
+      })
+    })
   }
 
   public listen = async (port = this.configOptions.socketIOPort): Promise<void> => {
-    return await new Promise(resolve => {
-      if (this.serverIoProvider.server.listening) resolve()
+    this.logger(`Opening data server on port ${this.configOptions.socketIOPort}`)
+
+    // Sometimes socket.io closes the HTTP server but doesn't close
+    // all underlying connections. So it doesn't appear that
+    // `this.serverIoProvider.server.listening` is sufficient.
+    if (this.listening) {
+      const numConnections = await this.getConnections()
+      this.logger('Failed to listen. Connections still open:', numConnections)
+      return
+    }
+
+    return new Promise(resolve => {
       this.serverIoProvider.server.listen(this.configOptions.socketIOPort, '127.0.0.1', () => {
         this.logger(`Data server running on port ${this.configOptions.socketIOPort}`)
+        this.listening = true
         resolve()
       })
     })
   }
 
-  public close = async (): Promise<void> => {
-    this.logger(`Closing data server on port ${this.configOptions.socketIOPort}`)
-    return await new Promise(resolve => {
-      this.serverIoProvider.server.close(err => {
+  public close = (): Promise<void> => {
+    return new Promise(resolve => {
+      this.logger(`Closing data server on port ${this.configOptions.socketIOPort}`)
+
+      if (!this.listening) {
+        this.logger('Data server is not running.')
+        resolve()
+        return
+      }
+
+      this.serverIoProvider.io.close(err => {
         if (err) throw new Error(err.message)
+        this.logger('Data server closed')
+        this.listening = false
         resolve()
       })
+      this.logger('Disconnecting sockets')
+      this.closeSockets()
     })
   }
 }

packages/backend/src/nest/storage/certifacteRequests/certificatesRequestsStore.ts

@@ -52,9 +52,9 @@ export class CertificatesRequestsStore extends EventEmitter {
   }
 
   public async close() {
-    this.logger('Closing...')
+    this.logger('Closing certificate requests DB')
     await this.store?.close()
-    this.logger('Closed')
+    this.logger('Closed certificate requests DB')
   }
 
   public getAddress() {

packages/backend/src/nest/storage/certificates/certificates.store.ts

@@ -72,7 +72,9 @@ export class CertificatesStore extends EventEmitter {
   }
 
   public async close() {
+    this.logger('Closing certificates DB')
     await this.store?.close()
+    this.logger('Closed certificates DB')
   }
 
   public getAddress() {

packages/backend/src/nest/storage/communityMetadata/communityMetadata.store.ts

@@ -90,7 +90,9 @@ export class CommunityMetadataStore extends EventEmitter {
   }
 
   public async close() {
+    logger('Closing community metadata DB')
     await this.store?.close()
+    logger('Closed community metadata DB')
   }
 
   public async updateCommunityMetadata(newMeta: CommunityMetadata): Promise<CommunityMetadata | undefined> {

packages/backend/src/nest/storage/storage.service.ts

@@ -251,7 +251,9 @@ export class StorageService extends EventEmitter {
 
   public async stopOrbitDb() {
     try {
+      this.logger('Closing channels DB')
       await this.channels?.close()
+      this.logger('Closed channels DB')
     } catch (e) {
       this.logger.error('Error closing channels db', e)
     }

packages/backend/src/nest/storage/userProfile/userProfile.store.ts

@@ -86,7 +86,9 @@ export class UserProfileStore extends EventEmitter {
   }
 
   public async close() {
+    logger('Closing user profile DB')
     await this.store?.close()
+    logger('Closed user profile DB')
   }
 
   public async addUserProfile(userProfile: UserProfile) {

packages/mobile/src/store/init/startConnection/startConnection.saga.ts

@@ -1,5 +1,18 @@
 import { io } from 'socket.io-client'
-import { select, put, call, cancel, fork, takeEvery, FixedTask, delay, apply, putResolve } from 'typed-redux-saga'
+import {
+  select,
+  put,
+  putResolve,
+  call,
+  cancel,
+  fork,
+  take,
+  takeLeading,
+  takeEvery,
+  FixedTask,
+  delay,
+  apply,
+} from 'typed-redux-saga'
 import { PayloadAction } from '@reduxjs/toolkit'
 import { socket as stateManager, Socket } from '@quiet/state-manager'
 import { encodeSecret } from '@quiet/common'
@@ -49,17 +62,20 @@ export function* startConnectionSaga(
   })
   yield* fork(handleSocketLifecycleActions, socket, action.payload)
   // Handle opening/restoring connection
-  yield* takeEvery(initActions.setWebsocketConnected, setConnectedSaga, socket)
+  yield* takeLeading(initActions.setWebsocketConnected, setConnectedSaga, socket)
 }
 
 function* setConnectedSaga(socket: Socket): Generator {
+  console.log('Frontend is ready. Forking state-manager sagas and starting backend...')
+
   const task = yield* fork(stateManager.useIO, socket)
-  console.log('WEBSOCKET', 'Forking state-manager sagas', task)
-  // Handle suspending current connection
-  yield* takeEvery(initActions.suspendWebsocketConnection, cancelRootTaskSaga, task)
-  console.log('Frontend is ready. Starting backend...')
+
   // @ts-ignore - Why is this broken?
   yield* apply(socket, socket.emit, [SocketActionTypes.START])
+
+  // Handle suspending current connection
+  const suspendAction = yield* take(initActions.suspendWebsocketConnection)
+  yield* call(cancelRootTaskSaga, task, suspendAction)
 }
 
 function* handleSocketLifecycleActions(socket: Socket, socketIOData: WebsocketConnectionPayload): Generator {

packages/mobile/src/store/nativeServices/events/nativeServicesCallbacks.ts

@@ -1,5 +1,5 @@
 import { eventChannel } from 'redux-saga'
-import { call, put, take } from 'typed-redux-saga'
+import { call, put, take, cancelled } from 'typed-redux-saga'
 import { app, publicChannels, WEBSOCKET_CONNECTION_CHANNEL, INIT_CHECK_CHANNEL, network } from '@quiet/state-manager'
 import { initActions, InitCheckPayload, WebsocketConnectionPayload } from '../../init/init.slice'
 import { ScreenNames } from '../../../const/ScreenNames.enum'
@@ -9,10 +9,18 @@ import { navigationActions } from '../../navigation/navigation.slice'
 import { nativeServicesActions } from '../nativeServices.slice'
 
 export function* nativeServicesCallbacksSaga(): Generator {
-  const channel = yield* call(deviceEvents)
-  while (true) {
-    const action = yield* take(channel)
-    yield put(action)
+  console.log('nativeServicesCallbacksSaga starting')
+  try {
+    const channel = yield* call(deviceEvents)
+    while (true) {
+      const action = yield* take(channel)
+      yield put(action)
+    }
+  } finally {
+    console.log('nativeServicesCallbacksSaga stopping')
+    if (yield cancelled()) {
+      console.log('nativeServicesCallbacksSaga cancelled')
+    }
   }
 }
 

packages/mobile/src/store/nativeServices/leaveCommunity/leaveCommunity.saga.ts

@@ -1,4 +1,4 @@
-import { select, call, takeLeading, putResolve } from 'typed-redux-saga'
+import { select, call, putResolve } from 'typed-redux-saga'
 import { app } from '@quiet/state-manager'
 import { persistor } from '../../store'
 import { nativeServicesActions } from '../nativeServices.slice'
@@ -9,11 +9,8 @@ import { ScreenNames } from '../../../../src/const/ScreenNames.enum'
 
 export function* leaveCommunitySaga(): Generator {
   console.log('Leaving community')
-
   // Restart backend
   yield* putResolve(app.actions.closeServices())
-
-  yield takeLeading(initActions.canceledRootTask.type, clearReduxStore)
 }
 
 export function* clearReduxStore(): Generator {