Merge pull request #13791 from taosdata/fix/mnode

refactor: mnode worker

include/dnode/mnode/mnode.h

@@ -32,9 +32,7 @@ typedef struct {
   int32_t  dnodeId;
   bool     standby;
   bool     deploy;
-  int8_t   replica;
-  int8_t   selfIndex;
-  SReplica replicas[TSDB_MAX_REPLICA];
+  SReplica replica;
   SMsgCb   msgCb;
 } SMnodeOpt;
 
@@ -83,6 +81,7 @@ int32_t mndGetLoad(SMnode *pMnode, SMnodeLoad *pLoad);
  */
 int32_t mndProcessRpcMsg(SRpcMsg *pMsg);
 int32_t mndProcessSyncMsg(SRpcMsg *pMsg);
+int32_t mndPreprocessQueryMsg(SMnode * pMnode, SRpcMsg * pMsg);
 
 /**
  * @brief Generate machine code

source/dnode/mgmt/mgmt_mnode/inc/mmInt.h

@@ -34,39 +34,31 @@ typedef struct SMnodeMgmt {
   SSingleWorker  writeWorker;
   SSingleWorker  syncWorker;
   SSingleWorker  monitorWorker;
-  SReplica       replicas[TSDB_MAX_REPLICA];
-  int8_t         replica;
   bool           stopped;
   int32_t        refCount;
   TdThreadRwlock lock;
 } SMnodeMgmt;
 
 // mmFile.c
-int32_t mmReadFile(SMnodeMgmt *pMgmt, bool *pDeployed);
-int32_t mmWriteFile(SMnodeMgmt *pMgmt, SDCreateMnodeReq *pMsg, bool deployed);
-
-// mmInt.c
-int32_t mmAcquire(SMnodeMgmt *pMgmt);
-void    mmRelease(SMnodeMgmt *pMgmt);
+int32_t mmReadFile(SMnodeMgmt *pMgmt, SReplica *pReplica, bool *pDeployed);
+int32_t mmWriteFile(SMnodeMgmt *pMgmt, const SReplica *pReplica, bool deployed);
 
 // mmHandle.c
 SArray *mmGetMsgHandles();
 int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
 int32_t mmProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
-int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t mmProcessGetMonitorInfoReq(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t mmProcessGetLoadsReq(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mndPreprocessQueryMsg(SMnode * pMnode, SRpcMsg * pMsg);
 
 // mmWorker.c
 int32_t mmStartWorker(SMnodeMgmt *pMgmt);
 void    mmStopWorker(SMnodeMgmt *pMgmt);
-int32_t mmPutNodeMsgToWriteQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmPutNodeMsgToSyncQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmPutNodeMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmPutNodeMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmPutNodeMsgToMonitorQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmPutRpcMsgToQueue(SMnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc);
+int32_t mmPutMsgToWriteQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
+int32_t mmPutMsgToSyncQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
+int32_t mmPutMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
+int32_t mmPutMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
+int32_t mmPutMsgToMonitorQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
+int32_t mmPutMsgToQueue(SMnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_mnode/src/mmFile.c

@@ -16,7 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "mmInt.h"
 
-int32_t mmReadFile(SMnodeMgmt *pMgmt, bool *pDeployed) {
+int32_t mmReadFile(SMnodeMgmt *pMgmt, SReplica *pReplica, bool *pDeployed) {
   int32_t   code = TSDB_CODE_INVALID_JSON_FORMAT;
   int32_t   len = 0;
   int32_t   maxLen = 4096;
@@ -52,61 +52,54 @@ int32_t mmReadFile(SMnodeMgmt *pMgmt, bool *pDeployed) {
   }
   *pDeployed = deployed->valueint;
 
-  cJSON *mnodes = cJSON_GetObjectItem(root, "mnodes");
-  if (mnodes != NULL) {
-    if (!mnodes || mnodes->type != cJSON_Array) {
-      dError("failed to read %s since nodes not found", file);
+  cJSON *id = cJSON_GetObjectItem(root, "id");
+  if (id) {
+    if (id->type != cJSON_Number) {
+      dError("failed to read %s since id not found", file);
       goto _OVER;
     }
+    if (pReplica) {
+      pReplica->id = id->valueint;
+    }
+  }
 
-    pMgmt->replica = cJSON_GetArraySize(mnodes);
-    if (pMgmt->replica <= 0 || pMgmt->replica > TSDB_MAX_REPLICA) {
-      dError("failed to read %s since mnodes size %d invalid", file, pMgmt->replica);
+  cJSON *fqdn = cJSON_GetObjectItem(root, "fqdn");
+  if (fqdn) {
+    if (fqdn->type != cJSON_String || fqdn->valuestring == NULL) {
+      dError("failed to read %s since fqdn not found", file);
       goto _OVER;
     }
-
-    for (int32_t i = 0; i < pMgmt->replica; ++i) {
-      cJSON *node = cJSON_GetArrayItem(mnodes, i);
-      if (node == NULL) break;
-
-      SReplica *pReplica = &pMgmt->replicas[i];
-
-      cJSON *id = cJSON_GetObjectItem(node, "id");
-      if (!id || id->type != cJSON_Number) {
-        dError("failed to read %s since id not found", file);
-        goto _OVER;
-      }
-      pReplica->id = id->valueint;
-
-      cJSON *fqdn = cJSON_GetObjectItem(node, "fqdn");
-      if (!fqdn || fqdn->type != cJSON_String || fqdn->valuestring == NULL) {
-        dError("failed to read %s since fqdn not found", file);
-        goto _OVER;
-      }
+    if (pReplica) {
       tstrncpy(pReplica->fqdn, fqdn->valuestring, TSDB_FQDN_LEN);
+    }
+  }
 
-      cJSON *port = cJSON_GetObjectItem(node, "port");
-      if (!port || port->type != cJSON_Number) {
-        dError("failed to read %s since port not found", file);
-        goto _OVER;
-      }
-      pReplica->port = port->valueint;
+  cJSON *port = cJSON_GetObjectItem(root, "port");
+  if (port) {
+    if (port->type != cJSON_Number) {
+      dError("failed to read %s since port not found", file);
+      goto _OVER;
+    }
+    if (pReplica) {
+      pReplica->port = (uint16_t)port->valueint;
     }
   }
 
   code = 0;
-  dDebug("succcessed to read file %s, deployed:%d", file, *pDeployed);
 
 _OVER:
   if (content != NULL) taosMemoryFree(content);
   if (root != NULL) cJSON_Delete(root);
   if (pFile != NULL) taosCloseFile(&pFile);
+  if (code == 0) {
+    dDebug("succcessed to read file %s, deployed:%d", file, *pDeployed);
+  }
 
   terrno = code;
   return code;
 }
 
-int32_t mmWriteFile(SMnodeMgmt *pMgmt, SDCreateMnodeReq *pMsg, bool deployed) {
+int32_t mmWriteFile(SMnodeMgmt *pMgmt, const SReplica *pReplica, bool deployed) {
   char file[PATH_MAX] = {0};
   char realfile[PATH_MAX] = {0};
   snprintf(file, sizeof(file), "%s%smnode.json.bak", pMgmt->path, TD_DIRSEP);
@@ -124,26 +117,11 @@ int32_t mmWriteFile(SMnodeMgmt *pMgmt, SDCreateMnodeReq *pMsg, bool deployed) {
   char   *content = taosMemoryCalloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
-
-  int8_t replica = (pMsg != NULL ? pMsg->replica : pMgmt->replica);
-  if (replica > 0) {
-    len += snprintf(content + len, maxLen - len, "  \"mnodes\": [{\n");
-    for (int32_t i = 0; i < replica; ++i) {
-      SReplica *pReplica = &pMgmt->replicas[i];
-      if (pMsg != NULL) {
-        pReplica = &pMsg->replicas[i];
-      }
-      len += snprintf(content + len, maxLen - len, "    \"id\": %d,\n", pReplica->id);
-      len += snprintf(content + len, maxLen - len, "    \"fqdn\": \"%s\",\n", pReplica->fqdn);
-      len += snprintf(content + len, maxLen - len, "    \"port\": %u\n", pReplica->port);
-      if (i < replica - 1) {
-        len += snprintf(content + len, maxLen - len, "  },{\n");
-      } else {
-        len += snprintf(content + len, maxLen - len, "  }],\n");
-      }
-    }
+  if (pReplica != NULL && pReplica->id > 0) {
+    len += snprintf(content + len, maxLen - len, "  \"id\": %d,\n", pReplica->id);
+    len += snprintf(content + len, maxLen - len, "  \"fqdn\": \"%s\",\n", pReplica->fqdn);
+    len += snprintf(content + len, maxLen - len, "  \"port\": %u\n,", pReplica->port);
   }
-
   len += snprintf(content + len, maxLen - len, "  \"deployed\": %d\n", deployed);
   len += snprintf(content + len, maxLen - len, "}\n");
 

source/dnode/mgmt/mgmt_mnode/src/mmInt.c

@@ -27,7 +27,7 @@ static bool mmDeployRequired(const SMgmtInputOpt *pInput) {
 static int32_t mmRequire(const SMgmtInputOpt *pInput, bool *required) {
   SMnodeMgmt mgmt = {0};
   mgmt.path = pInput->path;
-  if (mmReadFile(&mgmt, required) != 0) {
+  if (mmReadFile(&mgmt, NULL, required) != 0) {
     return -1;
   }
 
@@ -43,33 +43,19 @@ static void mmBuildOptionForDeploy(SMnodeMgmt *pMgmt, const SMgmtInputOpt *pInpu
   pOption->deploy = true;
   pOption->msgCb = pMgmt->msgCb;
   pOption->dnodeId = pMgmt->pData->dnodeId;
-
-  pOption->replica = 1;
-  pOption->selfIndex = 0;
-
-  SReplica *pReplica = &pOption->replicas[0];
-  pReplica->id = 1;
-  pReplica->port = tsServerPort;
-  tstrncpy(pReplica->fqdn, tsLocalFqdn, TSDB_FQDN_LEN);
+  pOption->replica.id = 1;
+  pOption->replica.port = tsServerPort;
+  tstrncpy(pOption->replica.fqdn, tsLocalFqdn, TSDB_FQDN_LEN);
 }
 
-static void mmBuildOptionForOpen(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
-  pOption->deploy = false;
+static void mmBuildOptionForOpen(SMnodeMgmt *pMgmt, const SReplica *pReplica, SMnodeOpt *pOption) {
   pOption->standby = false;
+  pOption->deploy = false;
   pOption->msgCb = pMgmt->msgCb;
   pOption->dnodeId = pMgmt->pData->dnodeId;
-
-  if (pMgmt->replica > 0) {
+  if (pReplica->id > 0) {
     pOption->standby = true;
-    pOption->replica = 1;
-    pOption->selfIndex = 0;
-    SReplica *pReplica = &pOption->replicas[0];
-    for (int32_t i = 0; i < pMgmt->replica; ++i) {
-      if (pMgmt->replicas[i].id != pMgmt->pData->dnodeId) continue;
-      pReplica->id = pMgmt->replicas[i].id;
-      pReplica->port = pMgmt->replicas[i].port;
-      memcpy(pReplica->fqdn, pMgmt->replicas[i].fqdn, TSDB_FQDN_LEN);
-    }
+    pOption->replica = *pReplica;
   }
 }
 
@@ -105,12 +91,13 @@ static int32_t mmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   pMgmt->path = pInput->path;
   pMgmt->name = pInput->name;
   pMgmt->msgCb = pInput->msgCb;
-  pMgmt->msgCb.putToQueueFp = (PutToQueueFp)mmPutRpcMsgToQueue;
+  pMgmt->msgCb.putToQueueFp = (PutToQueueFp)mmPutMsgToQueue;
   pMgmt->msgCb.mgmt = pMgmt;
   taosThreadRwlockInit(&pMgmt->lock, NULL);
 
-  bool deployed = false;
-  if (mmReadFile(pMgmt, &deployed) != 0) {
+  bool     deployed = false;
+  SReplica replica = {0};
+  if (mmReadFile(pMgmt, &replica, &deployed) != 0) {
     dError("failed to read file since %s", terrstr());
     mmClose(pMgmt);
     return -1;
@@ -123,7 +110,7 @@ static int32_t mmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
     mmBuildOptionForDeploy(pMgmt, pInput, &option);
   } else {
     dInfo("mnode start to open");
-    mmBuildOptionForOpen(pMgmt, &option);
+    mmBuildOptionForOpen(pMgmt, &replica, &option);
   }
 
   pMgmt->pMnode = mndOpen(pMgmt->path, &option);
@@ -141,8 +128,7 @@ static int32_t mmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   }
   tmsgReportStartup("mnode-worker", "initialized");
 
-  if (!deployed || pMgmt->replica > 0) {
-    pMgmt->replica = 0;
+  if (!deployed || replica.id > 0) {
     deployed = true;
     if (mmWriteFile(pMgmt, NULL, deployed) != 0) {
       dError("failed to write mnode file since %s", terrstr());
@@ -178,22 +164,3 @@ SMgmtFunc mmGetMgmtFunc() {
 
   return mgmtFunc;
 }
-
-int32_t mmAcquire(SMnodeMgmt *pMgmt) {
-  int32_t code = 0;
-
-  taosThreadRwlockRdlock(&pMgmt->lock);
-  if (pMgmt->stopped) {
-    code = -1;
-  } else {
-    atomic_add_fetch_32(&pMgmt->refCount, 1);
-  }
-  taosThreadRwlockUnlock(&pMgmt->lock);
-  return code;
-}
-
-void mmRelease(SMnodeMgmt *pMgmt) {
-  taosThreadRwlockRdlock(&pMgmt->lock);
-  atomic_sub_fetch_32(&pMgmt->refCount, 1);
-  taosThreadRwlockUnlock(&pMgmt->lock);
-}
\ No newline at end of file

source/dnode/mgmt/mgmt_mnode/src/mmWorker.c

@@ -16,6 +16,25 @@
 #define _DEFAULT_SOURCE
 #include "mmInt.h"
 
+static inline int32_t mmAcquire(SMnodeMgmt *pMgmt) {
+  int32_t code = 0;
+
+  taosThreadRwlockRdlock(&pMgmt->lock);
+  if (pMgmt->stopped) {
+    code = -1;
+  } else {
+    atomic_add_fetch_32(&pMgmt->refCount, 1);
+  }
+  taosThreadRwlockUnlock(&pMgmt->lock);
+  return code;
+}
+
+static inline void mmRelease(SMnodeMgmt *pMgmt) {
+  taosThreadRwlockRdlock(&pMgmt->lock);
+  atomic_sub_fetch_32(&pMgmt->refCount, 1);
+  taosThreadRwlockUnlock(&pMgmt->lock);
+}
+
 static inline void mmSendRsp(SRpcMsg *pMsg, int32_t code) {
   SRpcMsg rsp = {
       .code = code,
@@ -26,7 +45,7 @@ static inline void mmSendRsp(SRpcMsg *pMsg, int32_t code) {
   tmsgSendRsp(&rsp);
 }
 
-static void mmProcessQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
+static void mmProcessRpcMsg(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SMnodeMgmt *pMgmt = pInfo->ahandle;
   int32_t     code = -1;
   dTrace("msg:%p, get from mnode queue", pMsg);
@@ -53,11 +72,10 @@ static void mmProcessQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   taosFreeQitem(pMsg);
 }
 
-static void mmProcessSyncQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
+static void mmProcessSyncMsg(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SMnodeMgmt *pMgmt = pInfo->ahandle;
-  dTrace("msg:%p, get from mnode-sync queue", pMsg);
-
   pMsg->info.node = pMgmt->pMnode;
+  dTrace("msg:%p, get from mnode-sync queue", pMsg);
 
   SMsgHead *pHead = pMsg->pCont;
   pHead->contLen = ntohl(pHead->contLen);
@@ -70,66 +88,69 @@ static void mmProcessSyncQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   taosFreeQitem(pMsg);
 }
 
-static int32_t mmPutNodeMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pMsg) {
-  dTrace("msg:%p, put into %s queue, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->msgType));
-  taosWriteQitem(pWorker->queue, pMsg);
-  return 0;
+static inline int32_t mmPutMsgToWorker(SMnodeMgmt *pMgmt, SSingleWorker *pWorker, SRpcMsg *pMsg) {
+  if (mmAcquire(pMgmt) == 0) {
+    dTrace("msg:%p, put into %s queue, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->msgType));
+    taosWriteQitem(pWorker->queue, pMsg);
+    mmRelease(pMgmt);
+    return 0;
+  } else {
+    dTrace("msg:%p, failed to put into %s queue since %s, type:%s", pMsg, pWorker->name, terrstr(),
+           TMSG_INFO(pMsg->msgType));
+    return -1;
+  }
 }
 
-int32_t mmPutNodeMsgToWriteQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  return mmPutNodeMsgToWorker(&pMgmt->writeWorker, pMsg);
+int32_t mmPutMsgToWriteQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
+  return mmPutMsgToWorker(pMgmt, &pMgmt->writeWorker, pMsg);
 }
 
-int32_t mmPutNodeMsgToSyncQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  return mmPutNodeMsgToWorker(&pMgmt->syncWorker, pMsg);
+int32_t mmPutMsgToSyncQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
+  return mmPutMsgToWorker(pMgmt, &pMgmt->syncWorker, pMsg);
 }
 
-int32_t mmPutNodeMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  return mmPutNodeMsgToWorker(&pMgmt->readWorker, pMsg);
+int32_t mmPutMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
+  return mmPutMsgToWorker(pMgmt, &pMgmt->readWorker, pMsg);
 }
 
-int32_t mmPutNodeMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  mndPreprocessQueryMsg(pMgmt->pMnode, pMsg);
-
-  return mmPutNodeMsgToWorker(&pMgmt->queryWorker, pMsg);
+int32_t mmPutMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
+  if (mndPreprocessQueryMsg(pMgmt->pMnode, pMsg) != 0) {
+    dError("msg:%p, failed to pre-process in mnode since %s, type:%s", pMsg, terrstr(), TMSG_INFO(pMsg->msgType));
+    return -1;
+  }
+  return mmPutMsgToWorker(pMgmt, &pMgmt->queryWorker, pMsg);
 }
 
-int32_t mmPutNodeMsgToMonitorQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  return mmPutNodeMsgToWorker(&pMgmt->monitorWorker, pMsg);
+int32_t mmPutMsgToMonitorQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
+  return mmPutMsgToWorker(pMgmt, &pMgmt->monitorWorker, pMsg);
 }
 
-int32_t mmPutRpcMsgToQueue(SMnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
-  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
-  if (pMsg == NULL) return -1;
-  memcpy(pMsg, pRpc, sizeof(SRpcMsg));
-
+int32_t mmPutMsgToQueue(SMnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
+  SSingleWorker *pWorker = NULL;
   switch (qtype) {
     case WRITE_QUEUE:
-      dTrace("msg:%p, is created and will put into vnode-write queue", pMsg);
-      taosWriteQitem(pMgmt->writeWorker.queue, pMsg);
-      return 0;
+      pWorker = &pMgmt->writeWorker;
+      break;
     case QUERY_QUEUE:
-      dTrace("msg:%p, is created and will put into vnode-query queue", pMsg);
-      taosWriteQitem(pMgmt->queryWorker.queue, pMsg);
-      return 0;
-
+      pWorker = &pMgmt->queryWorker;
+      break;
     case READ_QUEUE:
-      dTrace("msg:%p, is created and will put into vnode-read queue", pMsg);
-      taosWriteQitem(pMgmt->readWorker.queue, pMsg);
-      return 0;
+      pWorker = &pMgmt->readWorker;
+      break;
     case SYNC_QUEUE:
-      if (mmAcquire(pMgmt) == 0) {
-        dTrace("msg:%p, is created and will put into vnode-sync queue", pMsg);
-        taosWriteQitem(pMgmt->syncWorker.queue, pMsg);
-        mmRelease(pMgmt);
-        return 0;
-      } else {
-        return -1;
-      }
+      pWorker = &pMgmt->syncWorker;
+      break;
     default:
       terrno = TSDB_CODE_INVALID_PARA;
-      return -1;
   }
+
+  if (pWorker == NULL) return -1;
+  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
+  if (pMsg == NULL) return -1;
+  memcpy(pMsg, pRpc, sizeof(SRpcMsg));
+
+  dTrace("msg:%p, is created and will put int %s queue", pMsg, pWorker->name);
+  return mmPutMsgToWorker(pMgmt, pWorker, pMsg);
 }
 
 int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
@@ -137,7 +158,7 @@ int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
       .min = tsNumOfMnodeQueryThreads,
       .max = tsNumOfMnodeQueryThreads,
       .name = "mnode-query",
-      .fp = (FItem)mmProcessQueue,
+      .fp = (FItem)mmProcessRpcMsg,
       .param = pMgmt,
   };
   if (tSingleWorkerInit(&pMgmt->queryWorker, &qCfg) != 0) {
@@ -149,7 +170,7 @@ int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
       .min = tsNumOfMnodeReadThreads,
       .max = tsNumOfMnodeReadThreads,
       .name = "mnode-read",
-      .fp = (FItem)mmProcessQueue,
+      .fp = (FItem)mmProcessRpcMsg,
       .param = pMgmt,
   };
   if (tSingleWorkerInit(&pMgmt->readWorker, &rCfg) != 0) {
@@ -161,7 +182,7 @@ int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
       .min = 1,
       .max = 1,
       .name = "mnode-write",
-      .fp = (FItem)mmProcessQueue,
+      .fp = (FItem)mmProcessRpcMsg,
       .param = pMgmt,
   };
   if (tSingleWorkerInit(&pMgmt->writeWorker, &wCfg) != 0) {
@@ -173,7 +194,7 @@ int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
       .min = 1,
       .max = 1,
       .name = "mnode-sync",
-      .fp = (FItem)mmProcessSyncQueue,
+      .fp = (FItem)mmProcessSyncMsg,
       .param = pMgmt,
   };
   if (tSingleWorkerInit(&pMgmt->syncWorker, &sCfg) != 0) {
@@ -185,7 +206,7 @@ int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
       .min = 1,
       .max = 1,
       .name = "mnode-monitor",
-      .fp = (FItem)mmProcessQueue,
+      .fp = (FItem)mmProcessRpcMsg,
       .param = pMgmt,
   };
   if (tSingleWorkerInit(&pMgmt->monitorWorker, &mCfg) != 0) {

source/dnode/mgmt/node_mgmt/src/dmEnv.c

@@ -123,10 +123,12 @@ static int32_t dmProcessCreateNodeReq(EDndNodeType ntype, SRpcMsg *pMsg) {
     dError("node:%s, failed to create since %s", pWrapper->name, terrstr());
   } else {
     dInfo("node:%s, has been created", pWrapper->name);
-    (void)dmOpenNode(pWrapper);
-    (void)dmStartNode(pWrapper);
-    pWrapper->required = true;
+    code = dmOpenNode(pWrapper);
+    if (code != 0) {
+      code = dmStartNode(pWrapper);
+    }
     pWrapper->deployed = true;
+    pWrapper->required = true;
     pWrapper->proc.ptype = pDnode->ptype;
   }
 

source/dnode/mnode/impl/inc/mndInt.h

@@ -76,11 +76,12 @@ typedef struct {
 } STelemMgmt;
 
 typedef struct {
-  sem_t   syncSem;
-  int64_t sync;
-  bool    standby;
-  int32_t errCode;
-  int32_t transId;
+  sem_t    syncSem;
+  int64_t  sync;
+  bool     standby;
+  SReplica replica;
+  int32_t  errCode;
+  int32_t  transId;
 } SSyncMgmt;
 
 typedef struct {
@@ -98,9 +99,6 @@ typedef struct SMnode {
   bool           stopped;
   bool           restored;
   bool           deploy;
-  int8_t         replica;
-  int8_t         selfIndex;
-  SReplica       replicas[TSDB_MAX_REPLICA];
   char          *path;
   int64_t        checkTime;
   SSdb          *pSdb;

source/dnode/mnode/impl/src/mndDnode.c

@@ -95,8 +95,8 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
   dnodeObj.id = 1;
   dnodeObj.createdTime = taosGetTimestampMs();
   dnodeObj.updateTime = dnodeObj.createdTime;
-  dnodeObj.port = pMnode->replicas[0].port;
-  memcpy(&dnodeObj.fqdn, pMnode->replicas[0].fqdn, TSDB_FQDN_LEN);
+  dnodeObj.port = tsServerPort;
+  memcpy(&dnodeObj.fqdn, tsLocalFqdn, TSDB_FQDN_LEN);
   snprintf(dnodeObj.ep, TSDB_EP_LEN, "%s:%u", dnodeObj.fqdn, dnodeObj.port);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, NULL);

source/dnode/mnode/impl/src/mndMain.c

@@ -289,11 +289,9 @@ static int32_t mndExecSteps(SMnode *pMnode) {
 }
 
 static void mndSetOptions(SMnode *pMnode, const SMnodeOpt *pOption) {
-  pMnode->replica = pOption->replica;
-  pMnode->selfIndex = pOption->selfIndex;
-  memcpy(&pMnode->replicas, pOption->replicas, sizeof(SReplica) * TSDB_MAX_REPLICA);
   pMnode->msgCb = pOption->msgCb;
   pMnode->selfDnodeId = pOption->dnodeId;
+  pMnode->syncMgmt.replica = pOption->replica;
   pMnode->syncMgmt.standby = pOption->standby;
 }
 

source/dnode/mnode/impl/src/mndSync.c

@@ -188,15 +188,15 @@ int32_t mndInitSync(SMnode *pMnode) {
   syncInfo.isStandBy = pMgmt->standby;
   syncInfo.snapshotEnable = true;
 
-  SSyncCfg *pCfg = &syncInfo.syncCfg;
-  pCfg->replicaNum = pMnode->replica;
-  pCfg->myIndex = pMnode->selfIndex;
-  mInfo("start to open mnode sync, replica:%d myindex:%d standby:%d", pCfg->replicaNum, pCfg->myIndex, pMgmt->standby);
-  for (int32_t i = 0; i < pMnode->replica; ++i) {
-    SNodeInfo *pNode = &pCfg->nodeInfo[i];
-    tstrncpy(pNode->nodeFqdn, pMnode->replicas[i].fqdn, sizeof(pNode->nodeFqdn));
-    pNode->nodePort = pMnode->replicas[i].port;
-    mInfo("index:%d, fqdn:%s port:%d", i, pNode->nodeFqdn, pNode->nodePort);
+  mInfo("start to open mnode sync, standby:%d", pMgmt->standby);
+  if (pMgmt->standby || pMgmt->replica.id > 0) {
+    SSyncCfg *pCfg = &syncInfo.syncCfg;
+    pCfg->replicaNum = 1;
+    pCfg->myIndex = 0;
+    SNodeInfo *pNode = &pCfg->nodeInfo[0];
+    tstrncpy(pNode->nodeFqdn, pMgmt->replica.fqdn, sizeof(pNode->nodeFqdn));
+    pNode->nodePort = pMgmt->replica.port;
+    mInfo("fqdn:%s port:%u", pNode->nodeFqdn, pNode->nodePort);
   }
 
   tsem_init(&pMgmt->syncSem, 0, 0);

source/libs/transport/src/transCli.c

@@ -983,6 +983,9 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
         SEpSet epSet = {0};
         tDeserializeSEpSet(pResp->pCont, pResp->contLen, &epSet);
         pCtx->epSet = epSet;
+        if (!transEpSetIsEqual(&epSet, &pCtx->epSet)) {
+          pCtx->retryCount = 0;
+        }
       }
       addConnToPool(pThrd->pool, pConn);
       tTrace("use remote epset, current in use: %d, retry count:%d, try limit: %d", pEpSet->inUse, pCtx->retryCount + 1,