limit connect to 3 for 5 minutes, prevent looping restart and full storage off qrcode message

Author: clairton

README.md

@@ -367,6 +367,8 @@ WHATSAPP_VERSION=Version of whatsapp, default to local Baileys version.
 CONSUMER_TIMEOUT_MS=miliseconds in timeout for consume job, default is 30000
 DEFAULT_LOCALE=locale for notifications status, now possibile is en, pt_BR and pt, default is en
 ONLY_HELLO_TEMPLATE=true sets hello template as the only default template, default false.
+MAX_CONNECT_RETRY=3 max try connect 
+MAX_CONNECT_TIME_MS=300000 interval of max connect, 5 minutes
 ```
 
 Bucket env to config assets media compatible with S3, this config can't save in redis:

package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoapi-cloud",
-  "version": "1.26.7",
+  "version": "1.27.0",
   "description": "Unoapi Cloud",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",

src/controllers/session_controller.ts

@@ -118,7 +118,7 @@ export class SessionController {
     const store = await config.getStore(phone, config)
     const { sessionStore } = store
 
-    const generateQrcode = (await sessionStore.isStatusIsDisconnect(phone)) || (await sessionStore.isStatusOffline(phone))
+    const generateQrcode = (await sessionStore.isStatusDisconnect(phone)) || (await sessionStore.isStatusOffline(phone))
     const html = generateQrcode ? await qrcode(phone, this.getConfig, this.onNewLogin, this.socket) : await configuration(phone, this.getConfig)
     return res.send(html)
   }

src/defaults.ts

@@ -78,6 +78,8 @@ export const UNOAPI_DELAY_AFTER_FIRST_MESSAGE_MS = parseInt(process.env.UNOAPI_D
 export const UNOAPI_DELAY_AFTER_FIRST_MESSAGE_WEBHOOK_MS = parseInt(process.env.UNOAPI_DELAY_AFTER_FIRST_MESSAGE_WEBHOOK_MS || '0')
 export const UNOAPI_BULK_BATCH = parseInt(process.env.UNOAPI_BULK_BATCH || '5')
 export const UNOAPI_BULK_DELAY = parseInt(process.env.UNOAPI_BULK_DELAY || '60')
+export const MAX_CONNECT_RETRY = parseInt(process.env.MAX_CONNECT_RETRY || '3')
+export const MAX_CONNECT_TIME_MS = parseInt(process.env.MAX_CONNECT_TIME || '600000')
 export const UNOAPI_BULK_MESSAGE_DELAY = parseInt(process.env.UNOAPI_BULK_DELAY || '12')
 export const PORT: number = parseInt(process.env.PORT || '9876')
 export const BASE_URL = process.env.BASE_URL || `http://localhost:${PORT}`

src/services/auto_connect.ts

@@ -16,7 +16,7 @@ export const autoConnect = async (
   onNewLogin: OnNewLogin,
 ) => {
   try {
-    await sessionStore.syncConnecting()
+    await sessionStore.syncConnections()
     const phones = await sessionStore.getPhones()
     logger.info(`${phones.length} phones to verify if is auto connect`)
     for (let i = 0, j = phones.length; i < j; i++) {

src/services/client_baileys.ts

@@ -566,7 +566,7 @@ export class ClientBaileys implements Client {
   }
 
   async getMessageMetadata<T>(message: T) {
-    if (!this.store || !(await this.store.sessionStore.isStatusOnline(this.phone))) {
+    if (!this.store || !await this.store.sessionStore.isStatusOnline(this.phone)) {
       return message
     }
     const key = message && message['key']

src/services/redis.ts

@@ -135,6 +135,10 @@ const authKey = (phone: string) => {
   return `${BASE_KEY}auth:${phone}`
 }
 
+const connectCountKey = (phone: string, ordinal: number | string) => {
+  return `${BASE_KEY}connect-count:${phone}:${ordinal}`
+}
+
 export const sessionStatusKey = (phone: string) => {
   return `${BASE_KEY}status:${phone}`
 }
@@ -383,6 +387,18 @@ export const getMessage = async <T>(phone: string, jid: string, id: string): Pro
   }
 }
 
+export const getConnectCount = async(phone: string) => {
+  const keyPattern = connectCountKey(phone, '*')
+  const keys = await redisKeys(keyPattern)
+  return keys.length || 0
+}
+
+export const setConnectCount = async (phone: string, ttl: number) => {
+  const last = await getConnectCount(phone)
+  const key = connectCountKey(phone, last + 1)
+  await redisSetAndExpire(key, 1, ttl)
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const setMessage = async (phone: string, jid: string, id: string, value: any) => {
   const key = messageKey(phone, jid, id)

src/services/session_store.ts

@@ -1,8 +1,10 @@
+import { MAX_CONNECT_RETRY } from '../defaults'
 import logger from './logger'
 
-export type sessionStatus = 'offline' | 'online' | 'disconnected' | 'connecting'
+export type sessionStatus = 'offline' | 'online' | 'disconnected' | 'connecting' | 'blocked'
 
 const statuses: Map<string, string> = new Map<string, string>()
+const retries: Map<string, number> = new Map<string, number>()
 
 
 export abstract class SessionStore {
@@ -29,9 +31,38 @@ export abstract class SessionStore {
     return await this.getStatus(phone) == 'offline'
   }
 
-  async isStatusIsDisconnect(phone: string) {
+  async isStatusDisconnect(phone: string) {
     return await this.getStatus(phone) == 'disconnected'
   }
 
-  async syncConnecting() {}
+  async isStatusBlocked(phone: string) {
+    return await this.getStatus(phone) == 'blocked'
+  }
+
+  async getConnectCount(phone: string) {
+    return retries.get(phone) || 0
+  }
+
+  async incrementConnectCountAndVerify(phone: string) {
+    const count = retries.get(phone) || 0
+    retries.set(phone, count + 1)
+    if (retries.get(phone)! >= MAX_CONNECT_RETRY) {
+      this.setStatus(phone, 'blocked')
+      return true
+    }
+  }
+
+  async isStatusBlockedAndVerify(phone: string) {
+    if (await this.isStatusBlocked(phone)) {
+      if (await this.getConnectCount(phone) < MAX_CONNECT_RETRY) {
+        await this.setStatus(phone, 'offline')
+        return false
+      }
+      logger.warn('Blocked %s', phone)
+      return true
+    }
+    return this.incrementConnectCountAndVerify(phone)
+  }
+
+  async syncConnections() {}
 }

src/services/session_store_redis.ts

@@ -1,6 +1,7 @@
 import { SessionStore, sessionStatus } from './session_store'
-import { configKey, redisKeys, getSessionStatus, setSessionStatus, sessionStatusKey, redisGet, getConfig } from './redis'
+import { configKey, redisKeys, getSessionStatus, setSessionStatus, sessionStatusKey, redisGet, getConfig, getConnectCount, setConnectCount } from './redis'
 import logger from './logger'
+import { MAX_CONNECT_RETRY } from '../defaults'
 
 const toReplaceConfig = configKey('')
 const toReplaceStatus = sessionStatusKey('')
@@ -26,18 +27,36 @@ export class SessionStoreRedis extends SessionStore {
     return setSessionStatus(phone, status)
   }
 
-  async syncConnecting() {
-    logger.info(`Syncing lost connections...`)
+  async getConnectCount(phone: string) {
+    return getConnectCount(phone)
+  }
+
+  async incrementConnectCountAndVerify(phone: string) {
+    const count = await this.getConnectCount(phone)
+    await setConnectCount(phone, count + 1)
+
+    if (await this.getConnectCount(phone) >= MAX_CONNECT_RETRY) {
+      this.setStatus(phone, 'blocked')
+      return true
+    }
+  }
+
+  async syncConnections() {
+    logger.info(`Syncing lost and blocked connections...`)
     try {
       const pattern = sessionStatusKey('*')
       const keys = await redisKeys(pattern)
       for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
         const phone = key.replace(toReplaceStatus, '')
-        if ((await redisGet(key)) == 'connecting' || !getConfig(phone) ) {
+        if (await redisGet(key) == 'connecting' || !await getConfig(phone) ) {
           logger.info(`Sync ${phone} lost connecting!`)
           await this.setStatus(phone, 'disconnected')
         }
+        if (await redisGet(key) == 'blocked' && await this.getConnectCount(phone) < MAX_CONNECT_RETRY) {
+          logger.info(`Sync ${phone} blocked!`)
+          await this.setStatus(phone, 'offline')
+        }
       }
     } catch (error) {
       logger.error(error, 'Error on sync lost connecting')

src/services/socket.ts

@@ -227,7 +227,7 @@ export const connect = async ({
       sock = undefined
       return
     }
-    if (await sessionStore.isStatusIsDisconnect(phone)) {
+    if (await sessionStore.isStatusDisconnect(phone)) {
       logger.warn('Already Disconnected %s', phone)
       sock = undefined
       return
@@ -365,7 +365,7 @@ export const connect = async ({
     if (await sessionStore.isStatusConnecting(phone)) {
       await verifyConnectingTimeout()
       throw new SendError(5, t('connecting_session'))
-    } else if (await sessionStore.isStatusIsDisconnect(phone) || !sock) {
+    } else if (await sessionStore.isStatusDisconnect(phone) || !sock) {
       throw new SendError(3, t('disconnected_session'))
     } else if (await sessionStore.isStatusOffline(phone)) {
       throw new SendError(12, t('offline_session'))
@@ -444,6 +444,10 @@ export const connect = async ({
       logger.warn('Already Connected %s', phone)
       return
     }
+    if (await sessionStore.isStatusBlockedAndVerify(phone)) {
+      logger.warn('Blocked %s', phone)
+      return
+    }
     logger.debug('Connecting %s', phone)
 
     const browser: WABrowserDescription = config.ignoreHistoryMessages ? DEFAULT_BROWSER as WABrowserDescription : Browsers.windows('Desktop')