Merge branch '3.0' into feature/3.0_liaohj

cmake/cmake.define

@@ -14,25 +14,6 @@ MESSAGE(STATUS "Project binary files output path: " ${PROJECT_BINARY_DIR})
 MESSAGE(STATUS "Project executable files output path: " ${EXECUTABLE_OUTPUT_PATH})
 MESSAGE(STATUS "Project library files output path: " ${LIBRARY_OUTPUT_PATH})
 
-find_package(Git QUIET)
-if(GIT_FOUND AND EXISTS "${TD_SOURCE_DIR}/.git")
-# Update submodules as needed
-    option(GIT_SUBMODULE "Check submodules during build" ON)
-    if(GIT_SUBMODULE)
-        message(STATUS "Submodule update")
-        execute_process(COMMAND cd ${TD_SOURCE_DIR} && ${GIT_EXECUTABLE} submodule update --init --recursive
-                        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                        RESULT_VARIABLE GIT_SUBMOD_RESULT)
-        if(NOT GIT_SUBMOD_RESULT EQUAL "0")
-            message(WARNING "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodules")
-        endif()
-    endif()
-endif()
-
-if(NOT EXISTS "${TD_SOURCE_DIR}/tools/taos-tools/CMakeLists.txt")
-    message(WARNING "The submodules were not downloaded! GIT_SUBMODULE was turned off or failed. Please update submodules manually if you need build them.")
-endif()
-
 if (NOT DEFINED TD_GRANT)
   SET(TD_GRANT FALSE)
 endif()

include/common/tglobal.h

@@ -32,6 +32,7 @@ extern char     tsLocalEp[];
 extern uint16_t tsServerPort;
 extern int32_t  tsVersion;
 extern int32_t  tsStatusInterval;
+extern int32_t  tsNumOfSupportVnodes;
 
 // common
 extern int32_t tsMaxShellConns;
@@ -45,7 +46,7 @@ extern bool    tsPrintAuth;
 extern int64_t tsTickPerMin[3];
 
 // multi-process
-extern bool    tsMultiProcess;
+extern int32_t tsMultiProcess;
 extern int32_t tsMnodeShmSize;
 extern int32_t tsVnodeShmSize;
 extern int32_t tsQnodeShmSize;
@@ -125,6 +126,10 @@ extern SDiskCfg tsDiskCfg[];
 // udf
 extern bool tsStartUdfd;
 
+// schemaless
+extern char tsSmlChildTableName[];
+extern bool tsSmlDataFormat;
+
 // internal
 extern int32_t tsTransPullupInterval;
 extern int32_t tsMqRebalanceInterval;

include/common/tmsg.h

@@ -70,7 +70,7 @@ typedef uint16_t tmsg_t;
 #define TSDB_IE_TYPE_DNODE_EXT   6
 #define TSDB_IE_TYPE_DNODE_STATE 7
 
-enum { CONN_TYPE__QUERY = 1, CONN_TYPE__TMQ, CONN_TYPE__MAX };
+enum { CONN_TYPE__QUERY = 1, CONN_TYPE__TMQ, CONN_TYPE__UDFD, CONN_TYPE__MAX };
 
 enum {
   HEARTBEAT_KEY_USER_AUTHINFO = 1,
@@ -1764,17 +1764,15 @@ int32_t tDecodeSVDropTbBatchRsp(SDecoder* pCoder, SVDropTbBatchRsp* pRsp);
 typedef struct {
   const char* tbName;
   int8_t      action;
+  const char* colName;
   // TSDB_ALTER_TABLE_ADD_COLUMN
   int8_t  type;
+  int8_t  flags;
   int32_t bytes;
-  const char* colAddName;
   // TSDB_ALTER_TABLE_DROP_COLUMN
-  const char* colDropName;
   // TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES
-  const char* colModName;
   int32_t colModBytes;
   // TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME
-  const char* colOldName;
   const char* colNewName;
   // TSDB_ALTER_TABLE_UPDATE_TAG_VAL
   const char*    tagName;
@@ -2099,6 +2097,18 @@ enum {
   TOPIC_SUB_TYPE__TABLE,
 };
 
+typedef struct {
+  SMsgHead head;
+  int64_t  leftForVer;
+  int32_t  vgId;
+  int64_t  consumerId;
+  char     subKey[TSDB_SUBSCRIBE_KEY_LEN];
+} SMqVDeleteReq;
+
+typedef struct {
+  int8_t reserved;
+} SMqVDeleteRsp;
+
 typedef struct {
   int64_t leftForVer;
   int32_t vgId;
@@ -2257,20 +2267,22 @@ static FORCE_INLINE void tdDestroyTSma(STSma* pSma) {
   }
 }
 
-static FORCE_INLINE void tdDestroyTSmaWrapper(STSmaWrapper* pSW) {
+static FORCE_INLINE void tdDestroyTSmaWrapper(STSmaWrapper* pSW, bool deepCopy) {
   if (pSW) {
     if (pSW->tSma) {
+      if (deepCopy) {
         for (uint32_t i = 0; i < pSW->number; ++i) {
           tdDestroyTSma(pSW->tSma + i);
         }
+      }
       taosMemoryFreeClear(pSW->tSma);
     }
   }
 }
 
-static FORCE_INLINE void* tdFreeTSmaWrapper(STSmaWrapper* pSW) {
+static FORCE_INLINE void* tdFreeTSmaWrapper(STSmaWrapper* pSW, bool deepCopy) {
-  tdDestroyTSmaWrapper(pSW);
+  tdDestroyTSmaWrapper(pSW, deepCopy);
-  taosMemoryFree(pSW);
+  taosMemoryFreeClear(pSW);
   return NULL;
 }
 
@@ -2534,11 +2546,15 @@ static FORCE_INLINE void tDeleteSMqAskEpRsp(SMqAskEpRsp* pRsp) {
 }
 
 typedef struct {
-  void* data;
+  int64_t streamId;
+  int32_t taskId;
+  int32_t sourceVg;
+  int64_t sourceVer;
+  SArray* data;  // SArray<SSDataBlock>
 } SStreamDispatchReq;
 
 typedef struct {
-  int8_t status;
+  int8_t inputStatus;
 } SStreamDispatchRsp;
 
 #define TD_AUTO_CREATE_TABLE 0x1

include/common/tmsgcb.h

@@ -25,6 +25,7 @@ extern "C" {
 typedef struct SRpcMsg        SRpcMsg;
 typedef struct SEpSet         SEpSet;
 typedef struct SMgmtWrapper   SMgmtWrapper;
+typedef struct SRpcHandleInfo SRpcHandleInfo;
 
 typedef enum {
   QUERY_QUEUE,
@@ -37,26 +38,22 @@ typedef enum {
   QUEUE_MAX,
 } EQueueType;
 
-typedef int32_t (*PutToQueueFp)(void *pMgmt, SRpcMsg* pReq);
+typedef int32_t (*PutToQueueFp)(void* pMgmt, SRpcMsg* pMsg);
 typedef int32_t (*GetQueueSizeFp)(void* pMgmt, int32_t vgId, EQueueType qtype);
-typedef int32_t (*SendReqFp)(SMgmtWrapper* pWrapper, const SEpSet* epSet, SRpcMsg* pReq);
+typedef int32_t (*SendReqFp)(const SEpSet* pEpSet, SRpcMsg* pMsg);
-typedef int32_t (*SendMnodeReqFp)(SMgmtWrapper* pWrapper, SRpcMsg* pReq);
+typedef void (*SendRspFp)(const SRpcMsg* pMsg);
-typedef void (*SendRspFp)(SMgmtWrapper* pWrapper, const SRpcMsg* pRsp);
+typedef void (*SendRedirectRspFp)(const SRpcMsg* pMsg, const SEpSet* pNewEpSet);
-typedef void (*SendMnodeRecvFp)(SMgmtWrapper* pWrapper, SRpcMsg* pReq, SRpcMsg* pRsp);
+typedef void (*RegisterBrokenLinkArgFp)(SRpcMsg* pMsg);
-typedef void (*SendRedirectRspFp)(SMgmtWrapper* pWrapper, const SRpcMsg* pRsp, const SEpSet* pNewEpSet);
+typedef void (*ReleaseHandleFp)(SRpcHandleInfo* pHandle, int8_t type);
-typedef void (*RegisterBrokenLinkArgFp)(SMgmtWrapper* pWrapper, SRpcMsg* pMsg);
+typedef void (*ReportStartup)(const char* name, const char* desc);
-typedef void (*ReleaseHandleFp)(SMgmtWrapper* pWrapper, void* handle, int8_t type);
-typedef void (*ReportStartup)(SMgmtWrapper* pWrapper, const char* name, const char* desc);
 
 typedef struct {
-  SMgmtWrapper*           pWrapper;
+  void*                   mgmt;
-  void*                   pMgmt;
   void*                   clientRpc;
   PutToQueueFp            queueFps[QUEUE_MAX];
   GetQueueSizeFp          qsizeFp;
   SendReqFp               sendReqFp;
   SendRspFp               sendRspFp;
-  SendMnodeRecvFp         sendMnodeRecvFp;
   SendRedirectRspFp       sendRedirectRspFp;
   RegisterBrokenLinkArgFp registerBrokenLinkArgFp;
   ReleaseHandleFp         releaseHandleFp;
@@ -64,14 +61,13 @@ typedef struct {
 } SMsgCb;
 
 void    tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb);
-int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq);
+int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pMsg);
 int32_t tmsgGetQueueSize(const SMsgCb* pMsgCb, int32_t vgId, EQueueType qtype);
-int32_t tmsgSendReq(const SMsgCb* pMsgCb, const SEpSet* epSet, SRpcMsg* pReq);
+int32_t tmsgSendReq(const SEpSet* epSet, SRpcMsg* pMsg);
-void    tmsgSendRsp(SRpcMsg* pRsp);
+void    tmsgSendRsp(const SRpcMsg* pMsg);
-void    tmsgSendMnodeRecv(SRpcMsg* pReq, SRpcMsg* pRsp);
+void    tmsgSendRedirectRsp(const SRpcMsg* pMsg, const SEpSet* pNewEpSet);
-void    tmsgSendRedirectRsp(SRpcMsg* pRsp, const SEpSet* pNewEpSet);
+void    tmsgRegisterBrokenLinkArg(SRpcMsg* pMsg);
-void    tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg);
+void    tmsgReleaseHandle(SRpcHandleInfo* pHandle, int8_t type);
-void    tmsgReleaseHandle(void* handle, int8_t type);
 void    tmsgReportStartup(const char* name, const char* desc);
 
 #ifdef __cplusplus

include/common/tmsgdef.h

@@ -178,6 +178,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_CONNECT, "vnode-mq-connect", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_DISCONNECT, "vnode-mq-disconnect", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_VG_CHANGE, "vnode-mq-vg-change", SMqRebVgReq, SMqRebVgRsp)
+  TD_DEF_MSG_TYPE(TDMT_VND_MQ_VG_DELETE, "vnode-mq-vg-delete", SMqVDeleteReq, SMqVDeleteRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_RES_READY, "vnode-res-ready", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_TASKS_STATUS, "vnode-tasks-status", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_CANCEL_TASK, "vnode-cancel-task", NULL, NULL)

include/dnode/mgmt/dnode.h

@@ -22,66 +22,28 @@
 extern "C" {
 #endif
 
-/* ------------------------ TYPES EXPOSED ---------------- */
-typedef struct SDnode SDnode;
-
 /**
- * @brief Initialize the environment
+ * @brief Initialize the dnode
  *
+ * @param rtype for internal debug usage, default is 0
  * @return int32_t 0 for success and -1 for failure
  */
-int32_t dmInit();
+int32_t dmInit(int8_t rtype);
 
 /**
- * @brief Clear the environment
+ * @brief Cleanup the dnode
  */
 void dmCleanup();
 
-/* ------------------------ SDnode ----------------------- */
+/**
-typedef struct {
+ * @brief Run dnode.
-  int32_t   numOfSupportVnodes;
+ */
-  uint16_t  serverPort;
+int32_t dmRun();
-  char      dataDir[PATH_MAX];
-  char      localEp[TSDB_EP_LEN];
-  char      localFqdn[TSDB_FQDN_LEN];
-  char      firstEp[TSDB_EP_LEN];
-  char      secondEp[TSDB_EP_LEN];
-  SDiskCfg *disks;
-  int32_t   numOfDisks;
-  int8_t    ntype;
-} SDnodeOpt;
-
-typedef enum { DND_EVENT_START = 0, DND_EVENT_STOP = 1, DND_EVENT_CHILD = 2 } EDndEvent;
 
 /**
- * @brief Initialize and start the dnode.
+ * @brief Stop dnode.
- *
- * @param pOption Option of the dnode.
- * @return SDnode* The dnode object.
  */
-SDnode *dmCreate(const SDnodeOpt *pOption);
+void dmStop();
-
-/**
- * @brief Stop and cleanup the dnode.
- *
- * @param pDnode The dnode object to close.
- */
-void dmClose(SDnode *pDnode);
-
-/**
- * @brief Run dnode until specific event is receive.
- *
- * @param pDnode The dnode object to run.
- */
-int32_t dmRun(SDnode *pDnode);
-
-/**
- * @brief Handle event in the dnode.
- *
- * @param pDnode The dnode object to close.
- * @param event The event to handle.
- */
-void dmSetEvent(SDnode *pDnode, EDndEvent event);
 
 #ifdef __cplusplus
 }

include/dnode/mnode/mnode.h

@@ -88,7 +88,7 @@ int32_t mndGetLoad(SMnode *pMnode, SMnodeLoad *pLoad);
  * @param pMsg The request msg.
  * @return int32_t 0 for success, -1 for failure.
  */
-int32_t mndProcessMsg(SNodeMsg *pMsg);
+int32_t mndProcessMsg(SRpcMsg *pMsg);
 
 /**
  * @brief Generate machine code

include/libs/function/functionMgt.h

@@ -41,6 +41,7 @@ typedef enum EFunctionType {
   FUNCTION_TYPE_SUM,
   FUNCTION_TYPE_TWA,
   FUNCTION_TYPE_HISTOGRAM,
+  FUNCTION_TYPE_HYPERLOGLOG,
 
   // nonstandard SQL function
   FUNCTION_TYPE_BOTTOM = 500,

include/libs/function/tudf.h

@@ -87,6 +87,7 @@ typedef struct SUdfInterBuf {
 } SUdfInterBuf;
 typedef void *UdfcFuncHandle;
 
+//low level APIs
 /**
  * setup udf
  * @param udf, in
@@ -115,6 +116,9 @@ int32_t doCallUdfScalarFunc(UdfcFuncHandle handle, SScalarParam *input, int32_t
  */
 int32_t doTeardownUdf(UdfcFuncHandle handle);
 
+void freeUdfInterBuf(SUdfInterBuf *buf);
+
+//high level APIs
 bool udfAggGetEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 bool udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo* pResultCellInfo);
 int32_t udfAggProcess(struct SqlFunctionCtx *pCtx);

include/libs/nodes/nodes.h

@@ -240,6 +240,7 @@ typedef struct SNodeList {
 
 #define SNodeptr void*
 
+int32_t  nodesNodeSize(ENodeType type);
 SNodeptr nodesMakeNode(ENodeType type);
 void     nodesDestroyNode(SNodeptr pNode);
 

include/libs/nodes/querynodes.h

@@ -48,6 +48,7 @@ typedef struct SExprNode {
   ENodeType type;
   SDataType resType;
   char      aliasName[TSDB_COL_NAME_LEN];
+  char      userAlias[TSDB_COL_NAME_LEN];
   SArray*   pAssociation;
 } SExprNode;
 
@@ -325,6 +326,7 @@ typedef struct SQuery {
   bool           showRewrite;
   int32_t        placeholderNum;
   SArray*        pPlaceholderValues;
+  SNode*         pPrepareRoot;
 } SQuery;
 
 void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext);

include/libs/parser/parser.h

@@ -62,7 +62,7 @@ int32_t     qRebuildStmtDataBlock(void** pDst, void* pSrc, uint64_t uid, int32_t
 void        qDestroyStmtDataBlock(void* pBlock);
 STableMeta* qGetTableMetaInDataBlock(void* pDataBlock);
 
-int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx, uint64_t queryId);
+int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx);
 int32_t qStmtParseQuerySql(SParseContext* pCxt, SQuery* pQuery);
 int32_t qBindStmtColsValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen);
 int32_t qBindStmtSingleColValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen, int32_t colIdx,
@@ -77,8 +77,8 @@ int32_t qCreateSName(SName* pName, const char* pTableName, int32_t acctId, char*
 
 void*   smlInitHandle(SQuery* pQuery);
 void    smlDestroyHandle(void* pHandle);
-int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols, bool format,
+int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols, bool format, STableMeta* pTableMeta,
-                    STableMeta* pTableMeta, char* tableName, char* msgBuf, int16_t msgBufLen);
+                    char* tableName, char* msgBuf, int16_t msgBufLen);
 int32_t smlBuildOutput(void* handle, SHashObj* pVgHash);
 
 #ifdef __cplusplus

include/libs/planner/planner.h

@@ -34,7 +34,6 @@ typedef struct SPlanContext {
   bool     showRewrite;
   int8_t   triggerType;
   int64_t  watermark;
-  int32_t  placeholderNum;
   char*    pMsg;
   int32_t  msgLen;
 } SPlanContext;
@@ -48,9 +47,6 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo
 // @pSource one execution location of this group of datasource subplans
 int32_t qSetSubplanExecutionNode(SSubplan* pSubplan, int32_t groupId, SDownstreamSourceNode* pSource);
 
-int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_MULTI_BIND* pParams, int32_t colIdx, uint64_t queryId,
-                       bool* pEmptyResult);
-
 // Convert to subplan to string for the scheduler to send to the executor
 int32_t qSubPlanToString(const SSubplan* pSubplan, char** pStr, int32_t* pLen);
 int32_t qStringToSubplan(const char* pStr, SSubplan** pSubplan);

include/libs/transport/trpc.h

@@ -26,39 +26,42 @@ extern "C" {
 
 #define TAOS_CONN_SERVER 0
 #define TAOS_CONN_CLIENT 1
+#define IsReq(pMsg)      (pMsg->msgType & 1U)
 
 extern int tsRpcHeadSize;
 
-typedef struct SRpcConnInfo {
+typedef struct {
   uint32_t clientIp;
   uint16_t clientPort;
-  uint32_t serverIp;
   char     user[TSDB_USER_LEN];
 } SRpcConnInfo;
 
+typedef struct SRpcHandleInfo {
+  // rpc info
+  void   *handle;         // rpc handle returned to app
+  int64_t refId;          // refid, used by server
+  int32_t noResp;         // has response or not(default 0, 0: resp, 1: no resp);
+  int32_t persistHandle;  // persist handle or not
+
+  // app info
+  void *ahandle;  // app handle set by client
+  void *wrapper;  // wrapper handle
+  void *node;     // node mgmt handle
+
+  // resp info
+  void   *rsp;
+  int32_t rspLen;
+} SRpcHandleInfo;
+
 typedef struct SRpcMsg {
   tmsg_t         msgType;
   void          *pCont;
-  int     contLen;
+  int32_t        contLen;
   int32_t        code;
-  void *  handle;         // rpc handle returned to app
+  SRpcHandleInfo info;
-  void *  ahandle;        // app handle set by client
+  SRpcConnInfo   conn;
-  int64_t refId;          // refid, used by server
-  int     noResp;         // has response or not(default 0, 0: resp, 1: no resp);
-  int     persistHandle;  // persist handle or not
-
 } SRpcMsg;
 
-typedef struct {
-  char     user[TSDB_USER_LEN];
-  uint32_t clientIp;
-  uint16_t clientPort;
-  SRpcMsg  rpcMsg;
-  int32_t  rspLen;
-  void *   pRsp;
-  void *   pNode;
-} SNodeMsg;
-
 typedef void (*RpcCfp)(void *parent, SRpcMsg *, SEpSet *rf);
 typedef int (*RpcAfp)(void *parent, char *tableId, char *spi, char *encrypt, char *secret, char *ckey);
 ///

include/os/os.h

@@ -58,9 +58,6 @@ extern "C" {
 #else
 #include <winsock.h>
 #endif
-
-#define __typeof(a) auto
-
 #endif
 
 #include <errno.h>

include/os/osFile.h

@@ -66,7 +66,7 @@ int32_t taosUnLockFile(TdFilePtr pFile);
 int32_t taosUmaskFile(int32_t maskVal);
  
 int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime);
-int32_t taosDevInoFile(const char *path, int64_t *stDev, int64_t *stIno);
+int32_t taosDevInoFile(TdFilePtr pFile, int64_t *stDev, int64_t *stIno);
 int32_t taosFStatFile(TdFilePtr pFile, int64_t *size, int32_t *mtime);
 bool    taosCheckExistFile(const char *pathname);
  

include/os/osMath.h

@@ -25,9 +25,11 @@ extern "C" {
 
 #define TSWAP(a, b)                              \
   do {                                           \
-    __typeof(a) __tmp = (a); \
+    char *__tmp = taosMemoryMalloc(sizeof(a));   \
-    (a) = (b);               \
+    memcpy(__tmp, &(a), sizeof(a));              \
-    (b) = __tmp;                \
+    memcpy(&(a), &(b), sizeof(a));               \
+    memcpy(&(b), __tmp, sizeof(a));              \
+    taosMemoryFree(__tmp);                       \
   } while (0)
 
 #ifdef WINDOWS

include/util/taoserror.h

@@ -281,6 +281,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST       TAOS_DEF_ERROR_CODE(0, 0x03E8)
 #define TSDB_CODE_MND_OFFSET_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03E9)
 #define TSDB_CODE_MND_CONSUMER_NOT_READY        TAOS_DEF_ERROR_CODE(0, 0x03EA)
+#define TSDB_CODE_MND_TOPIC_SUBSCRIBED          TAOS_DEF_ERROR_CODE(0, 0x03EB)
 
 // mnode-stream
 #define TSDB_CODE_MND_STREAM_ALREADY_EXIST      TAOS_DEF_ERROR_CODE(0, 0x03F0)
@@ -323,6 +324,9 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_VND_SMA_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x0516)
 #define TSDB_CODE_VND_HASH_MISMATCH             TAOS_DEF_ERROR_CODE(0, 0x0517)
 #define TSDB_CODE_VND_TABLE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x0518)
+#define TSDB_CODE_VND_INVALID_TABLE_ACTION      TAOS_DEF_ERROR_CODE(0, 0x0519)
+#define TSDB_CODE_VND_COL_ALREADY_EXISTS        TAOS_DEF_ERROR_CODE(0, 0x051a)
+#define TSDB_CODE_VND_TABLE_COL_NOT_EXISTS      TAOS_DEF_ERROR_CODE(0, 0x051b)
 
 // tsdb
 #define TSDB_CODE_TDB_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0600)
@@ -639,6 +643,9 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INVALID_INTERNAL_PK       TAOS_DEF_ERROR_CODE(0, 0x2646)
 #define TSDB_CODE_PAR_INVALID_TIMELINE_FUNC     TAOS_DEF_ERROR_CODE(0, 0x2647)
 #define TSDB_CODE_PAR_INVALID_PASSWD            TAOS_DEF_ERROR_CODE(0, 0x2648)
+#define TSDB_CODE_PAR_INVALID_ALTER_TABLE       TAOS_DEF_ERROR_CODE(0, 0x2649)
+#define TSDB_CODE_PAR_CANNOT_DROP_PRIMARY_KEY   TAOS_DEF_ERROR_CODE(0, 0x264A)
+#define TSDB_CODE_PAR_INVALID_MODIFY_COL        TAOS_DEF_ERROR_CODE(0, 0x264B)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)
@@ -661,6 +668,8 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_UDF_INVALID_STATE             TAOS_DEF_ERROR_CODE(0, 0x2906)
 #define TSDB_CODE_UDF_INVALID_INPUT             TAOS_DEF_ERROR_CODE(0, 0x2907)
 #define TSDB_CODE_UDF_NO_FUNC_HANDLE            TAOS_DEF_ERROR_CODE(0, 0x2908)
+#define TSDB_CODE_UDF_INVALID_BUFSIZE           TAOS_DEF_ERROR_CODE(0, 0x2909)
+#define TSDB_CODE_UDF_INVALID_OUTPUT_TYPE       TAOS_DEF_ERROR_CODE(0, 0x290A)
 
 #define TSDB_CODE_SML_INVALID_PROTOCOL_TYPE     TAOS_DEF_ERROR_CODE(0, 0x3000)
 #define TSDB_CODE_SML_INVALID_PRECISION_TYPE    TAOS_DEF_ERROR_CODE(0, 0x3001)

include/util/tcoding.h

@@ -63,14 +63,14 @@ static FORCE_INLINE void *taosSkipFixedLen(const void *buf, size_t len) { return
 
 static FORCE_INLINE int32_t taosEncodeFixedBool(void **buf, bool value) {
   if (buf != NULL) {
-    ((int8_t *)(*buf))[0] = value ? 1 : 0;
+    ((int8_t *)(*buf))[0] = (value ? 1 : 0);
     *buf = POINTER_SHIFT(*buf, sizeof(int8_t));
   }
   return (int32_t)sizeof(int8_t);
 }
 
 static FORCE_INLINE void *taosDecodeFixedBool(const void *buf, bool *value) {
-  *value = ((int8_t *)buf)[0] == 0 ? false : true;
+  *value = ( (((int8_t *)buf)[0] == 0) ? false : true );
   return POINTER_SHIFT(buf, sizeof(int8_t));
 }
 

include/util/thash.h

@@ -40,6 +40,7 @@ typedef void (*_hash_free_fn_t)(void *);
  */
 uint32_t MurmurHash3_32(const char *key, uint32_t len);
 
+uint64_t MurmurHash3_64(const char *key, uint32_t len);
 /**
  *
  * @param key

include/util/tjson.h

@@ -25,7 +25,7 @@ extern "C" {
 #define tjsonGetNumberValue(pJson, pName, val, code)  \
   do {                                                \
     uint64_t _tmp = 0;                                \
-    code = tjsonGetUBigIntValue(pJson, pName, &_tmp); \
+    code = tjsonGetBigIntValue(pJson, pName, &_tmp); \
     val = _tmp;                                       \
   } while (0)
 

include/util/tprocess.h

@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_UTIL_PROCESS_H_
-#define _TD_UTIL_PROCESS_H_
-
-#include "os.h"
-#include "tqueue.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum { PROC_FUNC_REQ = 1, PROC_FUNC_RSP, PROC_FUNC_REGIST, PROC_FUNC_RELEASE } EProcFuncType;
-
-typedef struct SProcObj SProcObj;
-typedef void *(*ProcMallocFp)(int32_t contLen, EQItype itype);
-typedef void *(*ProcFreeFp)(void *pCont);
-typedef void (*ProcConsumeFp)(void *parent, void *pHead, int16_t headLen, void *pBody, int32_t bodyLen,
-                              EProcFuncType ftype);
-
-typedef struct {
-  ProcConsumeFp childConsumeFp;
-  ProcMallocFp  childMallocHeadFp;
-  ProcFreeFp    childFreeHeadFp;
-  ProcMallocFp  childMallocBodyFp;
-  ProcFreeFp    childFreeBodyFp;
-  ProcConsumeFp parentConsumeFp;
-  ProcMallocFp  parentMallocHeadFp;
-  ProcFreeFp    parentFreeHeadFp;
-  ProcMallocFp  parentMallocBodyFp;
-  ProcFreeFp    parentFreeBodyFp;
-  SShm          shm;
-  void         *parent;
-  const char   *name;
-  bool          isChild;
-} SProcCfg;
-
-SProcObj *taosProcInit(const SProcCfg *pCfg);
-void      taosProcCleanup(SProcObj *pProc);
-int32_t   taosProcRun(SProcObj *pProc);
-void      taosProcStop(SProcObj *pProc);
-
-int32_t taosProcPutToChildQ(SProcObj *pProc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
-                            void *handle, int64_t handleRef, EProcFuncType ftype);
-int64_t taosProcRemoveHandle(SProcObj *pProc, void *handle);
-void    taosProcCloseHandles(SProcObj *pProc, void (*HandleFp)(void *handle));
-void    taosProcPutToParentQ(SProcObj *pProc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
-                             EProcFuncType ftype);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_UTIL_PROCESS_H_*/

source/client/inc/clientInt.h

@@ -234,6 +234,10 @@ static FORCE_INLINE SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res, bool conver
     if (msg->rsp.withSchema) {
       SSchemaWrapper* pSW = (SSchemaWrapper*)taosArrayGetP(msg->rsp.blockSchema, msg->resIter);
       setResSchemaInfo(&msg->resInfo, pSW->pSchema, pSW->nCols);
+      taosMemoryFreeClear(msg->resInfo.row);
+      taosMemoryFreeClear(msg->resInfo.pCol);
+      taosMemoryFreeClear(msg->resInfo.length);
+      taosMemoryFreeClear(msg->resInfo.convertBuf);
     }
     setQueryResultFromRsp(&msg->resInfo, pRetrieve, convertUcs4);
     return &msg->resInfo;

source/client/src/clientImpl.c

@@ -233,8 +233,7 @@ int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArra
                       .pAstRoot = pQuery->pRoot,
                       .showRewrite = pQuery->showRewrite,
                       .pMsg = pRequest->msgBuf,
-                      .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE,
+                      .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE};
-                      .placeholderNum = pQuery->placeholderNum};
   SEpSet       mgmtEpSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp);
   SCatalog*    pCatalog = NULL;
   int32_t      code = catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &pCatalog);
@@ -585,8 +584,8 @@ bool persistConnForSpecificMsg(void* parenct, tmsg_t msgType) {
 }
 
 void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
-  SMsgSendInfo* pSendInfo = (SMsgSendInfo*)pMsg->ahandle;
+  SMsgSendInfo* pSendInfo = (SMsgSendInfo*)pMsg->info.ahandle;
-  assert(pMsg->ahandle != NULL);
+  assert(pMsg->info.ahandle != NULL);
 
   if (pSendInfo->requestObjRefId != 0) {
     SRequestObj* pRequest = (SRequestObj*)taosAcquireRef(clientReqRefPool, pSendInfo->requestObjRefId);
@@ -617,7 +616,7 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
     taosReleaseRef(clientReqRefPool, pSendInfo->requestObjRefId);
   }
 
-  SDataBuf buf = {.len = pMsg->contLen, .pData = NULL, .handle = pMsg->handle};
+  SDataBuf buf = {.len = pMsg->contLen, .pData = NULL, .handle = pMsg->info.handle};
 
   if (pMsg->contLen > 0) {
     buf.pData = taosMemoryCalloc(1, pMsg->contLen);
@@ -949,7 +948,8 @@ int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableR
 
   // TODO handle the compressed case
   pResultInfo->totalRows += pResultInfo->numOfRows;
-  return setResultDataPtr(pResultInfo, pResultInfo->fields, pResultInfo->numOfCols, pResultInfo->numOfRows, convertUcs4);
+  return setResultDataPtr(pResultInfo, pResultInfo->fields, pResultInfo->numOfCols, pResultInfo->numOfRows,
+                          convertUcs4);
 }
 
 TSDB_SERVER_STATUS taos_check_server_status(const char* fqdn, int port, char* details, int maxlen) {
@@ -957,7 +957,7 @@ TSDB_SERVER_STATUS taos_check_server_status(const char* fqdn, int port, char* de
   void*              clientRpc = NULL;
   SServerStatusRsp   statusRsp = {0};
   SEpSet             epSet = {.inUse = 0, .numOfEps = 1};
-  SRpcMsg            rpcMsg = {.ahandle = (void*)0x9526, .msgType = TDMT_DND_SERVER_STATUS};
+  SRpcMsg            rpcMsg = {.info.ahandle = (void*)0x9526, .msgType = TDMT_DND_SERVER_STATUS};
   SRpcMsg            rpcRsp = {0};
   SRpcInit           rpcInit = {0};
   char               pass[TSDB_PASSWORD_LEN + 1] = {0};

source/client/src/clientSml.c

@@ -16,6 +16,7 @@
 #include "clientInt.h"
 #include "tname.h"
 #include "cJSON.h"
+#include "tglobal.h"
 //=================================================================================================
 
 #define SPACE ' '
@@ -54,6 +55,9 @@ for (int i = 1; i < keyLen; ++i) {      \
   }                                     \
 }
 
+#define IS_INVALID_COL_LEN(len)   ((len) <= 0 || (len) >= TSDB_COL_NAME_LEN)
+#define IS_INVALID_TABLE_LEN(len) ((len) <= 0 || (len) >= TSDB_TABLE_NAME_LEN)
+
 #define OTD_MAX_FIELDS_NUM      2
 #define OTD_JSON_SUB_FIELDS_NUM 2
 #define OTD_JSON_FIELDS_NUM     4
@@ -162,7 +166,7 @@ typedef struct {
 
   SMLProtocolType   protocol;
   int8_t            precision;
-  bool              dataFormat;     // true means that the name, number and order of keys in each line are the same(only for influx protocol)
+  bool              dataFormat;     // true means that the name and order of keys in each line are the same(only for influx protocol)
 
   SHashObj          *childTables;
   SHashObj          *superTables;
@@ -594,19 +598,25 @@ static bool smlParseNumber(SSmlKv *kvVal, SSmlMsgBuf *msg){
     kvVal->type = TSDB_DATA_TYPE_FLOAT;
     kvVal->f = (float)result;
   }else if ((left == 1 && *endptr == 'i') || (left == 3 && strncasecmp(endptr, "i64", left) == 0)){
-    if(smlDoubleToInt64OverFlow(result)){
+    if(result >= (double)INT64_MAX){
-      smlBuildInvalidDataMsg(msg, "big int is too large, out of precision", pVal);
+      kvVal->i = INT64_MAX;
-      return false;
+    }else if(result <= (double)INT64_MIN){
+      kvVal->i = INT64_MIN;
+    }else{
+      kvVal->i = result;
     }
     kvVal->type = TSDB_DATA_TYPE_BIGINT;
-    kvVal->i = (int64_t)result;
   }else if ((left == 3 && strncasecmp(endptr, "u64", left) == 0)){
-    if(result >= (double)UINT64_MAX || result < 0){
+    if(result < 0){
       smlBuildInvalidDataMsg(msg, "unsigned big int is too large, out of precision", pVal);
       return false;
     }
-    kvVal->type = TSDB_DATA_TYPE_UBIGINT;
+    if(result >= (double)UINT64_MAX){
+      kvVal->u = UINT64_MAX;
+    }else{
       kvVal->u = result;
+    }
+    kvVal->type = TSDB_DATA_TYPE_UBIGINT;
   }else if (left == 3 && strncasecmp(endptr, "i32", left) == 0){
     if(!IS_VALID_INT(result)){
       smlBuildInvalidDataMsg(msg, "int out of range[-2147483648,2147483647]", pVal);
@@ -659,12 +669,12 @@ static bool smlParseNumber(SSmlKv *kvVal, SSmlMsgBuf *msg){
 static bool smlParseBool(SSmlKv *kvVal) {
   const char *pVal = kvVal->value;
   int32_t len = kvVal->length;
-  if ((len == 1) && pVal[0] == 't') {
+  if ((len == 1) && (pVal[0] == 't' || pVal[0] == 'T')) {
     kvVal->i = true;
     return true;
   }
 
-  if ((len == 1) && pVal[0] == 'f') {
+  if ((len == 1) && (pVal[0] == 'f' || pVal[0] == 'F')) {
     kvVal->i = false;
     return true;
   }
@@ -899,8 +909,8 @@ static int32_t smlParseInfluxString(const char* sql, SSmlLineInfo *elements, SSm
     sql++;
   }
   elements->measureLen = sql - elements->measure;
-  if(elements->measureLen == 0) {
+  if(IS_INVALID_TABLE_LEN(elements->measureLen)) {
-    smlBuildInvalidDataMsg(msg, "measure is empty", NULL);
+    smlBuildInvalidDataMsg(msg, "measure is empty or too large than 192", NULL);
     return TSDB_CODE_SML_INVALID_DATA;
   }
 
@@ -969,8 +979,9 @@ static void smlParseTelnetElement(const char **sql, const char **data, int32_t *
   }
 }
 
-static int32_t smlParseTelnetTags(const char* data, SArray *cols, SHashObj *dumplicateKey, SSmlMsgBuf *msg){
+static int32_t smlParseTelnetTags(const char* data, SArray *cols, char *childTableName, SHashObj *dumplicateKey, SSmlMsgBuf *msg){
   const char *sql = data;
+  size_t childTableNameLen = strlen(tsSmlChildTableName);
   while(*sql != '\0'){
     JUMP_SPACE(sql)
     if(*sql == '\0') break;
@@ -992,7 +1003,7 @@ static int32_t smlParseTelnetTags(const char* data, SArray *cols, SHashObj *dump
       sql++;
     }
 
-    if(keyLen == 0 || keyLen >= TSDB_COL_NAME_LEN){
+    if(IS_INVALID_COL_LEN(keyLen)){
       smlBuildInvalidDataMsg(msg, "invalid key or key is too long than 64", key);
       return TSDB_CODE_SML_INVALID_DATA;
     }
@@ -1007,8 +1018,6 @@ static int32_t smlParseTelnetTags(const char* data, SArray *cols, SHashObj *dump
     while(*sql != '\0') {
       // parse value
       if (*sql == SPACE) {
-        valueLen = sql - value;
-        sql++;
         break;
       }
       if (*sql == EQUAL) {
@@ -1017,15 +1026,20 @@ static int32_t smlParseTelnetTags(const char* data, SArray *cols, SHashObj *dump
       }
       sql++;
     }
-    if(valueLen == 0){
     valueLen = sql - value;
-    }
 
     if(valueLen == 0){
       smlBuildInvalidDataMsg(msg, "invalid value", value);
       return TSDB_CODE_SML_INVALID_DATA;
     }
 
+    //handle child table name
+    if(childTableNameLen != 0 && strncmp(key, tsSmlChildTableName, keyLen) == 0){
+      memset(childTableName, 0, TSDB_TABLE_NAME_LEN);
+      strncpy(childTableName, value, (valueLen < TSDB_TABLE_NAME_LEN ? valueLen : TSDB_TABLE_NAME_LEN));
+      continue;
+    }
+
     // add kv to SSmlKv
     SSmlKv *kv = (SSmlKv *)taosMemoryCalloc(sizeof(SSmlKv), 1);
     if(!kv) return TSDB_CODE_OUT_OF_MEMORY;
@@ -1047,7 +1061,7 @@ static int32_t smlParseTelnetString(SSmlHandle *info, const char* sql, SSmlTable
 
   // parse metric
   smlParseTelnetElement(&sql, &tinfo->sTableName, &tinfo->sTableNameLen);
-  if (!(tinfo->sTableName) || tinfo->sTableNameLen == 0) {
+  if (!(tinfo->sTableName) || IS_INVALID_TABLE_LEN(tinfo->sTableNameLen)) {
     smlBuildInvalidDataMsg(&info->msgBuf, "invalid data", sql);
     return TSDB_CODE_SML_INVALID_DATA;
   }
@@ -1089,7 +1103,7 @@ static int32_t smlParseTelnetString(SSmlHandle *info, const char* sql, SSmlTable
   }
 
   // parse tags
-  ret = smlParseTelnetTags(sql, tinfo->tags, info->dumplicateKey, &info->msgBuf);
+  ret = smlParseTelnetTags(sql, tinfo->tags, tinfo->childTableName, info->dumplicateKey, &info->msgBuf);
   if (ret != TSDB_CODE_SUCCESS) {
     smlBuildInvalidDataMsg(&info->msgBuf, "invalid data", sql);
     return TSDB_CODE_SML_INVALID_DATA;
@@ -1098,7 +1112,7 @@ static int32_t smlParseTelnetString(SSmlHandle *info, const char* sql, SSmlTable
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t smlParseCols(const char* data, int32_t len, SArray *cols, bool isTag, SHashObj *dumplicateKey, SSmlMsgBuf *msg){
+static int32_t smlParseCols(const char* data, int32_t len, SArray *cols, char *childTableName, bool isTag, SHashObj *dumplicateKey, SSmlMsgBuf *msg){
   if(isTag && len == 0){
     SSmlKv *kv = (SSmlKv *)taosMemoryCalloc(sizeof(SSmlKv), 1);
     if(!kv) return TSDB_CODE_OUT_OF_MEMORY;
@@ -1111,6 +1125,7 @@ static int32_t smlParseCols(const char* data, int32_t len, SArray *cols, bool is
     return TSDB_CODE_SUCCESS;
   }
 
+  size_t childTableNameLen = strlen(tsSmlChildTableName);
   const char *sql = data;
   while(sql < data + len){
     const char *key = sql;
@@ -1130,7 +1145,7 @@ static int32_t smlParseCols(const char* data, int32_t len, SArray *cols, bool is
       sql++;
     }
 
-    if(keyLen == 0 || keyLen >= TSDB_COL_NAME_LEN){
+    if(IS_INVALID_COL_LEN(keyLen)){
       smlBuildInvalidDataMsg(msg, "invalid key or key is too long than 64", key);
       return TSDB_CODE_SML_INVALID_DATA;
     }
@@ -1173,6 +1188,13 @@ static int32_t smlParseCols(const char* data, int32_t len, SArray *cols, bool is
     PROCESS_SLASH(key, keyLen)
     PROCESS_SLASH(value, valueLen)
 
+    //handle child table name
+    if(childTableName && childTableNameLen != 0 && strncmp(key, tsSmlChildTableName, keyLen) == 0){
+      memset(childTableName, 0, TSDB_TABLE_NAME_LEN);
+      strncpy(childTableName, value, (valueLen < TSDB_TABLE_NAME_LEN ? valueLen : TSDB_TABLE_NAME_LEN));
+      continue;
+    }
+
     // add kv to SSmlKv
     SSmlKv *kv = (SSmlKv *)taosMemoryCalloc(sizeof(SSmlKv), 1);
     if(!kv) return TSDB_CODE_OUT_OF_MEMORY;
@@ -1365,7 +1387,7 @@ static void smlDestroySTableMeta(SSmlSTableMeta *meta){
 static void smlDestroyCols(SArray *cols) {
   if (!cols) return;
   for (int i = 0; i < taosArrayGetSize(cols); ++i) {
-    void *kv = taosArrayGet(cols, i);
+    void *kv = taosArrayGetP(cols, i);
     taosMemoryFree(kv);
   }
 }
@@ -1400,7 +1422,7 @@ static void smlDestroyInfo(SSmlHandle* info){
   taosMemoryFreeClear(info);
 }
 
-static SSmlHandle* smlBuildSmlInfo(TAOS* taos, SRequestObj* request, SMLProtocolType protocol, int8_t precision, bool dataFormat){
+static SSmlHandle* smlBuildSmlInfo(TAOS* taos, SRequestObj* request, SMLProtocolType protocol, int8_t precision){
   int32_t code = TSDB_CODE_SUCCESS;
   SSmlHandle* info = (SSmlHandle*)taosMemoryCalloc(1, sizeof(SSmlHandle));
   if (NULL == info) {
@@ -1432,7 +1454,11 @@ static SSmlHandle* smlBuildSmlInfo(TAOS* taos, SRequestObj* request, SMLProtocol
 
   info->precision   = precision;
   info->protocol    = protocol;
-  info->dataFormat  = dataFormat;
+  if(protocol == TSDB_SML_LINE_PROTOCOL){
+    info->dataFormat = tsSmlDataFormat;
+  }else{
+    info->dataFormat = true;
+  }
   info->pRequest    = request;
   info->msgBuf.buf  = info->pRequest->msgBuf;
   info->msgBuf.len  = ERROR_MSG_BUF_DEFAULT_SIZE;
@@ -1443,7 +1469,7 @@ static SSmlHandle* smlBuildSmlInfo(TAOS* taos, SRequestObj* request, SMLProtocol
   info->pVgHash     = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
 
   info->dumplicateKey = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
-  if(!dataFormat){
+  if(!info->dataFormat){
     info->colsContainer = taosArrayInit(32, POINTER_BYTES);
     if(NULL == info->colsContainer){
       uError("SML:0x%"PRIx64" create info failed", info->id);
@@ -1481,8 +1507,8 @@ static int32_t smlParseMetricFromJSON(SSmlHandle *info, cJSON *root, SSmlTableIn
   }
 
   tinfo->sTableNameLen = strlen(metric->valuestring);
-  if (tinfo->sTableNameLen >= TSDB_TABLE_NAME_LEN) {
+  if (IS_INVALID_TABLE_LEN(tinfo->sTableNameLen)) {
-    uError("OTD:0x%"PRIx64" Metric cannot exceeds %d characters in JSON", info->id, TSDB_TABLE_NAME_LEN - 1);
+    uError("OTD:0x%"PRIx64" Metric lenght is 0 or large than 192", info->id);
     return TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
   }
 
@@ -1678,11 +1704,13 @@ static int32_t smlConvertJSONNumber(SSmlKv *pVal, char* typeStr, cJSON *value) {
       strcasecmp(typeStr, "bigint") == 0) {
     pVal->type = TSDB_DATA_TYPE_BIGINT;
     pVal->length = (int16_t)tDataTypes[pVal->type].bytes;
-    if(smlDoubleToInt64OverFlow(value->valuedouble)){
+    if(value->valuedouble >= (double)INT64_MAX){
-      uError("OTD:JSON value(%f) cannot fit in type(big int)", value->valuedouble);
+      pVal->i = INT64_MAX;
-      return TSDB_CODE_TSC_VALUE_OUT_OF_RANGE;
+    }else if(value->valuedouble <= (double)INT64_MIN){
-    }
+      pVal->i = INT64_MIN;
+    }else{
       pVal->i = value->valuedouble;
+    }
     return TSDB_CODE_SUCCESS;
   }
   //float
@@ -1832,60 +1860,49 @@ static int32_t smlParseColsFromJSON(cJSON *root, SArray *cols) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t smlParseTagsFromJSON(cJSON *root, SArray *pKVs, SHashObj *dumplicateKey, SSmlMsgBuf *msg) {
+static int32_t smlParseTagsFromJSON(cJSON *root, SArray *pKVs, char *childTableName, SHashObj *dumplicateKey, SSmlMsgBuf *msg) {
   int32_t ret = TSDB_CODE_SUCCESS;
 
   cJSON *tags = cJSON_GetObjectItem(root, "tags");
   if (tags == NULL || tags->type != cJSON_Object) {
     return TSDB_CODE_TSC_INVALID_JSON;
   }
-  //handle child table name  todo
-//  size_t childTableNameLen = strlen(tsSmlChildTableName);
-//  char childTbName[TSDB_TABLE_NAME_LEN] = {0};
-//  if (childTableNameLen != 0) {
-//    memcpy(childTbName, tsSmlChildTableName, childTableNameLen);
-//    cJSON *id = cJSON_GetObjectItem(tags, childTbName);
-//    if (id != NULL) {
-//      if (!cJSON_IsString(id)) {
-//        tscError("OTD:0x%"PRIx64" ID must be JSON string", info->id);
-//        return TSDB_CODE_TSC_INVALID_JSON;
-//      }
-//      size_t idLen = strlen(id->valuestring);
-//      *childTableName = tcalloc(idLen + TS_BACKQUOTE_CHAR_SIZE + 1, sizeof(char));
-//      memcpy(*childTableName, id->valuestring, idLen);
-//      addEscapeCharToString(*childTableName, (int32_t)idLen);
-//
-//      //check duplicate IDs
-//      cJSON_DeleteItemFromObject(tags, childTbName);
-//      id = cJSON_GetObjectItem(tags, childTbName);
-//      if (id != NULL) {
-//        return TSDB_CODE_TSC_DUP_TAG_NAMES;
-//      }
-//    }
-//  }
 
+  size_t childTableNameLen = strlen(tsSmlChildTableName);
   int32_t tagNum = cJSON_GetArraySize(tags);
   for (int32_t i = 0; i < tagNum; ++i) {
     cJSON *tag = cJSON_GetArrayItem(tags, i);
     if (tag == NULL) {
       return TSDB_CODE_TSC_INVALID_JSON;
     }
+    size_t keyLen = strlen(tag->string);
+    if (IS_INVALID_COL_LEN(keyLen)) {
+      uError("OTD:Tag key length is 0 or too large than 64");
+      return TSDB_CODE_TSC_INVALID_COLUMN_LENGTH;
+    }
     //check duplicate keys
-    if (smlCheckDuplicateKey(tag->string, strlen(tag->string), dumplicateKey)) {
+    if (smlCheckDuplicateKey(tag->string, keyLen, dumplicateKey)) {
       return TSDB_CODE_TSC_DUP_TAG_NAMES;
     }
 
+    //handle child table name
+    if(childTableNameLen != 0 && strcmp(tag->string, tsSmlChildTableName) == 0){
+      if (!cJSON_IsString(tag)) {
+        uError("OTD:ID must be JSON string");
+        return TSDB_CODE_TSC_INVALID_JSON;
+      }
+      memset(childTableName, 0, TSDB_TABLE_NAME_LEN);
+      strncpy(childTableName, tag->valuestring, TSDB_TABLE_NAME_LEN);
+      continue;
+    }
+
     // add kv to SSmlKv
     SSmlKv *kv = (SSmlKv *)taosMemoryCalloc(sizeof(SSmlKv), 1);
     if(!kv) return TSDB_CODE_OUT_OF_MEMORY;
     if(pKVs) taosArrayPush(pKVs, &kv);
 
     //key
-    kv->keyLen = strlen(tag->string);
+    kv->keyLen = keyLen;
-    if (kv->keyLen >= TSDB_COL_NAME_LEN) {
-      uError("OTD:Tag key cannot exceeds %d characters in JSON", TSDB_COL_NAME_LEN - 1);
-      return TSDB_CODE_TSC_INVALID_COLUMN_LENGTH;
-    }
     ret = smlJsonCreateSring(&kv->key, tag->string, kv->keyLen);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
@@ -1941,7 +1958,7 @@ static int32_t smlParseJSONString(SSmlHandle *info, cJSON *root, SSmlTableInfo *
   uDebug("OTD:0x%"PRIx64" Parse metric value from JSON payload finished", info->id);
 
   //Parse tags
-  ret = smlParseTagsFromJSON(root, tinfo->tags, info->dumplicateKey, &info->msgBuf);
+  ret = smlParseTagsFromJSON(root, tinfo->tags, tinfo->childTableName, info->dumplicateKey, &info->msgBuf);
   if (ret) {
     uError("OTD:0x%"PRIx64" Unable to parse tags from JSON payload", info->id);
     return ret;
@@ -1979,7 +1996,7 @@ static int32_t smlParseInfluxLine(SSmlHandle* info, const char* sql) {
     if(info->dataFormat) taosArrayDestroy(cols);
     return ret;
   }
-  ret = smlParseCols(elements.cols, elements.colsLen, cols, false, info->dumplicateKey, &info->msgBuf);
+  ret = smlParseCols(elements.cols, elements.colsLen, cols, NULL, false, info->dumplicateKey, &info->msgBuf);
   if(ret != TSDB_CODE_SUCCESS){
     uError("SML:0x%"PRIx64" smlParseCols parse cloums fields failed", info->id);
     smlDestroyCols(cols);
@@ -2010,7 +2027,7 @@ static int32_t smlParseInfluxLine(SSmlHandle* info, const char* sql) {
   }
 
   if(!hasTable){
-    ret = smlParseCols(elements.tags, elements.tagsLen, (*oneTable)->tags, true, info->dumplicateKey, &info->msgBuf);
+    ret = smlParseCols(elements.tags, elements.tagsLen, (*oneTable)->tags, (*oneTable)->childTableName, true, info->dumplicateKey, &info->msgBuf);
     if(ret != TSDB_CODE_SUCCESS){
       uError("SML:0x%"PRIx64" smlParseCols parse tag fields failed", info->id);
       return ret;
@@ -2023,11 +2040,16 @@ static int32_t smlParseInfluxLine(SSmlHandle* info, const char* sql) {
 
     (*oneTable)->sTableName = elements.measure;
     (*oneTable)->sTableNameLen = elements.measureLen;
+    if(strlen((*oneTable)->childTableName) == 0){
       RandTableName rName = { (*oneTable)->tags, (*oneTable)->sTableName, (uint8_t)(*oneTable)->sTableNameLen,
                              (*oneTable)->childTableName, 0 };
 
       buildChildTableName(&rName);
       (*oneTable)->uid = rName.uid;
+    }else{
+      (*oneTable)->uid = *(uint64_t*)((*oneTable)->childTableName);
+    }
+
   }
 
   SSmlSTableMeta** tableMeta = (SSmlSTableMeta**)taosHashGet(info->superTables, elements.measure, elements.measureLen);
@@ -2077,20 +2099,29 @@ static int32_t smlParseTelnetLine(SSmlHandle* info, void *data) {
   if(ret != TSDB_CODE_SUCCESS){
     uError("SML:0x%"PRIx64" smlParseTelnetLine failed", info->id);
     smlDestroyTableInfo(info, tinfo);
+    smlDestroyCols(cols);
     taosArrayDestroy(cols);
     return ret;
   }
 
   if(taosArrayGetSize(tinfo->tags) <= 0 || taosArrayGetSize(tinfo->tags) > TSDB_MAX_TAGS){
     smlBuildInvalidDataMsg(&info->msgBuf, "invalidate tags length:[1,128]", NULL);
+    smlDestroyTableInfo(info, tinfo);
+    smlDestroyCols(cols);
+    taosArrayDestroy(cols);
     return TSDB_CODE_SML_INVALID_DATA;
   }
   taosHashClear(info->dumplicateKey);
 
+  if(strlen(tinfo->childTableName) == 0){
     RandTableName rName = { tinfo->tags, tinfo->sTableName, (uint8_t)tinfo->sTableNameLen,
                            tinfo->childTableName, 0 };
     buildChildTableName(&rName);
     tinfo->uid = rName.uid;
+  }else{
+    tinfo->uid = *(uint64_t*)(tinfo->childTableName);  // generate uid by name simple
+  }
+
 
   bool hasTable = true;
   SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashGet(info->childTables, tinfo->childTableName, strlen(tinfo->childTableName));
@@ -2308,14 +2339,14 @@ TAOS_RES* taos_schemaless_insert(TAOS* taos, char* lines[], int numLines, int pr
     return NULL;
   }
 
-  SSmlHandle* info = smlBuildSmlInfo(taos, request, (SMLProtocolType)protocol, precision, true);
+  SSmlHandle* info = smlBuildSmlInfo(taos, request, (SMLProtocolType)protocol, precision);
   if(!info){
     return (TAOS_RES*)request;
   }
 
-  if (numLines <= 0 || numLines > 65536) {
+  if (!lines) {
     request->code = TSDB_CODE_SML_INVALID_DATA;
-    smlBuildInvalidDataMsg(&info->msgBuf, "numLines should be between 1 and 65536", NULL);
+    smlBuildInvalidDataMsg(&info->msgBuf, "lines is null", NULL);
     goto end;
   }
 
@@ -2325,7 +2356,7 @@ TAOS_RES* taos_schemaless_insert(TAOS* taos, char* lines[], int numLines, int pr
     goto end;
   }
 
-  if(protocol == TSDB_SML_LINE_PROTOCOL && (precision < TSDB_SML_TIMESTAMP_HOURS || precision > TSDB_SML_TIMESTAMP_NANO_SECONDS)){
+  if(protocol == TSDB_SML_LINE_PROTOCOL && (precision < TSDB_SML_TIMESTAMP_NOT_CONFIGURED || precision > TSDB_SML_TIMESTAMP_NANO_SECONDS)){
     request->code = TSDB_CODE_SML_INVALID_PRECISION_TYPE;
     smlBuildInvalidDataMsg(&info->msgBuf, "precision invalidate for line protocol", NULL);
     goto end;

source/client/src/clientStmt.c

@@ -146,7 +146,8 @@ int32_t stmtUpdateExecInfo(TAOS_STMT* stmt, SHashObj* pVgHash, SHashObj* pBlockH
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t stmtUpdateInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags, char* tbFName, bool autoCreateTbl, SHashObj* pVgHash, SHashObj* pBlockHash) {
+int32_t stmtUpdateInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags, char* tbFName, bool autoCreateTbl,
+                       SHashObj* pVgHash, SHashObj* pBlockHash) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
   STMT_ERR_RET(stmtUpdateBindInfo(stmt, pTableMeta, tags, tbFName));
@@ -157,7 +158,6 @@ int32_t stmtUpdateInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags, char
   return TSDB_CODE_SUCCESS;
 }
 
-
 int32_t stmtGetExecInfo(TAOS_STMT* stmt, SHashObj** pVgHash, SHashObj** pBlockHash) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
@@ -324,8 +324,10 @@ int32_t stmtRebuildDataBlock(STscStmt* pStmt, STableDataBlocks *pDataBlock, STab
   SEpSet      ep = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp);
   SVgroupInfo vgInfo = {0};
 
-  STMT_ERR_RET(catalogGetTableHashVgroup(pStmt->pCatalog, pStmt->taos->pAppInfo->pTransporter, &ep, &pStmt->bInfo.sname, &vgInfo));
+  STMT_ERR_RET(catalogGetTableHashVgroup(pStmt->pCatalog, pStmt->taos->pAppInfo->pTransporter, &ep, &pStmt->bInfo.sname,
-  STMT_ERR_RET(taosHashPut(pStmt->exec.pVgHash, (const char*)&vgInfo.vgId, sizeof(vgInfo.vgId), (char*)&vgInfo, sizeof(vgInfo)));
+                                         &vgInfo));
+  STMT_ERR_RET(
+      taosHashPut(pStmt->exec.pVgHash, (const char*)&vgInfo.vgId, sizeof(vgInfo.vgId), (char*)&vgInfo, sizeof(vgInfo)));
 
   STMT_ERR_RET(qRebuildStmtDataBlock(newBlock, pDataBlock, uid, vgInfo.vgId));
 
@@ -336,7 +338,8 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
   pStmt->bInfo.needParse = true;
   pStmt->bInfo.inExecCache = false;
 
-  STableDataBlocks *pBlockInExec = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  STableDataBlocks* pBlockInExec =
+      taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
   if (pBlockInExec) {
     pStmt->bInfo.needParse = false;
     pStmt->bInfo.inExecCache = true;
@@ -371,7 +374,8 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
       STableDataBlocks* pNewBlock = NULL;
       STMT_ERR_RET(stmtRebuildDataBlock(pStmt, pCache->pDataBlock, &pNewBlock, 0));
 
-      if (taosHashPut(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName), &pNewBlock, POINTER_BYTES)) {
+      if (taosHashPut(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName), &pNewBlock,
+                      POINTER_BYTES)) {
         STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
       }
 
@@ -381,10 +385,10 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
     STMT_RET(stmtCleanBindInfo(pStmt));
   }
 
-
   STableMeta* pTableMeta = NULL;
   SEpSet      ep = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp);
-  int32_t code = catalogGetTableMeta(pStmt->pCatalog, pStmt->taos->pAppInfo->pTransporter, &ep, &pStmt->bInfo.sname, &pTableMeta);
+  int32_t     code =
+      catalogGetTableMeta(pStmt->pCatalog, pStmt->taos->pAppInfo->pTransporter, &ep, &pStmt->bInfo.sname, &pTableMeta);
   if (TSDB_CODE_PAR_TABLE_NOT_EXIST == code) {
     STMT_ERR_RET(stmtCleanBindInfo(pStmt));
 
@@ -408,7 +412,8 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
   if (pStmt->bInfo.inExecCache) {
     SStmtTableCache* pCache = taosHashGet(pStmt->sql.pTableCache, &cacheUid, sizeof(cacheUid));
     if (NULL == pCache) {
-      tscError("table [%s, %" PRIx64 ", %" PRIx64 "] found in exec blockHash, but not in sql blockHash", pStmt->bInfo.tbFName, uid, cacheUid);
+      tscError("table [%s, %" PRIx64 ", %" PRIx64 "] found in exec blockHash, but not in sql blockHash",
+               pStmt->bInfo.tbFName, uid, cacheUid);
 
       STMT_ERR_RET(TSDB_CODE_TSC_APP_ERROR);
     }
@@ -437,7 +442,8 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
     STableDataBlocks* pNewBlock = NULL;
     STMT_ERR_RET(stmtRebuildDataBlock(pStmt, pCache->pDataBlock, &pNewBlock, uid));
 
-    if (taosHashPut(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName), &pNewBlock, POINTER_BYTES)) {
+    if (taosHashPut(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName), &pNewBlock,
+                    POINTER_BYTES)) {
       STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
     }
 
@@ -522,7 +528,8 @@ int stmtSetTbName(TAOS_STMT* stmt, const char* tbName) {
     STMT_ERR_RET(buildRequest(pStmt->taos, pStmt->sql.sqlStr, pStmt->sql.sqlLen, &pStmt->exec.pRequest));
   }
 
-  STMT_ERR_RET(qCreateSName(&pStmt->bInfo.sname, tbName, pStmt->taos->acctId, pStmt->exec.pRequest->pDb, pStmt->exec.pRequest->msgBuf, pStmt->exec.pRequest->msgBufLen));
+  STMT_ERR_RET(qCreateSName(&pStmt->bInfo.sname, tbName, pStmt->taos->acctId, pStmt->exec.pRequest->pDb,
+                            pStmt->exec.pRequest->msgBuf, pStmt->exec.pRequest->msgBufLen));
   tNameExtractFullName(&pStmt->bInfo.sname, pStmt->bInfo.tbFName);
 
   STMT_ERR_RET(stmtGetFromCache(pStmt));
@@ -548,7 +555,8 @@ int stmtSetTbTags(TAOS_STMT* stmt, TAOS_MULTI_BIND* tags) {
     return TSDB_CODE_SUCCESS;
   }
 
-  STableDataBlocks **pDataBlock = (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  STableDataBlocks** pDataBlock =
+      (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
   if (NULL == pDataBlock) {
     tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
     STMT_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
@@ -566,7 +574,8 @@ int32_t stmtFetchTagFields(STscStmt* pStmt, int32_t* fieldNum, TAOS_FIELD** fiel
     STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
   }
 
-  STableDataBlocks **pDataBlock = (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  STableDataBlocks** pDataBlock =
+      (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
   if (NULL == pDataBlock) {
     tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
     STMT_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
@@ -583,7 +592,8 @@ int32_t stmtFetchColFields(STscStmt* pStmt, int32_t* fieldNum, TAOS_FIELD** fiel
     STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
   }
 
-  STableDataBlocks **pDataBlock = (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  STableDataBlocks** pDataBlock =
+      (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
   if (NULL == pDataBlock) {
     tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
     STMT_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
@@ -618,7 +628,7 @@ int stmtBindBatch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int32_t colIdx) {
   }
 
   if (STMT_TYPE_QUERY == pStmt->sql.type) {
-    STMT_ERR_RET(qStmtBindParams(pStmt->sql.pQuery, bind, colIdx, pStmt->exec.pRequest->requestId));
+    STMT_ERR_RET(qStmtBindParams(pStmt->sql.pQuery, bind, colIdx));
 
     SParseContext ctx = {.requestId = pStmt->exec.pRequest->requestId,
                          .acctId = pStmt->taos->acctId,
@@ -637,7 +647,8 @@ int stmtBindBatch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int32_t colIdx) {
     STMT_ERR_RET(qStmtParseQuerySql(&ctx, pStmt->sql.pQuery));
 
     if (pStmt->sql.pQuery->haveResultSet) {
-      setResSchemaInfo(&pStmt->exec.pRequest->body.resInfo, pStmt->sql.pQuery->pResSchema, pStmt->sql.pQuery->numOfResCols);
+      setResSchemaInfo(&pStmt->exec.pRequest->body.resInfo, pStmt->sql.pQuery->pResSchema,
+                       pStmt->sql.pQuery->numOfResCols);
       setResPrecision(&pStmt->exec.pRequest->body.resInfo, pStmt->sql.pQuery->precision);
     }
 
@@ -653,7 +664,8 @@ int stmtBindBatch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int32_t colIdx) {
     return TSDB_CODE_SUCCESS;
   }
 
-  STableDataBlocks **pDataBlock = (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  STableDataBlocks** pDataBlock =
+      (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
   if (NULL == pDataBlock) {
     tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
     STMT_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
@@ -733,7 +745,8 @@ int stmtUpdateTableUid(STscStmt* pStmt, SSubmitRsp *pRsp) {
     }
 
     if (i < pRsp->nBlocks) {
-      tscDebug("auto created table %s uid updated from %" PRIx64 " to %" PRIx64, blkRsp->tblFName, pMeta->uid, blkRsp->uid);
+      tscDebug("auto created table %s uid updated from %" PRIx64 " to %" PRIx64, blkRsp->tblFName, pMeta->uid,
+               blkRsp->uid);
 
       pMeta->uid = blkRsp->uid;
       pStmt->bInfo.tbUid = blkRsp->uid;
@@ -760,7 +773,8 @@ int stmtExec(TAOS_STMT *stmt) {
     launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, TSDB_CODE_SUCCESS, true, NULL);
   } else {
     STMT_ERR_RET(qBuildStmtOutput(pStmt->sql.pQuery, pStmt->exec.pVgHash, pStmt->exec.pBlockHash));
-    launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, TSDB_CODE_SUCCESS, true, (autoCreateTbl ? (void**)&pRsp : NULL));
+    launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, TSDB_CODE_SUCCESS, true,
+                    (autoCreateTbl ? (void**)&pRsp : NULL));
   }
 
   if (pStmt->exec.pRequest->code && NEED_CLIENT_HANDLE_ERROR(pStmt->exec.pRequest->code)) {

source/client/test/CMakeLists.txt

@@ -41,3 +41,7 @@ TARGET_INCLUDE_DIRECTORIES(
         PRIVATE "${TD_SOURCE_DIR}/source/client/inc"
 )
 
+#add_test(
+#        NAME smlTest
+#        COMMAND smlTest
+#)

source/client/test/smlTest.cpp

@@ -207,7 +207,7 @@ TEST(testCase, smlParseCols_Error_Test) {
     char *sql = (char*)taosMemoryCalloc(256, 1);
     memcpy(sql, data[i], len + 1);
     SArray *cols = taosArrayInit(8, POINTER_BYTES);
-    int32_t ret = smlParseCols(sql, len, cols, false, dumplicateKey, &msgBuf);
+    int32_t ret = smlParseCols(sql, len, cols, NULL, false, dumplicateKey, &msgBuf);
     ASSERT_NE(ret, TSDB_CODE_SUCCESS);
     taosHashClear(dumplicateKey);
     taosMemoryFree(sql);
@@ -233,7 +233,7 @@ TEST(testCase, smlParseCols_tag_Test) {
   const char *data =
       "cbin=\"passit helloc\",cnch=L\"iisdfsf\",cbool=false,cf64=4.31f64,cf64_=8.32,cf32=8.23f32,ci8=-34i8,cu8=89u8,ci16=233i16,cu16=898u16,ci32=98289i32,cu32=12323u32,ci64=-89238i64,ci=989i,cu64=8989323u64,cbooltrue=true,cboolt=t,cboolf=f,cnch_=l\"iuwq\"";
   int32_t len = strlen(data);
-  int32_t ret = smlParseCols(data, len, cols, true, dumplicateKey, &msgBuf);
+  int32_t ret = smlParseCols(data, len, cols, NULL, true, dumplicateKey, &msgBuf);
   ASSERT_EQ(ret, TSDB_CODE_SUCCESS);
   int32_t size = taosArrayGetSize(cols);
   ASSERT_EQ(size, 19);
@@ -265,7 +265,7 @@ TEST(testCase, smlParseCols_tag_Test) {
   len = 0;
   memset(msgBuf.buf, 0, msgBuf.len);
   taosHashClear(dumplicateKey);
-  ret = smlParseCols(data, len, cols, true, dumplicateKey, &msgBuf);
+  ret = smlParseCols(data, len, cols, NULL, true, dumplicateKey, &msgBuf);
   ASSERT_EQ(ret, TSDB_CODE_SUCCESS);
   size = taosArrayGetSize(cols);
   ASSERT_EQ(size, 1);
@@ -298,7 +298,7 @@ TEST(testCase, smlParseCols_Test) {
   int32_t len = strlen(data);
   char *sql = (char*)taosMemoryCalloc(1024, 1);
   memcpy(sql, data, len + 1);
-  int32_t ret = smlParseCols(sql, len, cols, false, dumplicateKey, &msgBuf);
+  int32_t ret = smlParseCols(sql, len, cols, NULL, false, dumplicateKey, &msgBuf);
   ASSERT_EQ(ret, TSDB_CODE_SUCCESS);
   int32_t size = taosArrayGetSize(cols);
   ASSERT_EQ(size, 19);
@@ -488,44 +488,118 @@ TEST(testCase, smlProcess_influx_Test) {
   TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(taos, nullptr);
 
-  TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
+  TAOS_RES* pRes = taos_query(taos, "create database if not exists inflx_db");
   taos_free_result(pRes);
 
-  pRes = taos_query(taos, "use sml_db");
+  pRes = taos_query(taos, "use inflx_db");
   taos_free_result(pRes);
 
   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
 
   const char *sql[] = {
-    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 load_capacity=1500,fuel_capacity=150,nominal_fuel_consumption=12,latitude=52.31854,longitude=4.72037,elevation=124,velocity=0,heading=221,grade=0 1451606400000000000",
+    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 load_capacity=1500,fuel_capacity=150,nominal_fuel_consumption=12,latitude=52.31854,longitude=4.72037,elevation=124,velocity=0,heading=221,grade=0 1451606401000000000",
-    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 load_capacity=1500,fuel_capacity=150,nominal_fuel_consumption=12,latitude=52.31854,longitude=4.72037,elevation=124,velocity=0,heading=221,grade=0,fuel_consumption=25 1451607400000000000",
+    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 load_capacity=1500,fuel_capacity=150,nominal_fuel_consumption=12,latitude=52.31854,longitude=4.72037,elevation=124,velocity=0,heading=221,grade=0,fuel_consumption=25 1451607402000000000",
-    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 load_capacity=1500,fuel_capacity=150,nominal_fuel_consumption=12,latitude=52.31854,longitude=4.72037,elevation=124,heading=221,grade=0,fuel_consumption=25 1451608400000000000",
+    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 load_capacity=1500,fuel_capacity=150,nominal_fuel_consumption=12,latitude=52.31854,longitude=4.72037,elevation=124,heading=221,grade=0,fuel_consumption=25 1451608403000000000",
-    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 fuel_capacity=150,nominal_fuel_consumption=12,latitude=52.31854,longitude=4.72037,elevation=124,velocity=0,heading=221,grade=0,fuel_consumption=25 1451609400000000000",
+    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 fuel_capacity=150,nominal_fuel_consumption=12,latitude=52.31854,longitude=4.72037,elevation=124,velocity=0,heading=221,grade=0,fuel_consumption=25 1451609404000000000",
-    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 fuel_consumption=25,grade=0 1451619400000000000",
+    "readings,name=truck_0,fleet=South,driver=Trish,model=H-2,device_version=v2.3 fuel_consumption=25,grade=0 1451619405000000000",
-    "readings,name=truck_1,fleet=South,driver=Albert,model=F-150,device_version=v1.5 load_capacity=2000,fuel_capacity=200,nominal_fuel_consumption=15,latitude=72.45258,longitude=68.83761,elevation=255,velocity=0,heading=181,grade=0,fuel_consumption=25 1451606400000000000",
+    "readings,name=truck_1,fleet=South,driver=Albert,model=F-150,device_version=v1.5 load_capacity=2000,fuel_capacity=200,nominal_fuel_consumption=15,latitude=72.45258,longitude=68.83761,elevation=255,velocity=0,heading=181,grade=0,fuel_consumption=25 145160640600000000",
-    "readings,name=truck_2,driver=Derek,model=F-150,device_version=v1.5 load_capacity=2000,fuel_capacity=200,nominal_fuel_consumption=15,latitude=24.5208,longitude=28.09377,elevation=428,velocity=0,heading=304,grade=0,fuel_consumption=25 1451606400000000000",
+    "readings,name=truck_2,driver=Derek,model=F-150,device_version=v1.5 load_capacity=2000,fuel_capacity=200,nominal_fuel_consumption=15,latitude=24.5208,longitude=28.09377,elevation=428,velocity=0,heading=304,grade=0,fuel_consumption=25 1451606407000000000",
-    "readings,name=truck_2,fleet=North,driver=Derek,model=F-150 load_capacity=2000,fuel_capacity=200,nominal_fuel_consumption=15,latitude=24.5208,longitude=28.09377,elevation=428,velocity=0,heading=304,grade=0,fuel_consumption=25 1451609400000000000",
+    "readings,name=truck_2,fleet=North,driver=Derek,model=F-150 load_capacity=2000,fuel_capacity=200,nominal_fuel_consumption=15,latitude=24.5208,longitude=28.09377,elevation=428,velocity=0,heading=304,grade=0,fuel_consumption=25 1451609408000000000",
-    "readings,fleet=South,name=truck_0,driver=Trish,model=H-2,device_version=v2.3 fuel_consumption=25,grade=0 1451629400000000000",
+    "readings,fleet=South,name=truck_0,driver=Trish,model=H-2,device_version=v2.3 fuel_consumption=25,grade=0 1451629409000000000",
-    "stable,t1=t1,t2=t2,t3=t3 c1=1,c2=2,c3=3,c4=4 1451629500000000000",
+    "stable,t1=t1,t2=t2,t3=t3 c1=1,c2=2,c3=\"kk\",c4=4 1451629501000000000",
-    "stable,t2=t2,t1=t1,t3=t3 c1=1,c3=3,c4=4 1451629600000000000",
+    "stable,t2=t2,t1=t1,t3=t3 c1=1,c3=\"\",c4=4 1451629602000000000",
   };
   int ret = smlProcess(info, (char**)sql, sizeof(sql)/sizeof(sql[0]));
   ASSERT_EQ(ret, 0);
 
-  TAOS_RES *res = taos_query(taos, "select * from t_6885c584b98481584ee13dac399e173d");
+  // case 1
+  TAOS_RES *res = taos_query(taos, "select * from t_91e0b182be80332b5c530cbf872f760e");
   ASSERT_NE(res, nullptr);
-//  int fieldNum = taos_field_count(res);
+  int fieldNum = taos_field_count(res);
-//  ASSERT_EQ(fieldNum, 5);
+  ASSERT_EQ(fieldNum, 11);
-//  int rowNum = taos_affected_rows(res);
+  printf("fieldNum:%d\n", fieldNum);
-//  ASSERT_EQ(rowNum, 2);
+
-//  for (int i = 0; i < rowNum; ++i) {
+  TAOS_ROW row = NULL;
-//    TAOS_ROW rows = taos_fetch_row(res);
+  int32_t rowIndex = 0;
-//  }
+  while((row = taos_fetch_row(res)) != NULL) {
+    int64_t ts = *(int64_t*)row[0];
+    double load_capacity = *(double*)row[1];
+    double fuel_capacity = *(double*)row[2];
+    double nominal_fuel_consumption = *(double*)row[3];
+    double latitude = *(double*)row[4];
+    double longitude = *(double*)row[5];
+    double elevation = *(double*)row[6];
+    double velocity = *(double*)row[7];
+    double heading = *(double*)row[8];
+    double grade = *(double*)row[9];
+    double fuel_consumption = *(double*)row[10];
+    if(rowIndex == 0){
+      ASSERT_EQ(ts, 1451606407000);
+      ASSERT_EQ(load_capacity, 2000);
+      ASSERT_EQ(fuel_capacity, 200);
+      ASSERT_EQ(nominal_fuel_consumption, 15);
+      ASSERT_EQ(latitude, 24.5208);
+      ASSERT_EQ(longitude, 28.09377);
+      ASSERT_EQ(elevation, 428);
+      ASSERT_EQ(velocity, 0);
+      ASSERT_EQ(heading, 304);
+      ASSERT_EQ(grade, 0);
+      ASSERT_EQ(fuel_consumption, 25);
+    }else{
+      ASSERT_FALSE(1);
+    }
+    rowIndex++;
+  }
   taos_free_result(res);
+
+  // case 2
+  res = taos_query(taos, "select * from t_6885c584b98481584ee13dac399e173d");
+  ASSERT_NE(res, nullptr);
+  fieldNum = taos_field_count(res);
+  ASSERT_EQ(fieldNum, 5);
+  printf("fieldNum:%d\n", fieldNum);
+
+  rowIndex = 0;
+  while((row = taos_fetch_row(res)) != NULL) {
+    int *length = taos_fetch_lengths(res);
+
+    int64_t ts = *(int64_t*)row[0];
+    double c1 = *(double*)row[1];
+    double c4 = *(double*)row[4];
+    if(rowIndex == 0){
+      ASSERT_EQ(ts, 1451629501000);
+      ASSERT_EQ(c1, 1);
+      ASSERT_EQ(*(double*)row[2], 2);
+      ASSERT_EQ(length[3], 2);
+      ASSERT_EQ(memcmp(row[3], "kk", length[3]), 0);
+      ASSERT_EQ(c4, 4);
+    }else if(rowIndex == 1){
+      ASSERT_EQ(ts, 1451629602000);
+      ASSERT_EQ(c1, 1);
+      ASSERT_EQ(row[2], nullptr);
+      ASSERT_EQ(length[3], 0);
+      ASSERT_EQ(c4, 4);
+    }else{
+      ASSERT_FALSE(1);
+    }
+    rowIndex++;
+  }
+  taos_free_result(res);
+
+  // case 2
+  res = taos_query(taos, "show tables");
+  ASSERT_NE(res, nullptr);
+
+  row = taos_fetch_row(res);
+  int rowNum = taos_affected_rows(res);
+  ASSERT_EQ(rowNum, 5);
+  taos_free_result(res);
+
+
   destroyRequest(request);
   smlDestroyInfo(info);
 }
@@ -544,7 +618,7 @@ TEST(testCase, smlParseLine_error_Test) {
   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
 
   const char *sql[] = {
@@ -584,16 +658,16 @@ TEST(testCase, smlProcess_telnet_Test) {
   TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(taos, nullptr);
 
-  TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
+  TAOS_RES* pRes = taos_query(taos, "create database if not exists telnet_db");
   taos_free_result(pRes);
 
-  pRes = taos_query(taos, "use sml_db");
+  pRes = taos_query(taos, "use telnet_db");
   taos_free_result(pRes);
 
   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
 
   const char *sql[] = {
@@ -605,27 +679,31 @@ TEST(testCase, smlProcess_telnet_Test) {
   int ret = smlProcess(info, (char**)sql, sizeof(sql)/sizeof(sql[0]));
   ASSERT_EQ(ret, 0);
 
+  // case 1
   TAOS_RES *res = taos_query(taos, "select * from t_8c30283b3c4131a071d1e16cf6d7094a");
   ASSERT_NE(res, nullptr);
-//  int fieldNum = taos_field_count(res);
+  int fieldNum = taos_field_count(res);
-//  ASSERT_EQ(fieldNum, 2);
+  ASSERT_EQ(fieldNum, 2);
-//  int rowNum = taos_affected_rows(res);
+
-//  ASSERT_EQ(rowNum, 1);
+  TAOS_ROW row = taos_fetch_row(res);
-//  for (int i = 0; i < rowNum; ++i) {
+  int64_t ts = *(int64_t*)row[0];
-//   TAOS_ROW rows = taos_fetch_row(res);
+  double c1 = *(double*)row[1];
-//  }
+  ASSERT_EQ(ts, 1479496100000);
+  ASSERT_EQ(c1, 42);
+
+  int rowNum = taos_affected_rows(res);
+  ASSERT_EQ(rowNum, 1);
+  taos_free_result(res);
+
+  // case 2
+  res = taos_query(taos, "show tables");
+  ASSERT_NE(res, nullptr);
+
+  row = taos_fetch_row(res);
+  rowNum = taos_affected_rows(res);
+  ASSERT_EQ(rowNum, 3);
   taos_free_result(res);
 
-//  res = taos_query(taos, "select * from t_6931529054e5637ca92c78a1ad441961");
-//  ASSERT_NE(res, nullptr);
-//  fieldNum = taos_field_count(res);
-//  ASSERT_EQ(fieldNum, 2);
-//  rowNum = taos_affected_rows(res);
-//  ASSERT_EQ(rowNum, 2);
-//  for (int i = 0; i < rowNum; ++i) {
-//   TAOS_ROW rows = taos_fetch_row(res);
-//  }
-//  taos_free_result(res);
   destroyRequest(request);
   smlDestroyInfo(info);
 }
@@ -634,16 +712,16 @@ TEST(testCase, smlProcess_json1_Test) {
   TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(taos, nullptr);
 
-  TAOS_RES *pRes = taos_query(taos, "create database if not exists sml_db");
+  TAOS_RES *pRes = taos_query(taos, "create database if not exists json_db");
   taos_free_result(pRes);
 
-  pRes = taos_query(taos, "use sml_db");
+  pRes = taos_query(taos, "use json_db");
   taos_free_result(pRes);
 
   SRequestObj *request = (SRequestObj *)createRequest((STscObj *)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
 
   const char *sql =
@@ -670,16 +748,31 @@ TEST(testCase, smlProcess_json1_Test) {
   int ret = smlProcess(info, (char **)(&sql), -1);
   ASSERT_EQ(ret, 0);
 
+  // case 1
   TAOS_RES *res = taos_query(taos, "select * from t_cb27a7198d637b4f1c6464bd73f756a7");
   ASSERT_NE(res, nullptr);
   int fieldNum = taos_field_count(res);
   ASSERT_EQ(fieldNum, 2);
-  //   int rowNum = taos_affected_rows(res);
+
-  //   ASSERT_EQ(rowNum, 1);
+  TAOS_ROW row = taos_fetch_row(res);
-  //   for (int i = 0; i < rowNum; ++i) {
+  int64_t ts = *(int64_t*)row[0];
-  //     TAOS_ROW rows = taos_fetch_row(res);
+  double c1 = *(double*)row[1];
-  //   }
+  ASSERT_EQ(ts, 1346846400000);
+  ASSERT_EQ(c1, 18);
+
+  int rowNum = taos_affected_rows(res);
+  ASSERT_EQ(rowNum, 1);
   taos_free_result(res);
+
+  // case 2
+  res = taos_query(taos, "show tables");
+  ASSERT_NE(res, nullptr);
+
+  row = taos_fetch_row(res);
+  rowNum = taos_affected_rows(res);
+  ASSERT_EQ(rowNum, 2);
+  taos_free_result(res);
+
   destroyRequest(request);
   smlDestroyInfo(info);
 }
@@ -697,7 +790,7 @@ TEST(testCase, smlProcess_json2_Test) {
   SRequestObj *request = (SRequestObj *)createRequest((STscObj *)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
   const char *sql =
      "{\n"
@@ -741,7 +834,7 @@ TEST(testCase, smlProcess_json3_Test) {
   SRequestObj *request = (SRequestObj *)createRequest((STscObj *)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
   const char *sql =
      "{\n"
@@ -813,7 +906,7 @@ TEST(testCase, smlProcess_json4_Test) {
   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
   const char *sql = "{\n"
      "    \"metric\": \"meter_current2\",\n"
@@ -875,7 +968,7 @@ TEST(testCase, smlParseTelnetLine_error_Test) {
   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
 
   int32_t ret = 0;
@@ -924,7 +1017,7 @@ TEST(testCase, smlParseTelnetLine_diff_type_Test) {
   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
 
   const char *sql[2] = {
@@ -951,7 +1044,7 @@ TEST(testCase, smlParseTelnetLine_json_error_Test) {
   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
 
   int32_t ret = 0;
@@ -1019,7 +1112,7 @@ TEST(testCase, smlParseTelnetLine_diff_json_type1_Test) {
   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
 
   const char *sql[2] = {
@@ -1064,7 +1157,7 @@ TEST(testCase, smlParseTelnetLine_diff_json_type2_Test) {
   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
-  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS);
   ASSERT_NE(info, nullptr);
 
   const char *sql[2] = {

source/common/src/tglobal.c

@@ -30,6 +30,7 @@ char     tsLocalEp[TSDB_EP_LEN] = {0};  // Local End Point, hostname:port
 uint16_t tsServerPort = 6030;
 int32_t  tsVersion = 30000000;
 int32_t  tsStatusInterval = 1;  // second
+int32_t  tsNumOfSupportVnodes = 256;
 
 // common
 int32_t tsMaxShellConns = 50000;
@@ -38,7 +39,7 @@ bool    tsEnableSlaveQuery = true;
 bool    tsPrintAuth = false;
 
 // multi process
-bool    tsMultiProcess = false;
+int32_t tsMultiProcess = 0;
 int32_t tsMnodeShmSize = TSDB_MAX_WAL_SIZE * 2 + 128;
 int32_t tsVnodeShmSize = TSDB_MAX_WAL_SIZE * 10 + 128;
 int32_t tsQnodeShmSize = TSDB_MAX_WAL_SIZE * 4 + 128;
@@ -76,6 +77,11 @@ int32_t  tsTelemInterval = 86400;
 char     tsTelemServer[TSDB_FQDN_LEN] = "telemetry.taosdata.com";
 uint16_t tsTelemPort = 80;
 
+// schemaless
+char tsSmlChildTableName[TSDB_TABLE_NAME_LEN] = ""; //user defined child table name can be specified in tag value.
+                                                     //If set to empty system will generate table name using MD5 hash.
+bool tsSmlDataFormat = true;  // true means that the name and order of cols in each line are the same(only for influx protocol)
+
 // query
 int32_t tsQueryPolicy = 1;
 
@@ -319,6 +325,8 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
   if (cfgAddInt32(pCfg, "compressColData", tsCompressColData, -1, 100000000, 1) != 0) return -1;
   if (cfgAddBool(pCfg, "keepColumnName", tsKeepOriginalColumnName, 1) != 0) return -1;
   if (cfgAddInt32(pCfg, "queryPolicy", tsQueryPolicy, 1, 3, 1) != 0) return -1;
+  if (cfgAddString(pCfg, "smlChildTableName", "", 1) != 0) return -1;
+  if (cfgAddBool(pCfg, "smlDataFormat", tsSmlDataFormat, 1) != 0) return -1;
 
   tsNumOfTaskQueueThreads = tsNumOfCores / 4;
   tsNumOfTaskQueueThreads = TRANGE(tsNumOfTaskQueueThreads, 1, 2);
@@ -355,7 +363,7 @@ static int32_t taosAddSystemCfg(SConfig *pCfg) {
 static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddDir(pCfg, "dataDir", tsDataDir, 0) != 0) return -1;
   if (cfgAddFloat(pCfg, "minimalDataDirGB", 2.0f, 0.001f, 10000000, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "supportVnodes", 256, 0, 4096, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "supportVnodes", tsNumOfSupportVnodes, 0, 4096, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxShellConns", tsMaxShellConns, 10, 50000000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "statusInterval", tsStatusInterval, 1, 30, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "minSlidingTime", tsMinSlidingTime, 10, 1000000, 0) != 0) return -1;
@@ -371,7 +379,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddBool(pCfg, "slaveQuery", tsEnableSlaveQuery, 0) != 0) return -1;
   if (cfgAddBool(pCfg, "deadLockKillQuery", tsDeadLockKillQuery, 0) != 0) return -1;
 
-  if (cfgAddBool(pCfg, "multiProcess", tsMultiProcess, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "multiProcess", tsMultiProcess, 0, 2, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "mnodeShmSize", tsMnodeShmSize, TSDB_MAX_WAL_SIZE + 128, INT32_MAX, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "vnodeShmSize", tsVnodeShmSize, TSDB_MAX_WAL_SIZE + 128, INT32_MAX, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "qnodeShmSize", tsQnodeShmSize, TSDB_MAX_WAL_SIZE + 128, INT32_MAX, 0) != 0) return -1;
@@ -433,7 +441,8 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
 
   tsRpcQueueMemoryAllowed = tsTotalMemoryKB * 1024 * 0.1;
   tsRpcQueueMemoryAllowed = TRANGE(tsRpcQueueMemoryAllowed, TSDB_MAX_WAL_SIZE * 10L, TSDB_MAX_WAL_SIZE * 10000L);
-  if (cfgAddInt64(pCfg, "rpcQueueMemoryAllowed", tsRpcQueueMemoryAllowed, 1, INT64_MAX, 0) != 0) return -1;
+  if (cfgAddInt64(pCfg, "rpcQueueMemoryAllowed", tsRpcQueueMemoryAllowed, TSDB_MAX_WAL_SIZE * 10L, INT64_MAX, 0) != 0)
+    return -1;
 
   if (cfgAddBool(pCfg, "monitor", tsEnableMonitor, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "monitorInterval", tsMonitorInterval, 1, 200000, 0) != 0) return -1;
@@ -512,6 +521,9 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
     return -1;
   }
 
+  tstrncpy(tsSmlChildTableName, cfgGetItem(pCfg, "smlChildTableName")->str, TSDB_TABLE_NAME_LEN);
+  tsSmlDataFormat = cfgGetItem(pCfg, "smlDataFormat")->bval;
+
   tsShellActivityTimer = cfgGetItem(pCfg, "shellActivityTimer")->i32;
   tsCompressMsgSize = cfgGetItem(pCfg, "compressMsgSize")->i32;
   tsCompressColData = cfgGetItem(pCfg, "compressColData")->i32;
@@ -541,6 +553,7 @@ static void taosSetSystemCfg(SConfig *pCfg) {
 
 static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsDataSpace.reserved = cfgGetItem(pCfg, "minimalDataDirGB")->fval;
+  tsNumOfSupportVnodes = cfgGetItem(pCfg, "supportVnodes")->i32;
   tsMaxShellConns = cfgGetItem(pCfg, "maxShellConns")->i32;
   tsStatusInterval = cfgGetItem(pCfg, "statusInterval")->i32;
   tsMinSlidingTime = cfgGetItem(pCfg, "minSlidingTime")->i32;
@@ -554,7 +567,7 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsRetrieveBlockingModel = cfgGetItem(pCfg, "retrieveBlockingModel")->bval;
   tsPrintAuth = cfgGetItem(pCfg, "printAuth")->bval;
   tsEnableSlaveQuery = cfgGetItem(pCfg, "slaveQuery")->bval;
-  tsDeadLockKillQuery = cfgGetItem(pCfg, "deadLockKillQuery")->bval;
+  tsDeadLockKillQuery = cfgGetItem(pCfg, "deadLockKillQuery")->i32;
 
   tsMultiProcess = cfgGetItem(pCfg, "multiProcess")->bval;
   tsMnodeShmSize = cfgGetItem(pCfg, "mnodeShmSize")->i32;

source/common/src/tmsg.c

@@ -4171,19 +4171,20 @@ int32_t tEncodeSVAlterTbReq(SEncoder *pEncoder, const SVAlterTbReq *pReq) {
   if (tEncodeI8(pEncoder, pReq->action) < 0) return -1;
   switch (pReq->action) {
     case TSDB_ALTER_TABLE_ADD_COLUMN:
+      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
       if (tEncodeI8(pEncoder, pReq->type) < 0) return -1;
+      if (tEncodeI8(pEncoder, pReq->flags) < 0) return -1;
       if (tEncodeI32v(pEncoder, pReq->bytes) < 0) return -1;
-      if (tEncodeCStr(pEncoder, pReq->colAddName) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_DROP_COLUMN:
-      if (tEncodeCStr(pEncoder, pReq->colDropName) < 0) return -1;
+      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
-      if (tEncodeCStr(pEncoder, pReq->colModName) < 0) return -1;
+      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
       if (tEncodeI32v(pEncoder, pReq->colModBytes) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:
-      if (tEncodeCStr(pEncoder, pReq->colOldName) < 0) return -1;
+      if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
       if (tEncodeCStr(pEncoder, pReq->colNewName) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:
@@ -4218,19 +4219,20 @@ int32_t tDecodeSVAlterTbReq(SDecoder *pDecoder, SVAlterTbReq *pReq) {
   if (tDecodeI8(pDecoder, &pReq->action) < 0) return -1;
   switch (pReq->action) {
     case TSDB_ALTER_TABLE_ADD_COLUMN:
+      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
       if (tDecodeI8(pDecoder, &pReq->type) < 0) return -1;
+      if (tDecodeI8(pDecoder, &pReq->flags) < 0) return -1;
       if (tDecodeI32v(pDecoder, &pReq->bytes) < 0) return -1;
-      if (tDecodeCStr(pDecoder, &pReq->colAddName) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_DROP_COLUMN:
-      if (tDecodeCStr(pDecoder, &pReq->colDropName) < 0) return -1;
+      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
-      if (tDecodeCStr(pDecoder, &pReq->colModName) < 0) return -1;
+      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
       if (tDecodeI32v(pDecoder, &pReq->colModBytes) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:
-      if (tDecodeCStr(pDecoder, &pReq->colOldName) < 0) return -1;
+      if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
       if (tDecodeCStr(pDecoder, &pReq->colNewName) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:

source/common/src/tmsgcb.c

@@ -19,92 +19,44 @@
 
 static SMsgCb tsDefaultMsgCb;
 
-void tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb) {
+void tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb) { tsDefaultMsgCb = *pMsgCb; }
-  // if (tsDefaultMsgCb.pWrapper == NULL) {
-  tsDefaultMsgCb = *pMsgCb;
-  //}
-}
 
 int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq) {
   PutToQueueFp fp = pMsgCb->queueFps[qtype];
-  if (fp != NULL) {
+  return (*fp)(pMsgCb->mgmt, pReq);
-    return (*fp)(pMsgCb->pMgmt, pReq);
-  } else {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return -1;
-  }
 }
 
 int32_t tmsgGetQueueSize(const SMsgCb* pMsgCb, int32_t vgId, EQueueType qtype) {
   GetQueueSizeFp fp = pMsgCb->qsizeFp;
-  if (fp != NULL) {
+  return (*fp)(pMsgCb->mgmt, vgId, qtype);
-    return (*fp)(pMsgCb->pMgmt, vgId, qtype);
-  } else {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return -1;
-  }
 }
 
-int32_t tmsgSendReq(const SMsgCb* pMsgCb, const SEpSet* epSet, SRpcMsg* pReq) {
+int32_t tmsgSendReq(const SEpSet* epSet, SRpcMsg* pReq) {
-  SendReqFp fp = pMsgCb->sendReqFp;
+  SendReqFp fp = tsDefaultMsgCb.sendReqFp;
-  if (fp != NULL) {
+  return (*fp)(epSet, pReq);
-    return (*fp)(pMsgCb->pWrapper, epSet, pReq);
-  } else {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return -1;
-  }
 }
 
-void tmsgSendRsp(SRpcMsg* pRsp) {
+void tmsgSendRsp(const SRpcMsg* pMsg) {
   SendRspFp fp = tsDefaultMsgCb.sendRspFp;
-  if (fp != NULL) {
+  return (*fp)(pMsg);
-    return (*fp)(tsDefaultMsgCb.pWrapper, pRsp);
-  } else {
-    terrno = TSDB_CODE_INVALID_PTR;
-  }
 }
 
-void tmsgSendRedirectRsp(SRpcMsg* pRsp, const SEpSet* pNewEpSet) {
+void tmsgSendRedirectRsp(const SRpcMsg* pMsg, const SEpSet* pNewEpSet) {
   SendRedirectRspFp fp = tsDefaultMsgCb.sendRedirectRspFp;
-  if (fp != NULL) {
+  (*fp)(pMsg, pNewEpSet);
-    (*fp)(tsDefaultMsgCb.pWrapper, pRsp, pNewEpSet);
-  } else {
-    terrno = TSDB_CODE_INVALID_PTR;
-  }
 }
 
-void tmsgSendMnodeRecv(SRpcMsg* pReq, SRpcMsg* pRsp) {
+void tmsgRegisterBrokenLinkArg(SRpcMsg* pMsg) {
-  SendMnodeRecvFp fp = tsDefaultMsgCb.sendMnodeRecvFp;
+  RegisterBrokenLinkArgFp fp = tsDefaultMsgCb.registerBrokenLinkArgFp;
-  if (fp != NULL) {
+  (*fp)(pMsg);
-    (*fp)(tsDefaultMsgCb.pWrapper, pReq, pRsp);
-  } else {
-    terrno = TSDB_CODE_INVALID_PTR;
-  }
 }
 
-void tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg) {
+void tmsgReleaseHandle(SRpcHandleInfo* pHandle, int8_t type) {
-  RegisterBrokenLinkArgFp fp = pMsgCb->registerBrokenLinkArgFp;
-  if (fp != NULL) {
-    (*fp)(pMsgCb->pWrapper, pMsg);
-  } else {
-    terrno = TSDB_CODE_INVALID_PTR;
-  }
-}
-
-void tmsgReleaseHandle(void* handle, int8_t type) {
   ReleaseHandleFp fp = tsDefaultMsgCb.releaseHandleFp;
-  if (fp != NULL) {
+  (*fp)(pHandle, type);
-    (*fp)(tsDefaultMsgCb.pWrapper, handle, type);
-  } else {
-    terrno = TSDB_CODE_INVALID_PTR;
-  }
 }
 
 void tmsgReportStartup(const char* name, const char* desc) {
   ReportStartup fp = tsDefaultMsgCb.reportStartupFp;
-  if (fp != NULL && tsDefaultMsgCb.pWrapper != NULL) {
+  (*fp)(name, desc);
-    (*fp)(tsDefaultMsgCb.pWrapper, name, desc);
-  } else {
-    terrno = TSDB_CODE_INVALID_PTR;
-  }
 }

source/dnode/mgmt/exe/dmMain.c

@@ -36,16 +36,10 @@ static struct {
   char         apolloUrl[PATH_MAX];
   const char **envCmd;
   SArray      *pArgs;  // SConfigPair
-  SDnode      *pDnode;
   EDndNodeType ntype;
 } global = {0};
 
-static void dmStopDnode(int signum, void *info, void *ctx) {
+static void dmStopDnode(int signum, void *info, void *ctx) { dmStop(); }
-  SDnode *pDnode = atomic_val_compare_exchange_ptr(&global.pDnode, 0, global.pDnode);
-  if (pDnode != NULL) {
-    dmSetEvent(pDnode, DND_EVENT_STOP);
-  }
-}
 
 static void dmSetSignalHandle() {
   taosSetSignal(SIGTERM, dmStopDnode);
@@ -102,7 +96,8 @@ static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
     } else if (strcmp(argv[i], "-e") == 0) {
       global.envCmd[cmdEnvIndex] = argv[++i];
       cmdEnvIndex++;
-    } else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "--usage") == 0 || strcmp(argv[i], "-?")) {
+    } else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "--usage") == 0 ||
+               strcmp(argv[i], "-?")) {
       global.printHelp = true;
     } else {
     }
@@ -144,23 +139,6 @@ static void dmDumpCfg() {
   cfgDumpCfg(pCfg, 0, true);
 }
 
-static SDnodeOpt dmGetOpt() {
-  SConfig  *pCfg = taosGetCfg();
-  SDnodeOpt option = {0};
-
-  option.numOfSupportVnodes = cfgGetItem(pCfg, "supportVnodes")->i32;
-  tstrncpy(option.dataDir, tsDataDir, sizeof(option.dataDir));
-  tstrncpy(option.firstEp, tsFirst, sizeof(option.firstEp));
-  tstrncpy(option.secondEp, tsSecond, sizeof(option.firstEp));
-  option.serverPort = tsServerPort;
-  tstrncpy(option.localFqdn, tsLocalFqdn, sizeof(option.localFqdn));
-  snprintf(option.localEp, sizeof(option.localEp), "%s:%u", option.localFqdn, option.serverPort);
-  option.disks = tsDiskCfg;
-  option.numOfDisks = tsDiskCfgNum;
-  option.ntype = global.ntype;
-  return option;
-}
-
 static int32_t dmInitLog() {
   char logName[12] = {0};
   snprintf(logName, sizeof(logName), "%slog", dmNodeLogName(global.ntype));
@@ -175,34 +153,6 @@ static void dmSetProcInfo(int32_t argc, char **argv) {
   }
 }
 
-static int32_t dmRunDnode() {
-  if (dmInit() != 0) {
-    dError("failed to init environment since %s", terrstr());
-    return -1;
-  }
-
-  SDnodeOpt option = dmGetOpt();
-  SDnode   *pDnode = dmCreate(&option);
-  if (pDnode == NULL) {
-    dError("failed to to create dnode since %s", terrstr());
-    return -1;
-  } else {
-    global.pDnode = pDnode;
-    dmSetSignalHandle();
-  }
-
-  dInfo("start the service");
-  int32_t code = dmRun(pDnode);
-  dInfo("start shutting down the service");
-
-  global.pDnode = NULL;
-  dmClose(pDnode);
-  dmCleanup();
-  taosCloseLog();
-  taosCleanupCfg();
-  return code;
-}
-
 static void taosCleanupArgs() {
   if (global.envCmd != NULL) taosMemoryFree(global.envCmd);
 }
@@ -259,5 +209,17 @@ int main(int argc, char const *argv[]) {
 
   dmSetProcInfo(argc, (char **)argv);
   taosCleanupArgs();
-  return dmRunDnode();
+
+  if (dmInit(global.ntype) != 0) {
+    dError("failed to init dnode since %s", terrstr());
+    return -1;
+  }
+
+  dInfo("start to run dnode");
+  dmSetSignalHandle();
+  int32_t code = dmRun();
+  dInfo("shutting down the service");
+
+  dmCleanup();
+  return code;
 }

source/dnode/mgmt/mgmt_bnode/inc/bmInt.h

@@ -25,26 +25,26 @@ extern "C" {
 #endif
 
 typedef struct SBnodeMgmt {
+  SDnodeData   *pData;
   SBnode       *pBnode;
   SMsgCb        msgCb;
   const char   *path;
   const char   *name;
-  int32_t       dnodeId;
   SMultiWorker  writeWorker;
   SSingleWorker monitorWorker;
 } SBnodeMgmt;
 
 // bmHandle.c
 SArray *bmGetMsgHandles();
-int32_t bmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg);
+int32_t bmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pReq);
-int32_t bmProcessDropReq(SBnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t bmProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pReq);
-int32_t bmProcessGetMonBmInfoReq(SBnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t bmProcessGetMonBmInfoReq(SBnodeMgmt *pMgmt, SRpcMsg *pReq);
 
 // bmWorker.c
 int32_t bmStartWorker(SBnodeMgmt *pMgmt);
 void    bmStopWorker(SBnodeMgmt *pMgmt);
-int32_t bmPutNodeMsgToWriteQueue(SBnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t bmPutNodeMsgToWriteQueue(SBnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t bmPutNodeMsgToMonitorQueue(SBnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t bmPutNodeMsgToMonitorQueue(SBnodeMgmt *pMgmt, SRpcMsg *pMsg);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_bnode/src/bmHandle.c

@@ -18,7 +18,7 @@
 
 static void bmGetMonitorInfo(SBnodeMgmt *pMgmt, SMonBmInfo *bmInfo) {}
 
-int32_t bmProcessGetMonBmInfoReq(SBnodeMgmt *pMgmt, SNodeMsg *pReq) {
+int32_t bmProcessGetMonBmInfoReq(SBnodeMgmt *pMgmt, SRpcMsg *pReq) {
   SMonBmInfo bmInfo = {0};
   bmGetMonitorInfo(pMgmt, &bmInfo);
   dmGetMonitorSystemInfo(&bmInfo.sys);
@@ -37,14 +37,14 @@ int32_t bmProcessGetMonBmInfoReq(SBnodeMgmt *pMgmt, SNodeMsg *pReq) {
   }
 
   tSerializeSMonBmInfo(pRsp, rspLen, &bmInfo);
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = rspLen;
+  pReq->info.rspLen = rspLen;
   tFreeSMonBmInfo(&bmInfo);
   return 0;
 }
 
-int32_t bmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
+int32_t bmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) {
-  SRpcMsg *pReq = &pMsg->rpcMsg;
+  SRpcMsg *pReq = pMsg;
 
   SDCreateBnodeReq createReq = {0};
   if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
@@ -52,9 +52,9 @@ int32_t bmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pInput->dnodeId != 0 && createReq.dnodeId != pInput->dnodeId) {
+  if (pInput->pData->dnodeId != 0 && createReq.dnodeId != pInput->pData->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
-    dError("failed to create bnode since %s, input:%d cur:%d", terrstr(), createReq.dnodeId, pInput->dnodeId);
+    dError("failed to create bnode since %s, input:%d cur:%d", terrstr(), createReq.dnodeId, pInput->pData->dnodeId);
     return -1;
   }
 
@@ -67,8 +67,8 @@ int32_t bmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t bmProcessDropReq(SBnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t bmProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) {
-  SRpcMsg *pReq = &pMsg->rpcMsg;
+  SRpcMsg *pReq = pMsg;
 
   SDDropBnodeReq dropReq = {0};
   if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
@@ -76,14 +76,14 @@ int32_t bmProcessDropReq(SBnodeMgmt *pMgmt, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pMgmt->dnodeId != 0 && dropReq.dnodeId != pMgmt->dnodeId) {
+  if (pInput->pData->dnodeId != 0 && dropReq.dnodeId != pInput->pData->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to drop bnode since %s", terrstr());
     return -1;
   }
 
   bool deployed = false;
-  if (dmWriteFile(pMgmt->path, pMgmt->name, deployed) != 0) {
+  if (dmWriteFile(pInput->path, pInput->name, deployed) != 0) {
     dError("failed to write bnode file since %s", terrstr());
     return -1;
   }

source/dnode/mgmt/mgmt_bnode/src/bmInt.c

@@ -23,7 +23,6 @@ static int32_t bmRequire(const SMgmtInputOpt *pInput, bool *required) {
 static void bmInitOption(SBnodeMgmt *pMgmt, SBnodeOpt *pOption) { pOption->msgCb = pMgmt->msgCb; }
 
 static void bmClose(SBnodeMgmt *pMgmt) {
-  dInfo("bnode-mgmt start to cleanup");
   if (pMgmt->pBnode != NULL) {
     bmStopWorker(pMgmt);
     bndClose(pMgmt->pBnode);
@@ -31,22 +30,20 @@ static void bmClose(SBnodeMgmt *pMgmt) {
   }
 
   taosMemoryFree(pMgmt);
-  dInfo("bnode-mgmt is cleaned up");
 }
 
-int32_t bmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
+int32_t bmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
-  dInfo("bnode-mgmt start to init");
   SBnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SBnodeMgmt));
   if (pMgmt == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
 
+  pMgmt->pData = pInput->pData;
   pMgmt->path = pInput->path;
   pMgmt->name = pInput->name;
-  pMgmt->dnodeId = pInput->dnodeId;
   pMgmt->msgCb = pInput->msgCb;
-  pMgmt->msgCb.pMgmt = pMgmt;
+  pMgmt->msgCb.mgmt = pMgmt;
 
   SBnodeOpt option = {0};
   bmInitOption(pMgmt, &option);
@@ -66,7 +63,6 @@ int32_t bmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   tmsgReportStartup("bnode-worker", "initialized");
 
   pOutput->pMgmt = pMgmt;
-  dInfo("bnode-mgmt is initialized");
   return 0;
 }
 

source/dnode/mgmt/mgmt_bnode/src/bmWorker.c

@@ -16,23 +16,18 @@
 #define _DEFAULT_SOURCE
 #include "bmInt.h"
 
-static void bmSendErrorRsp(SNodeMsg *pMsg, int32_t code) {
+static void bmSendErrorRsp(SRpcMsg *pMsg, int32_t code) {
-  SRpcMsg rpcRsp = {
+  SRpcMsg rsp = {.code = code, .info = pMsg->info};
-      .handle = pMsg->rpcMsg.handle,
+  tmsgSendRsp(&rsp);
-      .ahandle = pMsg->rpcMsg.ahandle,
-      .code = code,
-      .refId = pMsg->rpcMsg.refId,
-  };
-  tmsgSendRsp(&rpcRsp);
 
   dTrace("msg:%p, is freed", pMsg);
-  rpcFreeCont(pMsg->rpcMsg.pCont);
+  rpcFreeCont(pMsg->pCont);
   taosFreeQitem(pMsg);
 }
 
 static void bmSendErrorRsps(STaosQall *qall, int32_t numOfMsgs, int32_t code) {
   for (int32_t i = 0; i < numOfMsgs; ++i) {
-    SNodeMsg *pMsg = NULL;
+    SRpcMsg *pMsg = NULL;
     taosGetQitem(qall, (void **)&pMsg);
     if (pMsg != NULL) {
       bmSendErrorRsp(pMsg, code);
@@ -40,24 +35,24 @@ static void bmSendErrorRsps(STaosQall *qall, int32_t numOfMsgs, int32_t code) {
   }
 }
 
-static inline void bmSendRsp(SNodeMsg *pMsg, int32_t code) {
+static inline void bmSendRsp(SRpcMsg *pMsg, int32_t code) {
-  SRpcMsg rsp = {.handle = pMsg->rpcMsg.handle,
+  SRpcMsg rsp = {
-                 .ahandle = pMsg->rpcMsg.ahandle,
-                 .refId = pMsg->rpcMsg.refId,
       .code = code,
-                 .pCont = pMsg->pRsp,
+      .info = pMsg->info,
-                 .contLen = pMsg->rspLen};
+      .pCont = pMsg->info.rsp,
+      .contLen = pMsg->info.rspLen,
+  };
   tmsgSendRsp(&rsp);
 }
 
-static void bmProcessMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void bmProcessMonitorQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SBnodeMgmt *pMgmt = pInfo->ahandle;
 
   dTrace("msg:%p, get from bnode-monitor queue", pMsg);
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
+  SRpcMsg *pRpc = pMsg;
   int32_t  code = -1;
 
-  if (pMsg->rpcMsg.msgType == TDMT_MON_BM_INFO) {
+  if (pMsg->msgType == TDMT_MON_BM_INFO) {
     code = bmProcessGetMonBmInfoReq(pMgmt, pMsg);
   } else {
     terrno = TSDB_CODE_MSG_NOT_PROCESSED;
@@ -76,14 +71,14 @@ static void bmProcessMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
 static void bmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
   SBnodeMgmt *pMgmt = pInfo->ahandle;
 
-  SArray *pArray = taosArrayInit(numOfMsgs, sizeof(SNodeMsg *));
+  SArray *pArray = taosArrayInit(numOfMsgs, sizeof(SRpcMsg *));
   if (pArray == NULL) {
     bmSendErrorRsps(qall, numOfMsgs, TSDB_CODE_OUT_OF_MEMORY);
     return;
   }
 
   for (int32_t i = 0; i < numOfMsgs; ++i) {
-    SNodeMsg *pMsg = NULL;
+    SRpcMsg *pMsg = NULL;
     taosGetQitem(qall, (void **)&pMsg);
     if (pMsg != NULL) {
       dTrace("msg:%p, get from bnode-write queue", pMsg);
@@ -96,17 +91,17 @@ static void bmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
   bndProcessWMsgs(pMgmt->pBnode, pArray);
 
   for (size_t i = 0; i < numOfMsgs; i++) {
-    SNodeMsg *pMsg = *(SNodeMsg **)taosArrayGet(pArray, i);
+    SRpcMsg *pMsg = *(SRpcMsg **)taosArrayGet(pArray, i);
     if (pMsg != NULL) {
       dTrace("msg:%p, is freed", pMsg);
-      rpcFreeCont(pMsg->rpcMsg.pCont);
+      rpcFreeCont(pMsg->pCont);
       taosFreeQitem(pMsg);
     }
   }
   taosArrayDestroy(pArray);
 }
 
-int32_t bmPutNodeMsgToWriteQueue(SBnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t bmPutNodeMsgToWriteQueue(SBnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SMultiWorker *pWorker = &pMgmt->writeWorker;
 
   dTrace("msg:%p, put into worker:%s", pMsg, pWorker->name);
@@ -114,7 +109,7 @@ int32_t bmPutNodeMsgToWriteQueue(SBnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t bmPutNodeMsgToMonitorQueue(SBnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t bmPutNodeMsgToMonitorQueue(SBnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SSingleWorker *pWorker = &pMgmt->monitorWorker;
 
   dTrace("msg:%p, put into worker:%s", pMsg, pWorker->name);

source/dnode/mgmt/mgmt_dnode/inc/dmInt.h

@@ -23,7 +23,7 @@ extern "C" {
 #endif
 
 typedef struct SDnodeMgmt {
-  struct SDnode      *pDnode;
+  SDnodeData         *pData;
   SMsgCb              msgCb;
   const char         *path;
   const char         *name;
@@ -32,22 +32,16 @@ typedef struct SDnodeMgmt {
   SSingleWorker       mgmtWorker;
   ProcessCreateNodeFp processCreateNodeFp;
   ProcessDropNodeFp   processDropNodeFp;
-  IsNodeDeployedFp    isNodeDeployedFp;
+  IsNodeRequiredFp    isNodeRequiredFp;
-  SDnodeData          data;
 } SDnodeMgmt;
 
-// dmEps.c
-int32_t dmReadEps(SDnodeMgmt *pMgmt);
-int32_t dmWriteEps(SDnodeMgmt *pMgmt);
-void    dmUpdateEps(SDnodeMgmt *pMgmt, SArray *pDnodeEps);
-
 // dmHandle.c
 SArray *dmGetMsgHandles();
 void    dmSendStatusReq(SDnodeMgmt *pMgmt);
-int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t dmProcessServerRunStatus(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmProcessServerRunStatus(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
 
 // dmMonitor.c
 void dmGetVnodeLoads(SDnodeMgmt *pMgmt, SMonVloadInfo *pInfo);
@@ -55,7 +49,7 @@ void dmGetMnodeLoads(SDnodeMgmt *pMgmt, SMonMloadInfo *pInfo);
 void dmSendMonitorReport(SDnodeMgmt *pMgmt);
 
 // dmWorker.c
-int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t dmStartStatusThread(SDnodeMgmt *pMgmt);
 void    dmStopStatusThread(SDnodeMgmt *pMgmt);
 int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt);

source/dnode/mgmt/mgmt_dnode/src/dmHandle.c

@@ -17,30 +17,30 @@
 #include "dmInt.h"
 
 static void dmUpdateDnodeCfg(SDnodeMgmt *pMgmt, SDnodeCfg *pCfg) {
-  if (pMgmt->data.dnodeId == 0 || pMgmt->data.clusterId == 0) {
+  if (pMgmt->pData->dnodeId == 0 || pMgmt->pData->clusterId == 0) {
     dInfo("set dnodeId:%d clusterId:%" PRId64, pCfg->dnodeId, pCfg->clusterId);
-    taosWLockLatch(&pMgmt->data.latch);
+    taosWLockLatch(&pMgmt->pData->latch);
-    pMgmt->data.dnodeId = pCfg->dnodeId;
+    pMgmt->pData->dnodeId = pCfg->dnodeId;
-    pMgmt->data.clusterId = pCfg->clusterId;
+    pMgmt->pData->clusterId = pCfg->clusterId;
-    dmWriteEps(pMgmt);
+    dmWriteEps(pMgmt->pData);
-    taosWUnLockLatch(&pMgmt->data.latch);
+    taosWUnLockLatch(&pMgmt->pData->latch);
   }
 }
 
 static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) {
   if (pRsp->code != 0) {
-    if (pRsp->code == TSDB_CODE_MND_DNODE_NOT_EXIST && !pMgmt->data.dropped && pMgmt->data.dnodeId > 0) {
+    if (pRsp->code == TSDB_CODE_MND_DNODE_NOT_EXIST && !pMgmt->pData->dropped && pMgmt->pData->dnodeId > 0) {
-      dInfo("dnode:%d, set to dropped since not exist in mnode", pMgmt->data.dnodeId);
+      dInfo("dnode:%d, set to dropped since not exist in mnode", pMgmt->pData->dnodeId);
-      pMgmt->data.dropped = 1;
+      pMgmt->pData->dropped = 1;
-      dmWriteEps(pMgmt);
+      dmWriteEps(pMgmt->pData);
     }
   } else {
     SStatusRsp statusRsp = {0};
     if (pRsp->pCont != NULL && pRsp->contLen > 0 &&
         tDeserializeSStatusRsp(pRsp->pCont, pRsp->contLen, &statusRsp) == 0) {
-      pMgmt->data.dnodeVer = statusRsp.dnodeVer;
+      pMgmt->pData->dnodeVer = statusRsp.dnodeVer;
       dmUpdateDnodeCfg(pMgmt, &statusRsp.dnodeCfg);
-      dmUpdateEps(pMgmt, statusRsp.pDnodeEps);
+      dmUpdateEps(pMgmt->pData, statusRsp.pDnodeEps);
     }
     rpcFreeCont(pRsp->pCont);
     tFreeSStatusRsp(&statusRsp);
@@ -50,17 +50,17 @@ static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) {
 void dmSendStatusReq(SDnodeMgmt *pMgmt) {
   SStatusReq req = {0};
 
-  taosRLockLatch(&pMgmt->data.latch);
+  taosRLockLatch(&pMgmt->pData->latch);
   req.sver = tsVersion;
-  req.dnodeVer = pMgmt->data.dnodeVer;
+  req.dnodeVer = pMgmt->pData->dnodeVer;
-  req.dnodeId = pMgmt->data.dnodeId;
+  req.dnodeId = pMgmt->pData->dnodeId;
-  req.clusterId = pMgmt->data.clusterId;
+  req.clusterId = pMgmt->pData->clusterId;
   if (req.clusterId == 0) req.dnodeId = 0;
-  req.rebootTime = pMgmt->data.rebootTime;
+  req.rebootTime = pMgmt->pData->rebootTime;
-  req.updateTime = pMgmt->data.updateTime;
+  req.updateTime = pMgmt->pData->updateTime;
   req.numOfCores = tsNumOfCores;
-  req.numOfSupportVnodes = pMgmt->data.supportVnodes;
+  req.numOfSupportVnodes = tsNumOfSupportVnodes;
-  tstrncpy(req.dnodeEp, pMgmt->data.localEp, TSDB_EP_LEN);
+  tstrncpy(req.dnodeEp, tsLocalEp, TSDB_EP_LEN);
 
   req.clusterCfg.statusInterval = tsStatusInterval;
   req.clusterCfg.checkTime = 0;
@@ -69,53 +69,42 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
   memcpy(req.clusterCfg.timezone, tsTimezoneStr, TD_TIMEZONE_LEN);
   memcpy(req.clusterCfg.locale, tsLocale, TD_LOCALE_LEN);
   memcpy(req.clusterCfg.charset, tsCharset, TD_LOCALE_LEN);
-  taosRUnLockLatch(&pMgmt->data.latch);
+  taosRUnLockLatch(&pMgmt->pData->latch);
 
   SMonVloadInfo vinfo = {0};
   dmGetVnodeLoads(pMgmt, &vinfo);
   req.pVloads = vinfo.pVloads;
-  pMgmt->data.unsyncedVgId = 0;
-  pMgmt->data.vndState = TAOS_SYNC_STATE_LEADER;
-  for (int32_t i = 0; i < taosArrayGetSize(req.pVloads); ++i) {
-    SVnodeLoad *pLoad = taosArrayGet(req.pVloads, i);
-    if (pLoad->syncState != TAOS_SYNC_STATE_LEADER && pLoad->syncState != TAOS_SYNC_STATE_FOLLOWER) {
-      pMgmt->data.unsyncedVgId = pLoad->vgId;
-      pMgmt->data.vndState = pLoad->syncState;
-    }
-  }
 
   SMonMloadInfo minfo = {0};
   dmGetMnodeLoads(pMgmt, &minfo);
-  pMgmt->data.mndState = minfo.load.syncState;
 
   int32_t contLen = tSerializeSStatusReq(NULL, 0, &req);
   void   *pHead = rpcMallocCont(contLen);
   tSerializeSStatusReq(pHead, contLen, &req);
   tFreeSStatusReq(&req);
 
-  SRpcMsg rpcMsg = {.pCont = pHead, .contLen = contLen, .msgType = TDMT_MND_STATUS, .ahandle = (void *)0x9527};
+  SRpcMsg rpcMsg = {.pCont = pHead, .contLen = contLen, .msgType = TDMT_MND_STATUS, .info.ahandle = (void *)0x9527};
   SRpcMsg rpcRsp = {0};
 
-  dTrace("send req:%s to mnode, app:%p", TMSG_INFO(rpcMsg.msgType), rpcMsg.ahandle);
+  dTrace("send status msg to mnode, app:%p", rpcMsg.info.ahandle);
-  tmsgSendMnodeRecv(&rpcMsg, &rpcRsp);
+
+  SEpSet epSet = {0};
+  dmGetMnodeEpSet(pMgmt->pData, &epSet);
+  rpcSendRecv(pMgmt->msgCb.clientRpc, &epSet, &rpcMsg, &rpcRsp);
   dmProcessStatusRsp(pMgmt, &rpcRsp);
 }
 
-int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  SRpcMsg *pRsp = &pMsg->rpcMsg;
   dError("auth rsp is received, but not supported yet");
   return 0;
 }
 
-int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  SRpcMsg *pRsp = &pMsg->rpcMsg;
   dError("grant rsp is received, but not supported yet");
   return 0;
 }
 
-int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  SRpcMsg       *pReq = &pMsg->rpcMsg;
-  SDCfgDnodeReq *pCfg = pReq->pCont;
   dError("config req is received, but not supported yet");
   return TSDB_CODE_OPS_NOT_SUPPORT;
 }
@@ -149,12 +138,12 @@ static void dmGetServerRunStatus(SDnodeMgmt *pMgmt, SServerStatusRsp *pStatus) {
   taosArrayDestroy(vinfo.pVloads);
 }
 
-int32_t dmProcessServerRunStatus(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t dmProcessServerRunStatus(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   dDebug("server run status req is received");
   SServerStatusRsp statusRsp = {0};
   dmGetServerRunStatus(pMgmt, &statusRsp);
 
-  SRpcMsg rspMsg = {.handle = pMsg->rpcMsg.handle, .ahandle = pMsg->rpcMsg.ahandle, .refId = pMsg->rpcMsg.refId};
+  SRpcMsg rspMsg = {.info = pMsg->info};
   int32_t rspLen = tSerializeSServerStatusRsp(NULL, 0, &statusRsp);
   if (rspLen < 0) {
     rspMsg.code = TSDB_CODE_OUT_OF_MEMORY;
@@ -168,8 +157,8 @@ int32_t dmProcessServerRunStatus(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   }
 
   tSerializeSServerStatusRsp(pRsp, rspLen, &statusRsp);
-  pMsg->pRsp = pRsp;
+  pMsg->info.rsp = pRsp;
-  pMsg->rspLen = rspLen;
+  pMsg->info.rspLen = rspLen;
   return 0;
 }
 

source/dnode/mgmt/mgmt_dnode/src/dmInt.c

@@ -27,88 +27,41 @@ static int32_t dmStartMgmt(SDnodeMgmt *pMgmt) {
 }
 
 static void dmStopMgmt(SDnodeMgmt *pMgmt) {
-  pMgmt->data.stopped = true;
+  pMgmt->pData->stopped = true;
   dmStopMonitorThread(pMgmt);
   dmStopStatusThread(pMgmt);
 }
 
-static int32_t dmOpenMgmt(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
+static int32_t dmOpenMgmt(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
-  dInfo("dnode-mgmt start to init");
   SDnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SDnodeMgmt));
   if (pMgmt == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
 
-  pMgmt->data.dnodeId = 0;
+  pMgmt->pData = pInput->pData;
-  pMgmt->data.clusterId = 0;
-  pMgmt->data.dnodeVer = 0;
-  pMgmt->data.updateTime = 0;
-  pMgmt->data.rebootTime = taosGetTimestampMs();
-  pMgmt->data.dropped = 0;
-  pMgmt->data.localEp = pInput->localEp;
-  pMgmt->data.localFqdn = pInput->localFqdn;
-  pMgmt->data.firstEp = pInput->firstEp;
-  pMgmt->data.secondEp = pInput->secondEp;
-  pMgmt->data.supportVnodes = pInput->supportVnodes;
-  pMgmt->data.serverPort = pInput->serverPort;
-  pMgmt->pDnode = pInput->pDnode;
   pMgmt->msgCb = pInput->msgCb;
   pMgmt->path = pInput->path;
   pMgmt->name = pInput->name;
   pMgmt->processCreateNodeFp = pInput->processCreateNodeFp;
   pMgmt->processDropNodeFp = pInput->processDropNodeFp;
-  pMgmt->isNodeDeployedFp = pInput->isNodeDeployedFp;
+  pMgmt->isNodeRequiredFp = pInput->isNodeRequiredFp;
-  taosInitRWLatch(&pMgmt->data.latch);
-
-  pMgmt->data.dnodeHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
-  if (pMgmt->data.dnodeHash == NULL) {
-    dError("failed to init dnode hash");
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  if (dmReadEps(pMgmt) != 0) {
-    dError("failed to read file since %s", terrstr());
-    return -1;
-  }
-
-  if (pMgmt->data.dropped) {
-    dError("dnode will not start since its already dropped");
-    return -1;
-  }
 
   if (dmStartWorker(pMgmt) != 0) {
     return -1;
   }
 
-  if (udfStartUdfd(pMgmt->data.dnodeId) != 0) {
+  if (udfStartUdfd(pMgmt->pData->dnodeId) != 0) {
     dError("failed to start udfd");
   }
 
   pOutput->pMgmt = pMgmt;
-  pOutput->mnodeEps = pMgmt->data.mnodeEps;
-  dInfo("dnode-mgmt is initialized");
   return 0;
 }
 
 static void dmCloseMgmt(SDnodeMgmt *pMgmt) {
-  dInfo("dnode-mgmt start to clean up");
   dmStopWorker(pMgmt);
-
-  taosWLockLatch(&pMgmt->data.latch);
-  if (pMgmt->data.dnodeEps != NULL) {
-    taosArrayDestroy(pMgmt->data.dnodeEps);
-    pMgmt->data.dnodeEps = NULL;
-  }
-  if (pMgmt->data.dnodeHash != NULL) {
-    taosHashCleanup(pMgmt->data.dnodeHash);
-    pMgmt->data.dnodeHash = NULL;
-  }
-  taosWUnLockLatch(&pMgmt->data.latch);
   taosMemoryFree(pMgmt);
-
-  dInfo("dnode-mgmt is cleaned up");
 }
 
 static int32_t dmRequireMgmt(const SMgmtInputOpt *pInput, bool *required) {

source/dnode/mgmt/mgmt_dnode/src/dmMonitor.c

@@ -21,9 +21,8 @@
     SRpcMsg rsp = {0};                                       \
     SRpcMsg req = {.msgType = mtype};                        \
     SEpSet  epset = {.inUse = 0, .numOfEps = 1};             \
-    tstrncpy(epset.eps[0].fqdn, pMgmt->data.localFqdn, TSDB_FQDN_LEN); \
+    tstrncpy(epset.eps[0].fqdn, tsLocalFqdn, TSDB_FQDN_LEN); \
-    epset.eps[0].port = pMgmt->data.serverPort;                        \
+    epset.eps[0].port = tsServerPort;                        \
-                                                                       \
     rpcSendRecv(pMgmt->msgCb.clientRpc, &epset, &req, &rsp); \
     if (rsp.code == 0 && rsp.contLen > 0) {                  \
       func(rsp.pCont, rsp.contLen, pInfo);                   \
@@ -33,17 +32,17 @@
 
 static void dmGetMonitorBasicInfo(SDnodeMgmt *pMgmt, SMonBasicInfo *pInfo) {
   pInfo->protocol = 1;
-  pInfo->dnode_id = pMgmt->data.dnodeId;
+  pInfo->dnode_id = pMgmt->pData->dnodeId;
-  pInfo->cluster_id = pMgmt->data.clusterId;
+  pInfo->cluster_id = pMgmt->pData->clusterId;
   tstrncpy(pInfo->dnode_ep, tsLocalEp, TSDB_EP_LEN);
 }
 
 static void dmGetMonitorDnodeInfo(SDnodeMgmt *pMgmt, SMonDnodeInfo *pInfo) {
-  pInfo->uptime = (taosGetTimestampMs() - pMgmt->data.rebootTime) / (86400000.0f);
+  pInfo->uptime = (taosGetTimestampMs() - pMgmt->pData->rebootTime) / (86400000.0f);
-  pInfo->has_mnode = (*pMgmt->isNodeDeployedFp)(pMgmt->pDnode, MNODE);
+  pInfo->has_mnode = (*pMgmt->isNodeRequiredFp)(MNODE);
-  pInfo->has_qnode = (*pMgmt->isNodeDeployedFp)(pMgmt->pDnode, QNODE);
+  pInfo->has_qnode = (*pMgmt->isNodeRequiredFp)(QNODE);
-  pInfo->has_snode = (*pMgmt->isNodeDeployedFp)(pMgmt->pDnode, SNODE);
+  pInfo->has_snode = (*pMgmt->isNodeRequiredFp)(SNODE);
-  pInfo->has_bnode = (*pMgmt->isNodeDeployedFp)(pMgmt->pDnode, BNODE);
+  pInfo->has_bnode = (*pMgmt->isNodeRequiredFp)(BNODE);
   tstrncpy(pInfo->logdir.name, tsLogDir, sizeof(pInfo->logdir.name));
   pInfo->logdir.size = tsLogSpace.size;
   tstrncpy(pInfo->tempdir.name, tsTempDir, sizeof(pInfo->tempdir.name));

source/dnode/mgmt/mgmt_dnode/src/dmWorker.c

@@ -24,7 +24,7 @@ static void *dmStatusThreadFp(void *param) {
 
   while (1) {
     taosMsleep(200);
-    if (pMgmt->data.dropped || pMgmt->data.stopped) break;
+    if (pMgmt->pData->dropped || pMgmt->pData->stopped) break;
 
     int64_t curTime = taosGetTimestampMs();
     float   interval = (curTime - lastTime) / 1000.0f;
@@ -45,7 +45,7 @@ static void *dmMonitorThreadFp(void *param) {
 
   while (1) {
     taosMsleep(200);
-    if (pMgmt->data.dropped || pMgmt->data.stopped) break;
+    if (pMgmt->pData->dropped || pMgmt->pData->stopped) break;
 
     int64_t curTime = taosGetTimestampMs();
     float   interval = (curTime - lastTime) / 1000.0f;
@@ -98,10 +98,10 @@ void dmStopMonitorThread(SDnodeMgmt *pMgmt) {
   }
 }
 
-static void dmProcessMgmtQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void dmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SDnodeMgmt *pMgmt = pInfo->ahandle;
   int32_t     code = -1;
-  tmsg_t      msgType = pMsg->rpcMsg.msgType;
+  tmsg_t      msgType = pMsg->msgType;
   bool        isRequest = msgType & 1u;
   dTrace("msg:%p, will be processed in dnode-mgmt queue, type:%s", pMsg, TMSG_INFO(msgType));
 
@@ -116,28 +116,28 @@ static void dmProcessMgmtQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
       code = dmProcessGrantRsp(pMgmt, pMsg);
       break;
     case TDMT_DND_CREATE_MNODE:
-      code = (*pMgmt->processCreateNodeFp)(pMgmt->pDnode, MNODE, pMsg);
+      code = (*pMgmt->processCreateNodeFp)(MNODE, pMsg);
       break;
     case TDMT_DND_DROP_MNODE:
-      code = (*pMgmt->processDropNodeFp)(pMgmt->pDnode, MNODE, pMsg);
+      code = (*pMgmt->processDropNodeFp)(MNODE, pMsg);
       break;
     case TDMT_DND_CREATE_QNODE:
-      code = (*pMgmt->processCreateNodeFp)(pMgmt->pDnode, QNODE, pMsg);
+      code = (*pMgmt->processCreateNodeFp)(QNODE, pMsg);
       break;
     case TDMT_DND_DROP_QNODE:
-      code = (*pMgmt->processDropNodeFp)(pMgmt->pDnode, QNODE, pMsg);
+      code = (*pMgmt->processDropNodeFp)(QNODE, pMsg);
       break;
     case TDMT_DND_CREATE_SNODE:
-      code = (*pMgmt->processCreateNodeFp)(pMgmt->pDnode, SNODE, pMsg);
+      code = (*pMgmt->processCreateNodeFp)(SNODE, pMsg);
       break;
     case TDMT_DND_DROP_SNODE:
-      code = (*pMgmt->processDropNodeFp)(pMgmt->pDnode, SNODE, pMsg);
+      code = (*pMgmt->processDropNodeFp)(SNODE, pMsg);
       break;
     case TDMT_DND_CREATE_BNODE:
-      code = (*pMgmt->processCreateNodeFp)(pMgmt->pDnode, BNODE, pMsg);
+      code = (*pMgmt->processCreateNodeFp)(BNODE, pMsg);
       break;
     case TDMT_DND_DROP_BNODE:
-      code = (*pMgmt->processDropNodeFp)(pMgmt->pDnode, BNODE, pMsg);
+      code = (*pMgmt->processDropNodeFp)(BNODE, pMsg);
       break;
     case TDMT_DND_SERVER_STATUS:
       code = dmProcessServerRunStatus(pMgmt, pMsg);
@@ -150,18 +150,16 @@ static void dmProcessMgmtQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   if (isRequest) {
     if (code != 0 && terrno != 0) code = terrno;
     SRpcMsg rsp = {
-        .handle = pMsg->rpcMsg.handle,
-        .ahandle = pMsg->rpcMsg.ahandle,
         .code = code,
-        .refId = pMsg->rpcMsg.refId,
+        .info = pMsg->info,
-        .pCont = pMsg->pRsp,
+        .pCont = pMsg->info.rsp,
-        .contLen = pMsg->rspLen,
+        .contLen = pMsg->info.rspLen,
     };
     rpcSendResponse(&rsp);
   }
 
   dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-  rpcFreeCont(pMsg->rpcMsg.pCont);
+  rpcFreeCont(pMsg->pCont);
   taosFreeQitem(pMsg);
 }
 
@@ -187,7 +185,7 @@ void dmStopWorker(SDnodeMgmt *pMgmt) {
   dDebug("dnode workers are closed");
 }
 
-int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SSingleWorker *pWorker = &pMgmt->mgmtWorker;
   dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
   taosWriteQitem(pWorker->queue, pMsg);

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

@@ -24,11 +24,11 @@ extern "C" {
 #endif
 
 typedef struct SMnodeMgmt {
+  SDnodeData   *pData;
   SMnode       *pMnode;
   SMsgCb        msgCb;
   const char   *path;
   const char   *name;
-  int32_t       dnodeId;
   SSingleWorker queryWorker;
   SSingleWorker readWorker;
   SSingleWorker writeWorker;
@@ -48,20 +48,20 @@ int32_t mmAlter(SMnodeMgmt *pMgmt, SDAlterMnodeReq *pReq);
 
 // mmHandle.c
 SArray *mmGetMsgHandles();
-int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg);
+int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
-int32_t mmProcessDropReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
-int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmProcessGetMonitorInfoReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t mmProcessGetMonitorInfoReq(SMnodeMgmt *pMgmt, SRpcMsg *pReq);
-int32_t mmProcessGetLoadsReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t mmProcessGetLoadsReq(SMnodeMgmt *pMgmt, SRpcMsg *pReq);
 
 // mmWorker.c
 int32_t mmStartWorker(SMnodeMgmt *pMgmt);
 void    mmStopWorker(SMnodeMgmt *pMgmt);
-int32_t mmPutNodeMsgToWriteQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutNodeMsgToWriteQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmPutNodeMsgToSyncQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutNodeMsgToSyncQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmPutNodeMsgToReadQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutNodeMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmPutNodeMsgToQueryQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutNodeMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t mmPutNodeMsgToMonitorQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutNodeMsgToMonitorQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t mmPutRpcMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc);
 int32_t mmPutRpcMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc);
 int32_t mmPutRpcMsgToWriteQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc);

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

@@ -20,7 +20,7 @@ static void mmGetMonitorInfo(SMnodeMgmt *pMgmt, SMonMmInfo *mmInfo) {
   mndGetMonitorInfo(pMgmt->pMnode, &mmInfo->cluster, &mmInfo->vgroup, &mmInfo->grant);
 }
 
-int32_t mmProcessGetMonitorInfoReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq) {
+int32_t mmProcessGetMonitorInfoReq(SMnodeMgmt *pMgmt, SRpcMsg *pReq) {
   SMonMmInfo mmInfo = {0};
   mmGetMonitorInfo(pMgmt, &mmInfo);
   dmGetMonitorSystemInfo(&mmInfo.sys);
@@ -39,8 +39,8 @@ int32_t mmProcessGetMonitorInfoReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq) {
   }
 
   tSerializeSMonMmInfo(pRsp, rspLen, &mmInfo);
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = rspLen;
+  pReq->info.rspLen = rspLen;
   tFreeSMonMmInfo(&mmInfo);
   return 0;
 }
@@ -50,7 +50,7 @@ static void mmGetMnodeLoads(SMnodeMgmt *pMgmt, SMonMloadInfo *pInfo) {
   mndGetLoad(pMgmt->pMnode, &pInfo->load);
 }
 
-int32_t mmProcessGetLoadsReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq) {
+int32_t mmProcessGetLoadsReq(SMnodeMgmt *pMgmt, SRpcMsg *pReq) {
   SMonMloadInfo mloads = {0};
   mmGetMnodeLoads(pMgmt, &mloads);
 
@@ -67,13 +67,13 @@ int32_t mmProcessGetLoadsReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq) {
   }
 
   tSerializeSMonMloadInfo(pRsp, rspLen, &mloads);
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = rspLen;
+  pReq->info.rspLen = rspLen;
   return 0;
 }
 
-int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
+int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) {
-  SRpcMsg *pReq = &pMsg->rpcMsg;
+  SRpcMsg *pReq = pMsg;
 
   SDCreateMnodeReq createReq = {0};
   if (tDeserializeSDCreateMnodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
@@ -81,7 +81,7 @@ int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (createReq.replica <= 1 || (createReq.dnodeId != pInput->dnodeId && pInput->dnodeId != 0)) {
+  if (createReq.replica <= 1 || (createReq.dnodeId != pInput->pData->dnodeId && pInput->pData->dnodeId != 0)) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to create mnode since %s", terrstr());
     return -1;
@@ -100,8 +100,8 @@ int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t mmProcessDropReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t mmProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) {
-  SRpcMsg *pReq = &pMsg->rpcMsg;
+  SRpcMsg *pReq = pMsg;
 
   SDDropMnodeReq dropReq = {0};
   if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
@@ -109,14 +109,18 @@ int32_t mmProcessDropReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pMgmt->dnodeId != 0 && dropReq.dnodeId != pMgmt->dnodeId) {
+  if (pInput->pData->dnodeId != 0 && dropReq.dnodeId != pInput->pData->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to drop mnode since %s", terrstr());
     return -1;
   }
 
   bool deployed = false;
-  if (mmWriteFile(pMgmt, NULL, deployed) != 0) {
+
+  SMnodeMgmt mgmt = {0};
+  mgmt.path = pInput->path;
+  mgmt.name = pInput->name;
+  if (mmWriteFile(&mgmt, NULL, deployed) != 0) {
     dError("failed to write mnode file since %s", terrstr());
     return -1;
   }
@@ -124,8 +128,8 @@ int32_t mmProcessDropReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  SRpcMsg *pReq = &pMsg->rpcMsg;
+  SRpcMsg *pReq = pMsg;
 
   SDAlterMnodeReq alterReq = {0};
   if (tDeserializeSDCreateMnodeReq(pReq->pCont, pReq->contLen, &alterReq) != 0) {
@@ -133,9 +137,9 @@ int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pMgmt->dnodeId != 0 && alterReq.dnodeId != pMgmt->dnodeId) {
+  if (pMgmt->pData->dnodeId != 0 && alterReq.dnodeId != pMgmt->pData->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
-    dError("failed to alter mnode since %s, input:%d cur:%d", terrstr(), alterReq.dnodeId, pMgmt->dnodeId);
+    dError("failed to alter mnode since %s, input:%d cur:%d", terrstr(), alterReq.dnodeId, pMgmt->pData->dnodeId);
     return -1;
   } else {
     return mmAlter(pMgmt, &alterReq);
@@ -216,6 +220,7 @@ SArray *mmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_MND_MQ_COMMIT_OFFSET, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_MQ_ASK_EP, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_CHANGE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_DELETE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_STREAM, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_DEPLOY_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_GET_DB_CFG, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;

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

@@ -18,9 +18,9 @@
 #include "wal.h"
 
 static bool mmDeployRequired(const SMgmtInputOpt *pInput) {
-  if (pInput->dnodeId > 0) return false;
+  if (pInput->pData->dnodeId > 0) return false;
-  if (pInput->clusterId > 0) return false;
+  if (pInput->pData->clusterId > 0) return false;
-  if (strcmp(pInput->localEp, pInput->firstEp) != 0) return false;
+  if (strcmp(tsLocalEp, tsFirst) != 0) return false;
   return true;
 }
 
@@ -44,8 +44,8 @@ static void mmBuildOptionForDeploy(SMnodeMgmt *pMgmt, const SMgmtInputOpt *pInpu
   pOption->selfIndex = 0;
   SReplica *pReplica = &pOption->replicas[0];
   pReplica->id = 1;
-  pReplica->port = pInput->serverPort;
+  pReplica->port = tsServerPort;
-  tstrncpy(pReplica->fqdn, pInput->localFqdn, TSDB_FQDN_LEN);
+  tstrncpy(pReplica->fqdn, tsLocalFqdn, TSDB_FQDN_LEN);
   pOption->deploy = true;
 
   pMgmt->selfIndex = pOption->selfIndex;
@@ -70,7 +70,7 @@ static int32_t mmBuildOptionFromReq(SMnodeMgmt *pMgmt, SMnodeOpt *pOption, SDCre
     pReplica->id = pCreate->replicas[i].id;
     pReplica->port = pCreate->replicas[i].port;
     memcpy(pReplica->fqdn, pCreate->replicas[i].fqdn, TSDB_FQDN_LEN);
-    if (pReplica->id == pMgmt->dnodeId) {
+    if (pReplica->id == pMgmt->pData->dnodeId) {
       pOption->selfIndex = i;
     }
   }
@@ -107,7 +107,6 @@ int32_t mmAlter(SMnodeMgmt *pMgmt, SDAlterMnodeReq *pReq) {
 }
 
 static void mmClose(SMnodeMgmt *pMgmt) {
-  dInfo("mnode-mgmt start to cleanup");
   if (pMgmt->pMnode != NULL) {
     mmStopWorker(pMgmt);
     mndClose(pMgmt->pMnode);
@@ -115,11 +114,9 @@ static void mmClose(SMnodeMgmt *pMgmt) {
   }
 
   taosMemoryFree(pMgmt);
-  dInfo("mnode-mgmt is cleaned up");
 }
 
-static int32_t mmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
+static int32_t mmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
-  dInfo("mnode-mgmt start to init");
   if (walInit() != 0) {
     dError("failed to init wal since %s", terrstr());
     return -1;
@@ -131,15 +128,15 @@ static int32_t mmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
     return -1;
   }
 
+  pMgmt->pData = pInput->pData;
   pMgmt->path = pInput->path;
   pMgmt->name = pInput->name;
-  pMgmt->dnodeId = pInput->dnodeId;
   pMgmt->msgCb = pInput->msgCb;
   pMgmt->msgCb.queueFps[QUERY_QUEUE] = (PutToQueueFp)mmPutRpcMsgToQueryQueue;
   pMgmt->msgCb.queueFps[READ_QUEUE] = (PutToQueueFp)mmPutRpcMsgToReadQueue;
   pMgmt->msgCb.queueFps[WRITE_QUEUE] = (PutToQueueFp)mmPutRpcMsgToWriteQueue;
   pMgmt->msgCb.queueFps[SYNC_QUEUE] = (PutToQueueFp)mmPutRpcMsgToWriteQueue;
-  pMgmt->msgCb.pMgmt = pMgmt;
+  pMgmt->msgCb.mgmt = pMgmt;
 
   bool deployed = false;
   if (mmReadFile(pMgmt, &deployed) != 0) {
@@ -151,7 +148,7 @@ static int32_t mmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   SMnodeOpt option = {0};
   if (!deployed) {
     dInfo("mnode start to deploy");
-    pMgmt->dnodeId = 1;
+    pMgmt->pData->dnodeId = 1;
     mmBuildOptionForDeploy(pMgmt, pInput, &option);
   } else {
     dInfo("mnode start to open");
@@ -181,9 +178,8 @@ static int32_t mmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
     }
   }
 
-  pOutput->dnodeId = pMgmt->dnodeId;
+  pInput->pData->dnodeId = pMgmt->pData->dnodeId;
   pOutput->pMgmt = pMgmt;
-  dInfo("mnode-mgmt is initialized");
   return 0;
 }
 

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

@@ -16,26 +16,22 @@
 #define _DEFAULT_SOURCE
 #include "mmInt.h"
 
-static inline void mmSendRsp(SNodeMsg *pMsg, int32_t code) {
+static inline void mmSendRsp(SRpcMsg *pMsg, int32_t code) {
   SRpcMsg rsp = {
-      .handle = pMsg->rpcMsg.handle,
-      .ahandle = pMsg->rpcMsg.ahandle,
-      .refId = pMsg->rpcMsg.refId,
       .code = code,
-      .pCont = pMsg->pRsp,
+      .info = pMsg->info,
-      .contLen = pMsg->rspLen,
+      .pCont = pMsg->info.rsp,
+      .contLen = pMsg->info.rspLen,
   };
   tmsgSendRsp(&rsp);
 }
 
-static void mmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void mmProcessQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SMnodeMgmt *pMgmt = pInfo->ahandle;
   int32_t     code = -1;
-  tmsg_t      msgType = pMsg->rpcMsg.msgType;
+  dTrace("msg:%p, get from mnode queue, type:%s", pMsg, TMSG_INFO(pMsg->msgType));
-  bool        isRequest = msgType & 1U;
-  dTrace("msg:%p, get from mnode queue, type:%s", pMsg, TMSG_INFO(msgType));
 
-  switch (msgType) {
+  switch (pMsg->msgType) {
     case TDMT_DND_ALTER_MNODE:
       code = mmProcessAlterReq(pMgmt, pMsg);
       break;
@@ -46,69 +42,67 @@ static void mmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
       code = mmProcessGetLoadsReq(pMgmt, pMsg);
       break;
     default:
-      pMsg->pNode = pMgmt->pMnode;
+      pMsg->info.node = pMgmt->pMnode;
       code = mndProcessMsg(pMsg);
   }
 
-  if (isRequest) {
+  if (IsReq(pMsg) && pMsg->info.handle != NULL && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    if (pMsg->rpcMsg.handle != NULL && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     if (code != 0 && terrno != 0) code = terrno;
     mmSendRsp(pMsg, code);
   }
-  }
 
   dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-  rpcFreeCont(pMsg->rpcMsg.pCont);
+  rpcFreeCont(pMsg->pCont);
   taosFreeQitem(pMsg);
 }
 
-static void mmProcessQueryQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void mmProcessQueryQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SMnodeMgmt *pMgmt = pInfo->ahandle;
   int32_t     code = -1;
-  tmsg_t      msgType = pMsg->rpcMsg.msgType;
+  tmsg_t      msgType = pMsg->msgType;
   bool        isRequest = msgType & 1U;
   dTrace("msg:%p, get from mnode-query queue", pMsg);
 
-  pMsg->pNode = pMgmt->pMnode;
+  pMsg->info.node = pMgmt->pMnode;
   code = mndProcessMsg(pMsg);
 
   if (isRequest) {
-    if (pMsg->rpcMsg.handle != NULL && code != 0) {
+    if (pMsg->info.handle != NULL && code != 0) {
       if (code != 0 && terrno != 0) code = terrno;
       mmSendRsp(pMsg, code);
     }
   }
 
   dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-  rpcFreeCont(pMsg->rpcMsg.pCont);
+  rpcFreeCont(pMsg->pCont);
   taosFreeQitem(pMsg);
 }
 
-static int32_t mmPutNodeMsgToWorker(SSingleWorker *pWorker, SNodeMsg *pMsg) {
+static int32_t mmPutNodeMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pMsg) {
-  dTrace("msg:%p, put into worker %s, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->rpcMsg.msgType));
+  dTrace("msg:%p, put into worker %s, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->msgType));
   taosWriteQitem(pWorker->queue, pMsg);
   return 0;
 }
 
-int32_t mmPutNodeMsgToWriteQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->writeWorker, pMsg); }
+int32_t mmPutNodeMsgToWriteQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->writeWorker, pMsg); }
 
-int32_t mmPutNodeMsgToSyncQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->syncWorker, pMsg); }
+int32_t mmPutNodeMsgToSyncQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->syncWorker, pMsg); }
 
-int32_t mmPutNodeMsgToReadQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->readWorker, pMsg); }
+int32_t mmPutNodeMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->readWorker, pMsg); }
 
-int32_t mmPutNodeMsgToQueryQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->queryWorker, pMsg);
+int32_t mmPutNodeMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->queryWorker, pMsg);
 }
 
-int32_t mmPutNodeMsgToMonitorQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t mmPutNodeMsgToMonitorQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   return mmPutNodeMsgToWorker(&pMgmt->monitorWorker, pMsg);
 }
 
 static inline int32_t mmPutRpcMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pRpc) {
-  SNodeMsg *pMsg = taosAllocateQitem(sizeof(SNodeMsg), RPC_QITEM);
+  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
   if (pMsg == NULL) return -1;
 
   dTrace("msg:%p, is created and put into worker:%s, type:%s", pMsg, pWorker->name, TMSG_INFO(pRpc->msgType));
-  pMsg->rpcMsg = *pRpc;
+  memcpy(pMsg, pRpc, sizeof(SRpcMsg));
   taosWriteQitem(pWorker->queue, pMsg);
   return 0;
 }

source/dnode/mgmt/mgmt_qnode/inc/qmInt.h

@@ -25,11 +25,11 @@ extern "C" {
 #endif
 
 typedef struct SQnodeMgmt {
+  SDnodeData   *pData;
   SQnode       *pQnode;
   SMsgCb        msgCb;
   const char   *path;
   const char   *name;
-  int32_t       dnodeId;
   SSingleWorker queryWorker;
   SSingleWorker fetchWorker;
   SSingleWorker monitorWorker;
@@ -37,9 +37,9 @@ typedef struct SQnodeMgmt {
 
 // qmHandle.c
 SArray *qmGetMsgHandles();
-int32_t qmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg);
+int32_t qmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
-int32_t qmProcessDropReq(SQnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t qmProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
-int32_t qmProcessGetMonitorInfoReq(SQnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t qmProcessGetMonitorInfoReq(SQnodeMgmt *pMgmt, SRpcMsg *pReq);
 
 // qmWorker.c
 int32_t qmPutRpcMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg);
@@ -48,9 +48,9 @@ int32_t qmGetQueueSize(SQnodeMgmt *pMgmt, int32_t vgId, EQueueType qtype);
 
 int32_t qmStartWorker(SQnodeMgmt *pMgmt);
 void    qmStopWorker(SQnodeMgmt *pMgmt);
-int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t qmPutNodeMsgToFetchQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t qmPutNodeMsgToFetchQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t qmPutNodeMsgToMonitorQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t qmPutNodeMsgToMonitorQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_qnode/src/qmHandle.c

@@ -18,7 +18,7 @@
 
 static void qmGetMonitorInfo(SQnodeMgmt *pMgmt, SMonQmInfo *qmInfo) {}
 
-int32_t qmProcessGetMonitorInfoReq(SQnodeMgmt *pMgmt, SNodeMsg *pReq) {
+int32_t qmProcessGetMonitorInfoReq(SQnodeMgmt *pMgmt, SRpcMsg *pReq) {
   SMonQmInfo qmInfo = {0};
   qmGetMonitorInfo(pMgmt, &qmInfo);
   dmGetMonitorSystemInfo(&qmInfo.sys);
@@ -37,14 +37,14 @@ int32_t qmProcessGetMonitorInfoReq(SQnodeMgmt *pMgmt, SNodeMsg *pReq) {
   }
 
   tSerializeSMonQmInfo(pRsp, rspLen, &qmInfo);
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = rspLen;
+  pReq->info.rspLen = rspLen;
   tFreeSMonQmInfo(&qmInfo);
   return 0;
 }
 
-int32_t qmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
+int32_t qmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) {
-  SRpcMsg *pReq = &pMsg->rpcMsg;
+  SRpcMsg *pReq = pMsg;
 
   SDCreateQnodeReq createReq = {0};
   if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
@@ -52,7 +52,7 @@ int32_t qmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pInput->dnodeId != 0 && createReq.dnodeId != pInput->dnodeId) {
+  if (pInput->pData->dnodeId != 0 && createReq.dnodeId != pInput->pData->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to create qnode since %s", terrstr());
     return -1;
@@ -67,8 +67,8 @@ int32_t qmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t qmProcessDropReq(SQnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t qmProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) {
-  SRpcMsg *pReq = &pMsg->rpcMsg;
+  SRpcMsg *pReq = pMsg;
 
   SDDropQnodeReq dropReq = {0};
   if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
@@ -76,14 +76,14 @@ int32_t qmProcessDropReq(SQnodeMgmt *pMgmt, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pMgmt->dnodeId != 0 && dropReq.dnodeId != pMgmt->dnodeId) {
+  if (pInput->pData->dnodeId != 0 && dropReq.dnodeId != pInput->pData->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to drop qnode since %s", terrstr());
     return -1;
   }
 
   bool deployed = false;
-  if (dmWriteFile(pMgmt->path, pMgmt->name, deployed) != 0) {
+  if (dmWriteFile(pInput->path, pInput->name, deployed) != 0) {
     dError("failed to write qnode file since %s", terrstr());
     return -1;
   }

source/dnode/mgmt/mgmt_qnode/src/qmInt.c

@@ -23,7 +23,6 @@ static int32_t qmRequire(const SMgmtInputOpt *pInput, bool *required) {
 static void qmInitOption(SQnodeMgmt *pMgmt, SQnodeOpt *pOption) { pOption->msgCb = pMgmt->msgCb; }
 
 static void qmClose(SQnodeMgmt *pMgmt) {
-  dInfo("qnode-mgmt start to cleanup");
   if (pMgmt->pQnode != NULL) {
     qmStopWorker(pMgmt);
     qndClose(pMgmt->pQnode);
@@ -31,25 +30,23 @@ static void qmClose(SQnodeMgmt *pMgmt) {
   }
 
   taosMemoryFree(pMgmt);
-  dInfo("qnode-mgmt is cleaned up");
 }
 
-static int32_t qmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
+static int32_t qmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
-  dInfo("qnode-mgmt start to init");
   SQnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SQnodeMgmt));
   if (pMgmt == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
 
+  pMgmt->pData = pInput->pData;
   pMgmt->path = pInput->path;
   pMgmt->name = pInput->name;
-  pMgmt->dnodeId = pInput->dnodeId;
   pMgmt->msgCb = pInput->msgCb;
   pMgmt->msgCb.queueFps[QUERY_QUEUE] = (PutToQueueFp)qmPutRpcMsgToQueryQueue;
   pMgmt->msgCb.queueFps[FETCH_QUEUE] = (PutToQueueFp)qmPutRpcMsgToFetchQueue;
   pMgmt->msgCb.qsizeFp = (GetQueueSizeFp)qmGetQueueSize;
-  pMgmt->msgCb.pMgmt = pMgmt;
+  pMgmt->msgCb.mgmt = pMgmt;
 
   SQnodeOpt option = {0};
   qmInitOption(pMgmt, &option);
@@ -75,7 +72,6 @@ static int32_t qmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   tmsgReportStartup("qnode-worker", "initialized");
 
   pOutput->pMgmt = pMgmt;
-  dInfo("qnode-mgmt is initialized");
   return 0;
 }
 

source/dnode/mgmt/mgmt_qnode/src/qmWorker.c

@@ -16,26 +16,24 @@
 #define _DEFAULT_SOURCE
 #include "qmInt.h"
 
-static inline void qmSendRsp(SNodeMsg *pMsg, int32_t code) {
+static inline void qmSendRsp(SRpcMsg *pMsg, int32_t code) {
   SRpcMsg rsp = {
-      .handle = pMsg->rpcMsg.handle,
-      .ahandle = pMsg->rpcMsg.ahandle,
-      .refId = pMsg->rpcMsg.refId,
       .code = code,
-      .pCont = pMsg->pRsp,
+      .info = pMsg->info,
-      .contLen = pMsg->rspLen,
+      .pCont = pMsg->info.rsp,
+      .contLen = pMsg->info.rspLen,
   };
   tmsgSendRsp(&rsp);
 }
 
-static void qmProcessMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void qmProcessMonitorQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SQnodeMgmt *pMgmt = pInfo->ahandle;
 
   dTrace("msg:%p, get from qnode-monitor queue", pMsg);
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
+  SRpcMsg *pRpc = pMsg;
   int32_t  code = -1;
 
-  if (pMsg->rpcMsg.msgType == TDMT_MON_QM_INFO) {
+  if (pMsg->msgType == TDMT_MON_QM_INFO) {
     code = qmProcessGetMonitorInfoReq(pMgmt, pMsg);
   } else {
     terrno = TSDB_CODE_MSG_NOT_PROCESSED;
@@ -51,11 +49,11 @@ static void qmProcessMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   taosFreeQitem(pMsg);
 }
 
-static void qmProcessQueryQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void qmProcessQueryQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SQnodeMgmt *pMgmt = pInfo->ahandle;
 
   dTrace("msg:%p, get from qnode-query queue", pMsg);
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
+  SRpcMsg *pRpc = pMsg;
   int32_t  code = qndProcessQueryMsg(pMgmt->pQnode, pRpc);
 
   if (pRpc->msgType & 1U && code != 0) {
@@ -63,15 +61,15 @@ static void qmProcessQueryQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   }
 
   dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-  rpcFreeCont(pMsg->rpcMsg.pCont);
+  rpcFreeCont(pMsg->pCont);
   taosFreeQitem(pMsg);
 }
 
-static void qmProcessFetchQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void qmProcessFetchQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SQnodeMgmt *pMgmt = pInfo->ahandle;
 
   dTrace("msg:%p, get from qnode-fetch queue", pMsg);
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
+  SRpcMsg *pRpc = pMsg;
   int32_t  code = qndProcessFetchMsg(pMgmt->pQnode, pRpc);
 
   if (pRpc->msgType & 1U && code != 0) {
@@ -79,36 +77,36 @@ static void qmProcessFetchQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   }
 
   dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-  rpcFreeCont(pMsg->rpcMsg.pCont);
+  rpcFreeCont(pMsg->pCont);
   taosFreeQitem(pMsg);
 }
 
-static int32_t qmPutNodeMsgToWorker(SSingleWorker *pWorker, SNodeMsg *pMsg) {
+static int32_t qmPutNodeMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pMsg) {
   dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
   taosWriteQitem(pWorker->queue, pMsg);
   return 0;
 }
 
-int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   return qmPutNodeMsgToWorker(&pMgmt->queryWorker, pMsg);
 }
 
-int32_t qmPutNodeMsgToFetchQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t qmPutNodeMsgToFetchQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   return qmPutNodeMsgToWorker(&pMgmt->fetchWorker, pMsg);
 }
 
-int32_t qmPutNodeMsgToMonitorQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t qmPutNodeMsgToMonitorQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   return qmPutNodeMsgToWorker(&pMgmt->monitorWorker, pMsg);
 }
 
 static int32_t qmPutRpcMsgToWorker(SQnodeMgmt *pMgmt, SSingleWorker *pWorker, SRpcMsg *pRpc) {
-  SNodeMsg *pMsg = taosAllocateQitem(sizeof(SNodeMsg), RPC_QITEM);
+  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
   if (pMsg == NULL) {
     return -1;
   }
 
   dTrace("msg:%p, is created and put into worker:%s, type:%s", pMsg, pWorker->name, TMSG_INFO(pRpc->msgType));
-  pMsg->rpcMsg = *pRpc;
+  memcpy(pMsg, pRpc, sizeof(SRpcMsg));
   taosWriteQitem(pWorker->queue, pMsg);
   return 0;
 }

source/dnode/mgmt/mgmt_snode/inc/smInt.h

@@ -25,11 +25,11 @@ extern "C" {
 #endif
 
 typedef struct SSnodeMgmt {
+  SDnodeData   *pData;
   SSnode       *pSnode;
   SMsgCb        msgCb;
   const char   *path;
   const char   *name;
-  int32_t       dnodeId;
   SRWLatch      latch;
   int8_t        uniqueWorkerInUse;
   SArray       *uniqueWorkers;  // SArray<SMultiWorker*>
@@ -39,18 +39,18 @@ typedef struct SSnodeMgmt {
 
 // smHandle.c
 SArray *smGetMsgHandles();
-int32_t smProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg);
+int32_t smProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
-int32_t smProcessDropReq(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
-int32_t smProcessGetMonitorInfoReq(SSnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t smProcessGetMonitorInfoReq(SSnodeMgmt *pMgmt, SRpcMsg *pReq);
 
 // smWorker.c
 int32_t smStartWorker(SSnodeMgmt *pMgmt);
 void    smStopWorker(SSnodeMgmt *pMgmt);
-int32_t smPutNodeMsgToMgmtQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToMgmtQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t smPutNodeMsgToUniqueQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToUniqueQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t smPutNodeMsgToSharedQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToSharedQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t smPutNodeMsgToExecQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToExecQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t smPutNodeMsgToMonitorQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToMonitorQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_snode/src/smHandle.c

@@ -18,7 +18,7 @@
 
 static void smGetMonitorInfo(SSnodeMgmt *pMgmt, SMonSmInfo *smInfo) {}
 
-int32_t smProcessGetMonitorInfoReq(SSnodeMgmt *pMgmt, SNodeMsg *pReq) {
+int32_t smProcessGetMonitorInfoReq(SSnodeMgmt *pMgmt, SRpcMsg *pReq) {
   SMonSmInfo smInfo = {0};
   smGetMonitorInfo(pMgmt, &smInfo);
   dmGetMonitorSystemInfo(&smInfo.sys);
@@ -37,14 +37,14 @@ int32_t smProcessGetMonitorInfoReq(SSnodeMgmt *pMgmt, SNodeMsg *pReq) {
   }
 
   tSerializeSMonSmInfo(pRsp, rspLen, &smInfo);
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = rspLen;
+  pReq->info.rspLen = rspLen;
   tFreeSMonSmInfo(&smInfo);
   return 0;
 }
 
-int32_t smProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
+int32_t smProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) {
-  SRpcMsg *pReq = &pMsg->rpcMsg;
+  SRpcMsg *pReq = pMsg;
 
   SDCreateSnodeReq createReq = {0};
   if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
@@ -52,7 +52,7 @@ int32_t smProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pInput->dnodeId != 0 && createReq.dnodeId != pInput->dnodeId) {
+  if (pInput->pData->dnodeId != 0 && createReq.dnodeId != pInput->pData->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to create snode since %s", terrstr());
     return -1;
@@ -67,8 +67,8 @@ int32_t smProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t smProcessDropReq(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t smProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) {
-  SRpcMsg *pReq = &pMsg->rpcMsg;
+  SRpcMsg *pReq = pMsg;
 
   SDDropSnodeReq dropReq = {0};
   if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
@@ -76,14 +76,14 @@ int32_t smProcessDropReq(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pMgmt->dnodeId != 0 && dropReq.dnodeId != pMgmt->dnodeId) {
+  if (pInput->pData->dnodeId != 0 && dropReq.dnodeId != pInput->pData->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to drop snode since %s", terrstr());
     return -1;
   }
 
   bool deployed = false;
-  if (dmWriteFile(pMgmt->path, pMgmt->name, deployed) != 0) {
+  if (dmWriteFile(pInput->path, pInput->name, deployed) != 0) {
     dError("failed to write snode file since %s", terrstr());
     return -1;
   }

source/dnode/mgmt/mgmt_snode/src/smInt.c

@@ -24,7 +24,6 @@ static int32_t smRequire(const SMgmtInputOpt *pInput, bool *required) {
 static void smInitOption(SSnodeMgmt *pMgmt, SSnodeOpt *pOption) { pOption->msgCb = pMgmt->msgCb; }
 
 static void smClose(SSnodeMgmt *pMgmt) {
-  dInfo("snode-mgmt start to cleanup");
   if (pMgmt->pSnode != NULL) {
     smStopWorker(pMgmt);
     sndClose(pMgmt->pSnode);
@@ -32,22 +31,20 @@ static void smClose(SSnodeMgmt *pMgmt) {
   }
 
   taosMemoryFree(pMgmt);
-  dInfo("snode-mgmt is cleaned up");
 }
 
-int32_t smOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
+int32_t smOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
-  dInfo("snode-mgmt start to init");
   SSnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SSnodeMgmt));
   if (pMgmt == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
 
+  pMgmt->pData = pInput->pData;
   pMgmt->path = pInput->path;
   pMgmt->name = pInput->name;
-  pMgmt->dnodeId = pInput->dnodeId;
   pMgmt->msgCb = pInput->msgCb;
-  pMgmt->msgCb.pMgmt = pMgmt;
+  pMgmt->msgCb.mgmt = pMgmt;
 
   SSnodeOpt option = {0};
   smInitOption(pMgmt, &option);

source/dnode/mgmt/mgmt_snode/src/smWorker.c

@@ -16,26 +16,24 @@
 #define _DEFAULT_SOURCE
 #include "smInt.h"
 
-static inline void smSendRsp(SNodeMsg *pMsg, int32_t code) {
+static inline void smSendRsp(SRpcMsg *pMsg, int32_t code) {
   SRpcMsg rsp = {
-      .handle = pMsg->rpcMsg.handle,
-      .ahandle = pMsg->rpcMsg.ahandle,
-      .refId = pMsg->rpcMsg.refId,
       .code = code,
-      .pCont = pMsg->pRsp,
+      .info = pMsg->info,
-      .contLen = pMsg->rspLen,
+      .pCont = pMsg->info.rsp,
+      .contLen = pMsg->info.rspLen,
   };
   tmsgSendRsp(&rsp);
 }
 
-static void smProcessMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void smProcessMonitorQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SSnodeMgmt *pMgmt = pInfo->ahandle;
 
   dTrace("msg:%p, get from snode-monitor queue", pMsg);
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
+  SRpcMsg *pRpc = pMsg;
   int32_t  code = -1;
 
-  if (pMsg->rpcMsg.msgType == TDMT_MON_SM_INFO) {
+  if (pMsg->msgType == TDMT_MON_SM_INFO) {
     code = smProcessGetMonitorInfoReq(pMgmt, pMsg);
   } else {
     terrno = TSDB_CODE_MSG_NOT_PROCESSED;
@@ -55,26 +53,26 @@ static void smProcessUniqueQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t num
   SSnodeMgmt *pMgmt = pInfo->ahandle;
 
   for (int32_t i = 0; i < numOfMsgs; i++) {
-    SNodeMsg *pMsg = NULL;
+    SRpcMsg *pMsg = NULL;
     taosGetQitem(qall, (void **)&pMsg);
 
     dTrace("msg:%p, get from snode-unique queue", pMsg);
-    sndProcessUMsg(pMgmt->pSnode, &pMsg->rpcMsg);
+    sndProcessUMsg(pMgmt->pSnode, pMsg);
 
     dTrace("msg:%p, is freed", pMsg);
-    rpcFreeCont(pMsg->rpcMsg.pCont);
+    rpcFreeCont(pMsg->pCont);
     taosFreeQitem(pMsg);
   }
 }
 
-static void smProcessSharedQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void smProcessSharedQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SSnodeMgmt *pMgmt = pInfo->ahandle;
 
   dTrace("msg:%p, get from snode-shared queue", pMsg);
-  sndProcessSMsg(pMgmt->pSnode, &pMsg->rpcMsg);
+  sndProcessSMsg(pMgmt->pSnode, pMsg);
 
   dTrace("msg:%p, is freed", pMsg);
-  rpcFreeCont(pMsg->rpcMsg.pCont);
+  rpcFreeCont(pMsg->pCont);
   taosFreeQitem(pMsg);
 }
 
@@ -161,7 +159,7 @@ static FORCE_INLINE int32_t smGetSWTypeFromMsg(SRpcMsg *pMsg) {
   return 0;
 }
 
-int32_t smPutNodeMsgToMgmtQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t smPutNodeMsgToMgmtQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SMultiWorker *pWorker = taosArrayGetP(pMgmt->uniqueWorkers, 0);
   if (pWorker == NULL) {
     terrno = TSDB_CODE_INVALID_MSG;
@@ -173,7 +171,7 @@ int32_t smPutNodeMsgToMgmtQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t smPutNodeMsgToMonitorQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t smPutNodeMsgToMonitorQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SSingleWorker *pWorker = &pMgmt->monitorWorker;
 
   dTrace("msg:%p, put into worker:%s", pMsg, pWorker->name);
@@ -181,8 +179,8 @@ int32_t smPutNodeMsgToMonitorQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t smPutNodeMsgToUniqueQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t smPutNodeMsgToUniqueQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  int32_t       index = smGetSWIdFromMsg(&pMsg->rpcMsg);
+  int32_t       index = smGetSWIdFromMsg(pMsg);
   SMultiWorker *pWorker = taosArrayGetP(pMgmt->uniqueWorkers, index);
   if (pWorker == NULL) {
     terrno = TSDB_CODE_INVALID_MSG;
@@ -194,7 +192,7 @@ int32_t smPutNodeMsgToUniqueQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t smPutNodeMsgToSharedQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t smPutNodeMsgToSharedQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SSingleWorker *pWorker = &pMgmt->sharedWorker;
 
   dTrace("msg:%p, put into worker:%s", pMsg, pWorker->name);
@@ -202,8 +200,8 @@ int32_t smPutNodeMsgToSharedQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t smPutNodeMsgToExecQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t smPutNodeMsgToExecQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  int32_t workerType = smGetSWTypeFromMsg(&pMsg->rpcMsg);
+  int32_t workerType = smGetSWTypeFromMsg(pMsg);
   if (workerType == SND_WORKER_TYPE__SHARED) {
     return smPutNodeMsgToSharedQueue(pMgmt, pMsg);
   } else {

source/dnode/mgmt/mgmt_vnode/inc/vmInt.h

@@ -26,10 +26,10 @@ extern "C" {
 #endif
 
 typedef struct SVnodeMgmt {
+  SDnodeData   *pData;
   SMsgCb        msgCb;
   const char   *path;
   const char   *name;
-  int32_t       dnodeId;
   SQWorkerPool  queryPool;
   SQWorkerPool  fetchPool;
   SWWorkerPool  syncPool;
@@ -84,10 +84,10 @@ void       vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode);
 
 // vmHandle.c
 SArray *vmGetMsgHandles();
-int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pReq);
-int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pReq);
-int32_t vmProcessGetMonitorInfoReq(SVnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t vmProcessGetMonitorInfoReq(SVnodeMgmt *pMgmt, SRpcMsg *pReq);
-int32_t vmProcessGetLoadsReq(SVnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t vmProcessGetLoadsReq(SVnodeMgmt *pMgmt, SRpcMsg *pReq);
 
 // vmFile.c
 int32_t     vmGetVnodeListFromFile(SVnodeMgmt *pMgmt, SWrapperCfg **ppCfgs, int32_t *numOfVnodes);
@@ -108,13 +108,13 @@ int32_t vmPutRpcMsgToFetchQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t vmPutRpcMsgToMergeQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t vmGetQueueSize(SVnodeMgmt *pMgmt, int32_t vgId, EQueueType qtype);
 
-int32_t vmPutNodeMsgToWriteQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t vmPutNodeMsgToWriteQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t vmPutNodeMsgToSyncQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t vmPutNodeMsgToSyncQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t vmPutNodeMsgToQueryQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t vmPutNodeMsgToQueryQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t vmPutNodeMsgToFetchQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t vmPutNodeMsgToFetchQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t vmPutNodeMsgToMergeQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t vmPutNodeMsgToMergeQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t vmPutNodeMsgToMgmtQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t vmPutNodeMsgToMgmtQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t vmPutNodeMsgToMonitorQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t vmPutNodeMsgToMonitorQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_vnode/src/vmHandle.c

@@ -82,7 +82,7 @@ static void vmGetMonitorInfo(SVnodeMgmt *pMgmt, SMonVmInfo *pInfo) {
   taosArrayDestroy(pVloads);
 }
 
-int32_t vmProcessGetMonitorInfoReq(SVnodeMgmt *pMgmt, SNodeMsg *pReq) {
+int32_t vmProcessGetMonitorInfoReq(SVnodeMgmt *pMgmt, SRpcMsg *pReq) {
   SMonVmInfo vmInfo = {0};
   vmGetMonitorInfo(pMgmt, &vmInfo);
   dmGetMonitorSystemInfo(&vmInfo.sys);
@@ -101,13 +101,13 @@ int32_t vmProcessGetMonitorInfoReq(SVnodeMgmt *pMgmt, SNodeMsg *pReq) {
   }
 
   tSerializeSMonVmInfo(pRsp, rspLen, &vmInfo);
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = rspLen;
+  pReq->info.rspLen = rspLen;
   tFreeSMonVmInfo(&vmInfo);
   return 0;
 }
 
-int32_t vmProcessGetLoadsReq(SVnodeMgmt *pMgmt, SNodeMsg *pReq) {
+int32_t vmProcessGetLoadsReq(SVnodeMgmt *pMgmt, SRpcMsg *pReq) {
   SMonVloadInfo vloads = {0};
   vmGetVnodeLoads(pMgmt, &vloads);
 
@@ -124,8 +124,8 @@ int32_t vmProcessGetLoadsReq(SVnodeMgmt *pMgmt, SNodeMsg *pReq) {
   }
 
   tSerializeSMonVloadInfo(pRsp, rspLen, &vloads);
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = rspLen;
+  pReq->info.rspLen = rspLen;
   tFreeSMonVloadInfo(&vloads);
   return 0;
 }
@@ -173,8 +173,8 @@ static void vmGenerateWrapperCfg(SVnodeMgmt *pMgmt, SCreateVnodeReq *pCreate, SW
   snprintf(pCfg->path, sizeof(pCfg->path), "%s%svnode%d", pMgmt->path, TD_DIRSEP, pCreate->vgId);
 }
 
-int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  SRpcMsg        *pReq = &pMsg->rpcMsg;
+  SRpcMsg        *pReq = pMsg;
   SCreateVnodeReq createReq = {0};
   int32_t         code = -1;
   char            path[TSDB_FILENAME_LEN] = {0};
@@ -241,8 +241,8 @@ _OVER:
   return code;
 }
 
-int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  SRpcMsg      *pReq = &pMsg->rpcMsg;
+  SRpcMsg      *pReq = pMsg;
   SDropVnodeReq dropReq = {0};
   if (tDeserializeSDropVnodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
@@ -308,6 +308,7 @@ SArray *vmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_SMA, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_SUBMIT_RSMA, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_CHANGE, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_DELETE, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_CONSUME, vmPutNodeMsgToFetchQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_DEPLOY, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_HEARTBEAT, vmPutNodeMsgToFetchQueue, 0) == NULL) goto _OVER;

source/dnode/mgmt/mgmt_vnode/src/vmInt.c

@@ -234,26 +234,22 @@ static void vmCloseVnodes(SVnodeMgmt *pMgmt) {
 }
 
 static void vmCleanup(SVnodeMgmt *pMgmt) {
-  dInfo("vnode-mgmt start to cleanup");
   vmCloseVnodes(pMgmt);
   vmStopWorker(pMgmt);
   vnodeCleanup();
   tfsClose(pMgmt->pTfs);
   taosMemoryFree(pMgmt);
-
-  dInfo("vnode-mgmt is cleaned up");
 }
 
-static int32_t vmInit(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
+static int32_t vmInit(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
-  dInfo("vnode-mgmt start to init");
   int32_t code = -1;
 
   SVnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SVnodeMgmt));
   if (pMgmt == NULL) goto _OVER;
 
+  pMgmt->pData = pInput->pData;
   pMgmt->path = pInput->path;
   pMgmt->name = pInput->name;
-  pMgmt->dnodeId = pInput->dnodeId;
   pMgmt->msgCb = pInput->msgCb;
   pMgmt->msgCb.queueFps[WRITE_QUEUE] = (PutToQueueFp)vmPutRpcMsgToWriteQueue;
   pMgmt->msgCb.queueFps[SYNC_QUEUE] = (PutToQueueFp)vmPutRpcMsgToSyncQueue;
@@ -262,15 +258,15 @@ static int32_t vmInit(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   pMgmt->msgCb.queueFps[FETCH_QUEUE] = (PutToQueueFp)vmPutRpcMsgToFetchQueue;
   pMgmt->msgCb.queueFps[MERGE_QUEUE] = (PutToQueueFp)vmPutRpcMsgToMergeQueue;
   pMgmt->msgCb.qsizeFp = (GetQueueSizeFp)vmGetQueueSize;
-  pMgmt->msgCb.pMgmt = pMgmt;
+  pMgmt->msgCb.mgmt = pMgmt;
   taosInitRWLatch(&pMgmt->latch);
 
   SDiskCfg dCfg = {0};
-  tstrncpy(dCfg.dir, pInput->dataDir, TSDB_FILENAME_LEN);
+  tstrncpy(dCfg.dir, tsDataDir, TSDB_FILENAME_LEN);
   dCfg.level = 0;
   dCfg.primary = 1;
-  SDiskCfg *pDisks = pInput->disks;
+  SDiskCfg *pDisks = tsDiskCfg;
-  int32_t   numOfDisks = pInput->numOfDisks;
+  int32_t   numOfDisks = tsDiskCfgNum;
   if (numOfDisks <= 0 || pDisks == NULL) {
     pDisks = &dCfg;
     numOfDisks = 1;
@@ -323,7 +319,6 @@ static int32_t vmInit(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
 _OVER:
   if (code == 0) {
     pOutput->pMgmt = pMgmt;
-    dInfo("vnodes-mgmt is initialized");
   } else {
     dError("failed to init vnodes-mgmt since %s", terrstr());
     vmCleanup(pMgmt);
@@ -333,12 +328,11 @@ _OVER:
 }
 
 static int32_t vmRequire(const SMgmtInputOpt *pInput, bool *required) {
-  *required = pInput->supportVnodes > 0;
+  *required = tsNumOfSupportVnodes > 0;
   return 0;
 }
 
 static int32_t vmStart(SVnodeMgmt *pMgmt) {
-  dDebug("vnode-mgmt start to run");
   taosRLockLatch(&pMgmt->latch);
 
   void *pIter = taosHashIterate(pMgmt->hash, NULL);

source/dnode/mgmt/mgmt_vnode/src/vmWorker.c

@@ -19,24 +19,22 @@
 #include "sync.h"
 #include "syncTools.h"
 
-static inline void vmSendRsp(SNodeMsg *pMsg, int32_t code) {
+static inline void vmSendRsp(SRpcMsg *pMsg, int32_t code) {
   SRpcMsg rsp = {
-      .handle = pMsg->rpcMsg.handle,
-      .ahandle = pMsg->rpcMsg.ahandle,
-      .refId = pMsg->rpcMsg.refId,
       .code = code,
-      .pCont = pMsg->pRsp,
+      .info = pMsg->info,
-      .contLen = pMsg->rspLen,
+      .pCont = pMsg->info.rsp,
+      .contLen = pMsg->info.rspLen,
   };
   tmsgSendRsp(&rsp);
 }
 
-static void vmProcessMgmtMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void vmProcessMgmtMonitorQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SVnodeMgmt *pMgmt = pInfo->ahandle;
 
   int32_t code = -1;
-  tmsg_t  msgType = pMsg->rpcMsg.msgType;
+  tmsg_t  msgType = pMsg->msgType;
-  dTrace("msg:%p, will be processed in vnode-mgmt/monitor queue", pMsg);
+  dTrace("msg:%p, get from vnode queue, type:%s", pMsg, TMSG_INFO(msgType));
 
   switch (msgType) {
     case TDMT_MON_VM_INFO:
@@ -62,36 +60,36 @@ static void vmProcessMgmtMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   }
 
   dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-  rpcFreeCont(pMsg->rpcMsg.pCont);
+  rpcFreeCont(pMsg->pCont);
   taosFreeQitem(pMsg);
 }
 
-static void vmProcessQueryQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void vmProcessQueryQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SVnodeObj *pVnode = pInfo->ahandle;
 
   dTrace("msg:%p, will be processed in vnode-query queue", pMsg);
-  int32_t code = vnodeProcessQueryMsg(pVnode->pImpl, &pMsg->rpcMsg);
+  int32_t code = vnodeProcessQueryMsg(pVnode->pImpl, pMsg);
   if (code != 0) {
     if (terrno != 0) code = terrno;
     vmSendRsp(pMsg, code);
 
     dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-    rpcFreeCont(pMsg->rpcMsg.pCont);
+    rpcFreeCont(pMsg->pCont);
     taosFreeQitem(pMsg);
   }
 }
 
-static void vmProcessFetchQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+static void vmProcessFetchQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SVnodeObj *pVnode = pInfo->ahandle;
 
   dTrace("msg:%p, will be processed in vnode-fetch queue", pMsg);
-  int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, &pMsg->rpcMsg, pInfo);
+  int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, pMsg, pInfo);
   if (code != 0) {
     if (terrno != 0) code = terrno;
     vmSendRsp(pMsg, code);
 
     dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-    rpcFreeCont(pMsg->rpcMsg.pCont);
+    rpcFreeCont(pMsg->pCont);
     taosFreeQitem(pMsg);
   }
 }
@@ -100,14 +98,14 @@ static void vmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
   SVnodeObj *pVnode = pInfo->ahandle;
   SRpcMsg    rsp;
 
-  SArray *pArray = taosArrayInit(numOfMsgs, sizeof(SNodeMsg *));
+  SArray *pArray = taosArrayInit(numOfMsgs, sizeof(SRpcMsg *));
   if (pArray == NULL) {
     dError("failed to process %d msgs in write-queue since %s", numOfMsgs, terrstr());
     return;
   }
 
   for (int32_t i = 0; i < numOfMsgs; ++i) {
-    SNodeMsg *pMsg = NULL;
+    SRpcMsg *pMsg = NULL;
     if (taosGetQitem(qall, (void **)&pMsg) == 0) continue;
 
     dTrace("msg:%p, will be processed in vnode-write queue", pMsg);
@@ -118,15 +116,13 @@ static void vmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
   }
 
   for (int i = 0; i < taosArrayGetSize(pArray); i++) {
-    SNodeMsg *pMsg;
+    SRpcMsg *pMsg;
     SRpcMsg  *pRpc;
 
-    pMsg = *(SNodeMsg **)taosArrayGet(pArray, i);
+    pMsg = *(SRpcMsg **)taosArrayGet(pArray, i);
-    pRpc = &pMsg->rpcMsg;
+    pRpc = pMsg;
 
-    rsp.ahandle = pRpc->ahandle;
+    rsp.info = pRpc->info;
-    rsp.handle = pRpc->handle;
-    rsp.refId = pRpc->refId;
     rsp.pCont = NULL;
     rsp.contLen = 0;
 
@@ -153,9 +149,9 @@ static void vmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
   }
 
   for (int32_t i = 0; i < numOfMsgs; i++) {
-    SNodeMsg *pMsg = *(SNodeMsg **)taosArrayGet(pArray, i);
+    SRpcMsg *pMsg = *(SRpcMsg **)taosArrayGet(pArray, i);
     dTrace("msg:%p, is freed", pMsg);
-    rpcFreeCont(pMsg->rpcMsg.pCont);
+    rpcFreeCont(pMsg->pCont);
     taosFreeQitem(pMsg);
   }
 
@@ -164,7 +160,7 @@ static void vmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
 
 static void vmProcessApplyQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
   SVnodeObj *pVnode = pInfo->ahandle;
-  SNodeMsg  *pMsg = NULL;
+  SRpcMsg  *pMsg = NULL;
   SRpcMsg    rsp;
 
   for (int32_t i = 0; i < numOfMsgs; ++i) {
@@ -176,8 +172,8 @@ static void vmProcessApplyQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
     rsp.contLen = 0;
 
     // get original rpc msg
-    assert(pMsg->rpcMsg.msgType == TDMT_VND_SYNC_APPLY_MSG);
+    assert(pMsg->msgType == TDMT_VND_SYNC_APPLY_MSG);
-    SyncApplyMsg *pSyncApplyMsg = syncApplyMsgFromRpcMsg2(&pMsg->rpcMsg);
+    SyncApplyMsg *pSyncApplyMsg = syncApplyMsgFromRpcMsg2(pMsg);
     syncApplyMsgLog2("==vmProcessApplyQueue==", pSyncApplyMsg);
     SRpcMsg originalRpcMsg;
     syncApplyMsg2OriginalRpcMsg(pSyncApplyMsg, &originalRpcMsg);
@@ -192,56 +188,65 @@ static void vmProcessApplyQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
     rpcFreeCont(originalRpcMsg.pCont);
 
     // if leader, send response
-    if (pMsg->rpcMsg.handle != NULL && pMsg->rpcMsg.ahandle != NULL) {
+    // if (pMsg->rpcMsg.handle != NULL && pMsg->rpcMsg.ahandle != NULL) {
-      rsp.ahandle = pMsg->rpcMsg.ahandle;
+    if (pMsg->info.handle != NULL) {
-      rsp.handle = pMsg->rpcMsg.handle;
+      rsp.info = pMsg->info;
-      rsp.refId = pMsg->rpcMsg.refId;
       tmsgSendRsp(&rsp);
     }
 
-    rpcFreeCont(pMsg->rpcMsg.pCont);
+    rpcFreeCont(pMsg->pCont);
     taosFreeQitem(pMsg);
   }
 }
 
 static void vmProcessSyncQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
   SVnodeObj *pVnode = pInfo->ahandle;
-  SNodeMsg  *pMsg = NULL;
+  SRpcMsg   *pMsg = NULL;
 
   for (int32_t i = 0; i < numOfMsgs; ++i) {
     taosGetQitem(qall, (void **)&pMsg);
 
     // todo
     SRpcMsg *pRsp = NULL;
-    (void)vnodeProcessSyncReq(pVnode->pImpl, &pMsg->rpcMsg, &pRsp);
+    int32_t  ret = vnodeProcessSyncReq(pVnode->pImpl, pMsg, &pRsp);
+    if (ret != 0) {
+      // if leader, send response
+      if (pMsg->info.handle != NULL) {
+        SRpcMsg rsp = {0};
+        rsp.code = terrno;
+        rsp.info = pMsg->info;
+        dTrace("vmProcessSyncQueue error, code:%d", terrno);
+        tmsgSendRsp(&rsp);
+      }
+    }
 
-    rpcFreeCont(pMsg->rpcMsg.pCont);
+    rpcFreeCont(pMsg->pCont);
     taosFreeQitem(pMsg);
   }
 }
 
 static void vmProcessMergeQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
   SVnodeObj *pVnode = pInfo->ahandle;
-  SNodeMsg  *pMsg = NULL;
+  SRpcMsg  *pMsg = NULL;
 
   for (int32_t i = 0; i < numOfMsgs; ++i) {
     taosGetQitem(qall, (void **)&pMsg);
 
     dTrace("msg:%p, will be processed in vnode-merge queue", pMsg);
-    int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, &pMsg->rpcMsg, pInfo);
+    int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, pMsg, pInfo);
     if (code != 0) {
       if (terrno != 0) code = terrno;
       vmSendRsp(pMsg, code);
 
       dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-      rpcFreeCont(pMsg->rpcMsg.pCont);
+      rpcFreeCont(pMsg->pCont);
       taosFreeQitem(pMsg);
     }
   }
 }
 
-static int32_t vmPutNodeMsgToQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg, EQueueType qtype) {
+static int32_t vmPutNodeMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtype) {
-  SRpcMsg  *pRpc = &pMsg->rpcMsg;
+  SRpcMsg  *pRpc = pMsg;
   SMsgHead *pHead = pRpc->pCont;
   int32_t   code = 0;
 
@@ -285,34 +290,34 @@ static int32_t vmPutNodeMsgToQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg, EQueueType
   return code;
 }
 
-int32_t vmPutNodeMsgToSyncQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t vmPutNodeMsgToSyncQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   return vmPutNodeMsgToQueue(pMgmt, pMsg, SYNC_QUEUE);
 }
 
-int32_t vmPutNodeMsgToWriteQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t vmPutNodeMsgToWriteQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   return vmPutNodeMsgToQueue(pMgmt, pMsg, WRITE_QUEUE);
 }
 
-int32_t vmPutNodeMsgToQueryQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t vmPutNodeMsgToQueryQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   return vmPutNodeMsgToQueue(pMgmt, pMsg, QUERY_QUEUE);
 }
 
-int32_t vmPutNodeMsgToFetchQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t vmPutNodeMsgToFetchQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   return vmPutNodeMsgToQueue(pMgmt, pMsg, FETCH_QUEUE);
 }
 
-int32_t vmPutNodeMsgToMergeQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t vmPutNodeMsgToMergeQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   return vmPutNodeMsgToQueue(pMgmt, pMsg, MERGE_QUEUE);
 }
 
-int32_t vmPutNodeMsgToMgmtQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t vmPutNodeMsgToMgmtQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SSingleWorker *pWorker = &pMgmt->mgmtWorker;
   dTrace("msg:%p, will be put into vnode-mgmt queue, worker:%s", pMsg, pWorker->name);
   taosWriteQitem(pWorker->queue, pMsg);
   return 0;
 }
 
-int32_t vmPutNodeMsgToMonitorQueue(SVnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+int32_t vmPutNodeMsgToMonitorQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SSingleWorker *pWorker = &pMgmt->monitorWorker;
 
   dTrace("msg:%p, will be put into vnode-monitor queue, worker:%s", pMsg, pWorker->name);
@@ -326,13 +331,13 @@ static int32_t vmPutRpcMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pRpc, EQueueType q
   SVnodeObj *pVnode = vmAcquireVnode(pMgmt, pHead->vgId);
   if (pVnode == NULL) return -1;
 
-  SNodeMsg *pMsg = taosAllocateQitem(sizeof(SNodeMsg), RPC_QITEM);
+  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
   int32_t   code = 0;
 
   if (pMsg != NULL) {
     dTrace("msg:%p, is created, type:%s", pMsg, TMSG_INFO(pRpc->msgType));
-    pMsg->rpcMsg = *pRpc;
+    memcpy(pMsg, pRpc, sizeof(SRpcMsg));
-    // if (pMsg->rpcMsg.handle != NULL) assert(pMsg->rpcMsg.refId != 0);
+    // if (pMsg->handle != NULL) assert(pMsg->refId != 0);
     switch (qtype) {
       case WRITE_QUEUE:
         dTrace("msg:%p, will be put into vnode-write queue", pMsg);

source/dnode/mgmt/node_mgmt/inc/dmMgmt.h

@@ -19,40 +19,74 @@
 // tobe deleted
 #include "uv.h"
 
-#include "dmUtil.h"
 #include "dmInt.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+typedef struct SMgmtWrapper SMgmtWrapper;
+
+#define SINGLE_PROC               0
+#define CHILD_PROC                1
+#define PARENT_PROC               2
+#define TEST_PROC                 3
+#define OnlyInSingleProc(wrapper) ((wrapper)->proc.ptype == SINGLE_PROC)
+#define OnlyInChildProc(wrapper)  ((wrapper)->proc.ptype == CHILD_PROC)
+#define OnlyInParentProc(wrapper) ((wrapper)->proc.ptype == PARENT_PROC)
+#define InChildProc(wrapper)      ((wrapper)->proc.ptype & CHILD_PROC)
+#define InParentProc(wrapper)     ((wrapper)->proc.ptype & PARENT_PROC)
+
+typedef struct {
+  int32_t       head;
+  int32_t       tail;
+  int32_t       total;
+  int32_t       avail;
+  int32_t       items;
+  char          name[8];
+  TdThreadMutex mutex;
+  tsem_t        sem;
+  char          pBuffer[];
+} SProcQueue;
+
+typedef struct {
+  SMgmtWrapper *wrapper;
+  const char   *name;
+  SHashObj     *hash;
+  SProcQueue   *pqueue;
+  SProcQueue   *cqueue;
+  TdThread      pthread;
+  TdThread      cthread;
+  SShm          shm;
+  int32_t       pid;
+  EDndProcType  ptype;
+  bool          stop;
+} SProc;
+
 typedef struct SMgmtWrapper {
-  SDnode      *pDnode;
   SMgmtFunc      func;
+  struct SDnode *pDnode;
   void          *pMgmt;
   const char    *name;
   char          *path;
   int32_t        refCount;
   SRWLatch       latch;
-  EDndNodeType nodeType;
+  EDndNodeType   ntype;
   bool           deployed;
   bool           required;
-  EDndProcType procType;
+  SProc          proc;
-  int32_t      procId;
-  SProcObj    *procObj;
-  SShm         procShm;
   NodeMsgFp      msgFps[TDMT_MAX];
 } SMgmtWrapper;
 
 typedef struct {
   EDndNodeType defaultNtype;
   bool         needCheckVgId;
-} SMsgHandle;
+} SDnodeHandle;
 
 typedef struct {
   void        *serverRpc;
   void        *clientRpc;
-  SMsgHandle msgHandles[TDMT_MAX];
+  SDnodeHandle msgHandles[TDMT_MAX];
 } SDnodeTrans;
 
 typedef struct {
@@ -75,48 +109,63 @@ typedef struct SUdfdData {
 } SUdfdData;
 
 typedef struct SDnode {
+  int8_t        once;
+  bool          stop;
   EDndProcType  ptype;
-  EDndNodeType  ntype;
+  EDndNodeType  rtype;
-  EDndEvent     event;
   EDndRunStatus status;
   SStartupInfo  startup;
   SDnodeTrans   trans;
   SUdfdData     udfdData;
   TdThreadMutex mutex;
-  SRWLatch      latch;
-  SEpSet        mnodeEps;
   TdFilePtr     lockfile;
-  SMgmtInputOpt input;
+  SDnodeData    data;
   SMgmtWrapper  wrappers[NODE_END];
 } SDnode;
 
-// dmExec.c
+// dmEnv.c
-int32_t dmOpenNode(SMgmtWrapper *pWrapper);
+SDnode *dmInstance();
-void    dmCloseNode(SMgmtWrapper *pWrapper);
+void    dmReportStartup(const char *pName, const char *pDesc);
 
-// dmObj.c
+// dmMgmt.c
+int32_t       dmInitDnode(SDnode *pDnode, EDndNodeType rtype);
+void          dmCleanupDnode(SDnode *pDnode);
 SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType nType);
 int32_t       dmMarkWrapper(SMgmtWrapper *pWrapper);
 void          dmReleaseWrapper(SMgmtWrapper *pWrapper);
+SMgmtInputOpt dmBuildMgmtInputOpt(SMgmtWrapper *pWrapper);
 
 void dmSetStatus(SDnode *pDnode, EDndRunStatus stype);
-void dmSetEvent(SDnode *pDnode, EDndEvent event);
-void dmReportStartup(SDnode *pDnode, const char *pName, const char *pDesc);
-void dmReportStartupByWrapper(SMgmtWrapper *pWrapper, const char *pName, const char *pDesc);
-
 void dmProcessServerStartupStatus(SDnode *pDnode, SRpcMsg *pMsg);
 void dmProcessNetTestReq(SDnode *pDnode, SRpcMsg *pMsg);
-int32_t dmProcessCreateNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg);
+
-int32_t dmProcessDropNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg);
+// dmNodes.c
+int32_t dmOpenNode(SMgmtWrapper *pWrapper);
+int32_t dmStartNode(SMgmtWrapper *pWrapper);
+void    dmStopNode(SMgmtWrapper *pWrapper);
+void    dmCloseNode(SMgmtWrapper *pWrapper);
+int32_t dmRunDnode(SDnode *pDnode);
+
+// dmProc.c
+int32_t dmInitProc(struct SMgmtWrapper *pWrapper);
+void    dmCleanupProc(struct SMgmtWrapper *pWrapper);
+int32_t dmRunProc(SProc *proc);
+void    dmStopProc(SProc *proc);
+int64_t dmRemoveProcRpcHandle(SProc *proc, void *handle);
+void    dmCloseProcRpcHandles(SProc *proc);
+int32_t dmPutToProcCQueue(SProc *proc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
+                          void *handle, int64_t handleRef, EProcFuncType ftype);
+void    dmPutToProcPQueue(SProc *proc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
+                          EProcFuncType ftype);
 
 // dmTransport.c
 int32_t dmInitServer(SDnode *pDnode);
 void    dmCleanupServer(SDnode *pDnode);
 int32_t dmInitClient(SDnode *pDnode);
 void    dmCleanupClient(SDnode *pDnode);
-SProcCfg dmGenProcCfg(SMgmtWrapper *pWrapper);
+SMsgCb  dmGetMsgcb(SDnode *pDnode);
-SMsgCb   dmGetMsgcb(SMgmtWrapper *pWrapper);
 int32_t dmInitMsgHandle(SDnode *pDnode);
+int32_t dmProcessNodeMsg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
 
 // mgmt nodes
 SMgmtFunc dmGetMgmtFunc();

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

@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "dmMgmt.h"
+
+static SDnode global = {0};
+
+SDnode *dmInstance() { return &global; }
+
+static int32_t dmCheckRepeatInit(SDnode *pDnode) {
+  if (atomic_val_compare_exchange_8(&pDnode->once, DND_ENV_INIT, DND_ENV_READY) != DND_ENV_INIT) {
+    dError("env is already initialized");
+    terrno = TSDB_CODE_REPEAT_INIT;
+    return -1;
+  }
+  return 0;
+}
+
+static int32_t dmInitSystem() {
+  taosIgnSIGPIPE();
+  taosBlockSIGPIPE();
+  taosResolveCRC();
+  return 0;
+}
+
+static int32_t dmInitMonitor() {
+  SMonCfg monCfg = {0};
+  monCfg.maxLogs = tsMonitorMaxLogs;
+  monCfg.port = tsMonitorPort;
+  monCfg.server = tsMonitorFqdn;
+  monCfg.comp = tsMonitorComp;
+  if (monInit(&monCfg) != 0) {
+    dError("failed to init monitor since %s", terrstr());
+    return -1;
+  }
+  return 0;
+}
+
+int32_t dmInit(int8_t rtype) {
+  dInfo("start to init env");
+  if (dmCheckRepeatInit(dmInstance()) != 0) return -1;
+  if (dmInitSystem() != 0) return -1;
+  if (dmInitMonitor() != 0) return -1;
+  if (dmInitDnode(dmInstance(), rtype) != 0) return -1;
+
+  dInfo("env is initialized");
+  return 0;
+}
+
+static int32_t dmCheckRepeatCleanup(SDnode *pDnode) {
+  if (atomic_val_compare_exchange_8(&pDnode->once, DND_ENV_READY, DND_ENV_CLEANUP) != DND_ENV_READY) {
+    dError("env is already cleaned up");
+    return -1;
+  }
+  return 0;
+}
+
+void dmCleanup() {
+  dDebug("start to cleanup env");
+  SDnode *pDnode = dmInstance();
+  if (dmCheckRepeatCleanup(pDnode) != 0) return;
+  dmCleanupDnode(pDnode);
+  monCleanup();
+  syncCleanUp();
+  walCleanUp();
+  udfcClose();
+  udfStopUdfd();
+  taosStopCacheRefreshWorker();
+  dInfo("env is cleaned up");
+
+  taosCloseLog();
+  taosCleanupCfg();
+}
+
+void dmStop() {
+  SDnode *pDnode = dmInstance();
+  pDnode->stop = true;
+}
+
+int32_t dmRun() {
+  SDnode *pDnode = dmInstance();
+  return dmRunDnode(pDnode);
+}
+
+static int32_t dmProcessCreateNodeReq(EDndNodeType ntype, SRpcMsg *pMsg) {
+  SDnode *pDnode = dmInstance();
+
+  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, ntype);
+  if (pWrapper != NULL) {
+    dmReleaseWrapper(pWrapper);
+    terrno = TSDB_CODE_NODE_ALREADY_DEPLOYED;
+    dError("failed to create node since %s", terrstr());
+    return -1;
+  }
+
+  pWrapper = &pDnode->wrappers[ntype];
+  if (taosMkDir(pWrapper->path) != 0) {
+    dmReleaseWrapper(pWrapper);
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to create dir:%s since %s", pWrapper->path, terrstr());
+    return -1;
+  }
+
+  taosThreadMutexLock(&pDnode->mutex);
+  SMgmtInputOpt input = dmBuildMgmtInputOpt(pWrapper);
+
+  dInfo("node:%s, start to create", pWrapper->name);
+  int32_t code = (*pWrapper->func.createFp)(&input, pMsg);
+  if (code != 0) {
+    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;
+    pWrapper->deployed = true;
+    pWrapper->proc.ptype = pDnode->ptype;
+  }
+
+  taosThreadMutexUnlock(&pDnode->mutex);
+  return code;
+}
+
+static int32_t dmProcessDropNodeReq(EDndNodeType ntype, SRpcMsg *pMsg) {
+  SDnode *pDnode = dmInstance();
+
+  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, ntype);
+  if (pWrapper == NULL) {
+    terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
+    dError("failed to drop node since %s", terrstr());
+    return -1;
+  }
+
+  taosThreadMutexLock(&pDnode->mutex);
+  SMgmtInputOpt input = dmBuildMgmtInputOpt(pWrapper);
+
+  dInfo("node:%s, start to drop", pWrapper->name);
+  int32_t code = (*pWrapper->func.dropFp)(&input, pMsg);
+  if (code != 0) {
+    dError("node:%s, failed to drop since %s", pWrapper->name, terrstr());
+  } else {
+    dInfo("node:%s, has been dropped", pWrapper->name);
+    pWrapper->required = false;
+    pWrapper->deployed = false;
+  }
+
+  dmReleaseWrapper(pWrapper);
+
+  if (code == 0) {
+    dmStopNode(pWrapper);
+    dmCloseNode(pWrapper);
+    taosRemoveDir(pWrapper->path);
+  }
+  taosThreadMutexUnlock(&pDnode->mutex);
+  return code;
+}
+
+static bool dmIsNodeRequired(EDndNodeType ntype) {
+  SDnode *pDnode = dmInstance();
+  return pDnode->wrappers[ntype].required;
+}
+
+SMgmtInputOpt dmBuildMgmtInputOpt(SMgmtWrapper *pWrapper) {
+  SMgmtInputOpt opt = {
+      .path = pWrapper->path,
+      .name = pWrapper->name,
+      .pData = &pWrapper->pDnode->data,
+      .processCreateNodeFp = dmProcessCreateNodeReq,
+      .processDropNodeFp = dmProcessDropNodeReq,
+      .isNodeRequiredFp = dmIsNodeRequired,
+  };
+
+  opt.msgCb = dmGetMsgcb(pWrapper->pDnode);
+  return opt;
+}
+
+void dmReportStartup(const char *pName, const char *pDesc) {
+  SStartupInfo *pStartup = &(dmInstance()->startup);
+  tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
+  tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
+  dDebug("step:%s, %s", pStartup->name, pStartup->desc);
+}

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

@@ -16,39 +16,81 @@
 #define _DEFAULT_SOURCE
 #include "dmMgmt.h"
 
-static bool dmIsNodeDeployedFp(SDnode *pDnode, EDndNodeType ntype) { return pDnode->wrappers[ntype].required; }
+static bool dmRequireNode(SDnode *pDnode, SMgmtWrapper *pWrapper) {
+  SMgmtInputOpt input = dmBuildMgmtInputOpt(pWrapper);
 
-static int32_t dmInitVars(SDnode *pDnode, const SDnodeOpt *pOption) {
+  bool    required = false;
-  pDnode->input.dnodeId = 0;
+  int32_t code = (*pWrapper->func.requiredFp)(&input, &required);
-  pDnode->input.clusterId = 0;
+  if (!required) {
-  pDnode->input.localEp = strdup(pOption->localEp);
+    dDebug("node:%s, does not require startup", pWrapper->name);
-  pDnode->input.localFqdn = strdup(pOption->localFqdn);
+  }
-  pDnode->input.firstEp = strdup(pOption->firstEp);
-  pDnode->input.secondEp = strdup(pOption->secondEp);
-  pDnode->input.serverPort = pOption->serverPort;
-  pDnode->input.supportVnodes = pOption->numOfSupportVnodes;
-  pDnode->input.numOfDisks = pOption->numOfDisks;
-  pDnode->input.disks = pOption->disks;
-  pDnode->input.dataDir = strdup(pOption->dataDir);
-  pDnode->input.pDnode = pDnode;
-  pDnode->input.processCreateNodeFp = dmProcessCreateNodeReq;
-  pDnode->input.processDropNodeFp = dmProcessDropNodeReq;
-  pDnode->input.isNodeDeployedFp = dmIsNodeDeployedFp;
 
-  if (pDnode->input.dataDir == NULL || pDnode->input.localEp == NULL || pDnode->input.localFqdn == NULL ||
+  if (pWrapper->ntype == DNODE) {
-      pDnode->input.firstEp == NULL || pDnode->input.secondEp == NULL) {
+    if (pDnode->rtype != DNODE && pDnode->rtype != NODE_END) {
+      required = false;
+      dDebug("node:%s, does not require startup in child process", pWrapper->name);
+    }
+  } else {
+    if (OnlyInChildProc(pWrapper)) {
+      if (pWrapper->ntype != pDnode->rtype) {
+        dDebug("node:%s, does not require startup in child process", pWrapper->name);
+        required = false;
+      }
+    }
+  }
+
+  if (required) {
+    dDebug("node:%s, required to startup", pWrapper->name);
+  }
+
+  return required;
+}
+
+static int32_t dmInitVars(SDnode *pDnode, EDndNodeType rtype) {
+  pDnode->rtype = rtype;
+
+  if (tsMultiProcess == 0) {
+    pDnode->ptype = DND_PROC_SINGLE;
+    dInfo("dnode will run in single-process mode");
+  } else if (tsMultiProcess > 1) {
+    pDnode->ptype = DND_PROC_TEST;
+    dInfo("dnode will run in multi-process test mode");
+  } else if (pDnode->rtype == DNODE || pDnode->rtype == NODE_END) {
+    pDnode->ptype = DND_PROC_PARENT;
+    dInfo("dnode will run in parent-process mode");
+  } else {
+    pDnode->ptype = DND_PROC_CHILD;
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[pDnode->rtype];
+    dInfo("dnode will run in child-process mode, node:%s", dmNodeName(pDnode->rtype));
+  }
+
+  SDnodeData *pData = &pDnode->data;
+  pData->dnodeId = 0;
+  pData->clusterId = 0;
+  pData->dnodeVer = 0;
+  pData->updateTime = 0;
+  pData->rebootTime = taosGetTimestampMs();
+  pData->dropped = 0;
+  pData->stopped = 0;
+
+  pData->dnodeHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
+  if (pData->dnodeHash == NULL) {
+    dError("failed to init dnode hash");
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
 
-  pDnode->ntype = pOption->ntype;
+  if (dmReadEps(pData) != 0) {
-  if (!tsMultiProcess || pDnode->ntype == DNODE || pDnode->ntype == NODE_END) {
+    dError("failed to read file since %s", terrstr());
-    pDnode->lockfile = dmCheckRunning(pOption->dataDir);
-    if (pDnode->lockfile == NULL) {
     return -1;
   }
+
+  if (pData->dropped) {
+    dError("dnode will not start since its already dropped");
+    return -1;
   }
 
+  taosInitRWLatch(&pData->latch);
   taosThreadMutexInit(&pDnode->mutex, NULL);
   return 0;
 }
@@ -64,48 +106,31 @@ static void dmClearVars(SDnode *pDnode) {
     pDnode->lockfile = NULL;
   }
 
-  taosMemoryFreeClear(pDnode->input.localEp);
+  SDnodeData *pData = &pDnode->data;
-  taosMemoryFreeClear(pDnode->input.localFqdn);
+  taosWLockLatch(&pData->latch);
-  taosMemoryFreeClear(pDnode->input.firstEp);
+  if (pData->dnodeEps != NULL) {
-  taosMemoryFreeClear(pDnode->input.secondEp);
+    taosArrayDestroy(pData->dnodeEps);
-  taosMemoryFreeClear(pDnode->input.dataDir);
+    pData->dnodeEps = NULL;
+  }
+  if (pData->dnodeHash != NULL) {
+    taosHashCleanup(pData->dnodeHash);
+    pData->dnodeHash = NULL;
+  }
+  taosWUnLockLatch(&pData->latch);
 
   taosThreadMutexDestroy(&pDnode->mutex);
   memset(&pDnode->mutex, 0, sizeof(pDnode->mutex));
-  taosMemoryFree(pDnode);
-  dDebug("dnode memory is cleared, data:%p", pDnode);
 }
 
-static bool dmRequireNode(SMgmtWrapper *pWrapper) {
+int32_t dmInitDnode(SDnode *pDnode, EDndNodeType rtype) {
-  SMgmtInputOpt *pInput = &pWrapper->pDnode->input;
-  pInput->name = pWrapper->name;
-  pInput->path = pWrapper->path;
-
-  bool    required = false;
-  int32_t code = (*pWrapper->func.requiredFp)(pInput, &required);
-  if (!required) {
-    dDebug("node:%s, does not require startup", pWrapper->name);
-  }
-  return required;
-}
-
-SDnode *dmCreate(const SDnodeOpt *pOption) {
   dInfo("start to create dnode");
   int32_t code = -1;
   char    path[PATH_MAX + 100] = {0};
-  SDnode *pDnode = NULL;
 
-  pDnode = taosMemoryCalloc(1, sizeof(SDnode));
+  if (dmInitVars(pDnode, rtype) != 0) {
-  if (pDnode == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;
   }
 
-  if (dmInitVars(pDnode, pOption) != 0) {
-    goto _OVER;
-  }
-
-  dmSetStatus(pDnode, DND_STAT_INIT);
   pDnode->wrappers[DNODE].func = dmGetMgmtFunc();
   pDnode->wrappers[MNODE].func = mmGetMgmtFunc();
   pDnode->wrappers[VNODE].func = vmGetMgmtFunc();
@@ -117,24 +142,29 @@ SDnode *dmCreate(const SDnodeOpt *pOption) {
     SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
     pWrapper->pDnode = pDnode;
     pWrapper->name = dmNodeName(ntype);
-    pWrapper->procShm.id = -1;
+    pWrapper->ntype = ntype;
-    pWrapper->nodeType = ntype;
+    pWrapper->proc.wrapper = pWrapper;
-    pWrapper->procType = DND_PROC_SINGLE;
+    pWrapper->proc.shm.id = -1;
+    pWrapper->proc.pid = -1;
+    pWrapper->proc.ptype = pDnode->ptype;
+    if (ntype == DNODE) {
+      pWrapper->proc.ptype = DND_PROC_SINGLE;
+    }
     taosInitRWLatch(&pWrapper->latch);
 
-    snprintf(path, sizeof(path), "%s%s%s", pOption->dataDir, TD_DIRSEP, pWrapper->name);
+    snprintf(path, sizeof(path), "%s%s%s", tsDataDir, TD_DIRSEP, pWrapper->name);
     pWrapper->path = strdup(path);
     if (pWrapper->path == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       goto _OVER;
     }
 
-    if (ntype != DNODE && dmReadShmFile(pWrapper->path, pWrapper->name, pDnode->ntype, &pWrapper->procShm) != 0) {
+    pWrapper->required = dmRequireNode(pDnode, pWrapper);
+
+    if (ntype != DNODE && dmReadShmFile(pWrapper->path, pWrapper->name, pDnode->rtype, &pWrapper->proc.shm) != 0) {
       dError("node:%s, failed to read shm file since %s", pWrapper->name, terrstr());
       goto _OVER;
     }
-
-    pWrapper->required = dmRequireNode(pWrapper);
   }
 
   if (dmInitMsgHandle(pDnode) != 0) {
@@ -142,11 +172,24 @@ SDnode *dmCreate(const SDnodeOpt *pOption) {
     goto _OVER;
   }
 
+  if (pDnode->ptype == SINGLE_PROC || (pDnode->ptype & PARENT_PROC)) {
+    pDnode->lockfile = dmCheckRunning(tsDataDir);
+    if (pDnode->lockfile == NULL) {
+      goto _OVER;
+    }
+
+    if (dmInitServer(pDnode) != 0) {
+      dError("failed to init transport since %s", terrstr());
+      goto _OVER;
+    }
+  }
+
   if (dmInitClient(pDnode) != 0) {
     goto _OVER;
   }
 
-  dInfo("dnode is created, data:%p", pDnode);
+  dmReportStartup("dnode-transport", "initialized");
+  dInfo("dnode is created, ptr:%p", pDnode);
   code = 0;
 
 _OVER:
@@ -156,17 +199,16 @@ _OVER:
     dError("failed to create dnode since %s", terrstr());
   }
 
-  return pDnode;
+  return code;
 }
 
-void dmClose(SDnode *pDnode) {
+void dmCleanupDnode(SDnode *pDnode) {
   if (pDnode == NULL) return;
 
   dmCleanupClient(pDnode);
   dmCleanupServer(pDnode);
-
   dmClearVars(pDnode);
-  dInfo("dnode is closed, data:%p", pDnode);
+  dInfo("dnode is closed, ptr:%p", pDnode);
 }
 
 void dmSetStatus(SDnode *pDnode, EDndRunStatus status) {
@@ -176,12 +218,6 @@ void dmSetStatus(SDnode *pDnode, EDndRunStatus status) {
   }
 }
 
-void dmSetEvent(SDnode *pDnode, EDndEvent event) {
-  if (event == DND_EVENT_STOP) {
-    pDnode->event = event;
-  }
-}
-
 SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType ntype) {
   SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
   SMgmtWrapper *pRetWrapper = pWrapper;
@@ -189,7 +225,7 @@ SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType ntype) {
   taosRLockLatch(&pWrapper->latch);
   if (pWrapper->deployed) {
     int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1);
-    dTrace("node:%s, is acquired, refCount:%d", pWrapper->name, refCount);
+    dTrace("node:%s, is acquired, ref:%d", pWrapper->name, refCount);
   } else {
     terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
     pRetWrapper = NULL;
@@ -203,9 +239,9 @@ int32_t dmMarkWrapper(SMgmtWrapper *pWrapper) {
   int32_t code = 0;
 
   taosRLockLatch(&pWrapper->latch);
-  if (pWrapper->deployed || (pWrapper->procType == DND_PROC_PARENT && pWrapper->required)) {
+  if (pWrapper->deployed || (InParentProc(pWrapper) && pWrapper->required)) {
     int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1);
-    dTrace("node:%s, is marked, refCount:%d", pWrapper->name, refCount);
+    dTrace("node:%s, is marked, ref:%d", pWrapper->name, refCount);
   } else {
     terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
     code = -1;
@@ -221,18 +257,7 @@ void dmReleaseWrapper(SMgmtWrapper *pWrapper) {
   taosRLockLatch(&pWrapper->latch);
   int32_t refCount = atomic_sub_fetch_32(&pWrapper->refCount, 1);
   taosRUnLockLatch(&pWrapper->latch);
-  dTrace("node:%s, is released, refCount:%d", pWrapper->name, refCount);
+  dTrace("node:%s, is released, ref:%d", pWrapper->name, refCount);
-}
-
-void dmReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) {
-  SStartupInfo *pStartup = &pDnode->startup;
-  tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
-  tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
-  dInfo("step:%s, %s", pStartup->name, pStartup->desc);
-}
-
-void dmReportStartupByWrapper(SMgmtWrapper *pWrapper, const char *pName, const char *pDesc) {
-  dmReportStartup(pWrapper->pDnode, pName, pDesc);
 }
 
 static void dmGetServerStartupStatus(SDnode *pDnode, SServerStatusRsp *pStatus) {
@@ -251,7 +276,7 @@ static void dmGetServerStartupStatus(SDnode *pDnode, SServerStatusRsp *pStatus)
 
 void dmProcessNetTestReq(SDnode *pDnode, SRpcMsg *pReq) {
   dDebug("net test req is received");
-  SRpcMsg rsp = {.handle = pReq->handle, .refId = pReq->refId, .ahandle = pReq->ahandle, .code = 0};
+  SRpcMsg rsp = {.code = 0, .info = pReq->info};
   rsp.pCont = rpcMallocCont(pReq->contLen);
   if (rsp.pCont == NULL) {
     rsp.code = TSDB_CODE_OUT_OF_MEMORY;
@@ -259,7 +284,6 @@ void dmProcessNetTestReq(SDnode *pDnode, SRpcMsg *pReq) {
     rsp.contLen = pReq->contLen;
   }
   rpcSendResponse(&rsp);
-  rpcFreeCont(pReq->pCont);
 }
 
 void dmProcessServerStartupStatus(SDnode *pDnode, SRpcMsg *pReq) {
@@ -268,7 +292,7 @@ void dmProcessServerStartupStatus(SDnode *pDnode, SRpcMsg *pReq) {
   SServerStatusRsp statusRsp = {0};
   dmGetServerStartupStatus(pDnode, &statusRsp);
 
-  SRpcMsg rspMsg = {.handle = pReq->handle, .ahandle = pReq->ahandle, .refId = pReq->refId};
+  SRpcMsg rspMsg = {.info = pReq->info};
   int32_t rspLen = tSerializeSServerStatusRsp(NULL, 0, &statusRsp);
   if (rspLen < 0) {
     rspMsg.code = TSDB_CODE_OUT_OF_MEMORY;
@@ -287,72 +311,4 @@ void dmProcessServerStartupStatus(SDnode *pDnode, SRpcMsg *pReq) {
 
 _OVER:
   rpcSendResponse(&rspMsg);
-  rpcFreeCont(pReq->pCont);
-}
-
-int32_t dmProcessCreateNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg) {
-  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, ntype);
-  if (pWrapper != NULL) {
-    dmReleaseWrapper(pWrapper);
-    terrno = TSDB_CODE_NODE_ALREADY_DEPLOYED;
-    dError("failed to create node since %s", terrstr());
-    return -1;
-  }
-
-  taosThreadMutexLock(&pDnode->mutex);
-  pWrapper = &pDnode->wrappers[ntype];
-
-  if (taosMkDir(pWrapper->path) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to create dir:%s since %s", pWrapper->path, terrstr());
-    return -1;
-  }
-
-  SMgmtInputOpt *pInput = &pWrapper->pDnode->input;
-  pInput->name = pWrapper->name;
-  pInput->path = pWrapper->path;
-  pInput->msgCb = dmGetMsgcb(pWrapper);
-
-  int32_t code = (*pWrapper->func.createFp)(pInput, pMsg);
-  if (code != 0) {
-    dError("node:%s, failed to create since %s", pWrapper->name, terrstr());
-  } else {
-    dDebug("node:%s, has been created", pWrapper->name);
-    (void)dmOpenNode(pWrapper);
-    pWrapper->required = true;
-    pWrapper->deployed = true;
-    pWrapper->procType = pDnode->ptype;
-  }
-
-  taosThreadMutexUnlock(&pDnode->mutex);
-  return code;
-}
-
-int32_t dmProcessDropNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg) {
-  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, ntype);
-  if (pWrapper == NULL) {
-    terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
-    dError("failed to drop node since %s", terrstr());
-    return -1;
-  }
-
-  taosThreadMutexLock(&pDnode->mutex);
-
-  int32_t code = (*pWrapper->func.dropFp)(pWrapper->pMgmt, pMsg);
-  if (code != 0) {
-    dError("node:%s, failed to drop since %s", pWrapper->name, terrstr());
-  } else {
-    dDebug("node:%s, has been dropped", pWrapper->name);
-    pWrapper->required = false;
-    pWrapper->deployed = false;
-  }
-
-  dmReleaseWrapper(pWrapper);
-
-  if (code == 0) {
-    dmCloseNode(pWrapper);
-    taosRemoveDir(pWrapper->path);
-  }
-  taosThreadMutexUnlock(&pDnode->mutex);
-  return code;
 }

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

@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "dmMgmt.h"
+
+static int32_t dmCreateShm(SMgmtWrapper *pWrapper) {
+  int32_t shmsize = tsMnodeShmSize;
+  if (pWrapper->ntype == VNODE) {
+    shmsize = tsVnodeShmSize;
+  } else if (pWrapper->ntype == QNODE) {
+    shmsize = tsQnodeShmSize;
+  } else if (pWrapper->ntype == SNODE) {
+    shmsize = tsSnodeShmSize;
+  } else if (pWrapper->ntype == MNODE) {
+    shmsize = tsMnodeShmSize;
+  } else if (pWrapper->ntype == BNODE) {
+    shmsize = tsBnodeShmSize;
+  } else {
+    return -1;
+  }
+
+  if (taosCreateShm(&pWrapper->proc.shm, pWrapper->ntype, shmsize) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(terrno);
+    dError("node:%s, failed to create shm size:%d since %s", pWrapper->name, shmsize, terrstr());
+    return -1;
+  }
+  dInfo("node:%s, shm:%d is created, size:%d", pWrapper->name, pWrapper->proc.shm.id, shmsize);
+  return 0;
+}
+
+static int32_t dmNewProc(SMgmtWrapper *pWrapper, EDndNodeType ntype) {
+  char  tstr[8] = {0};
+  char *args[6] = {0};
+  snprintf(tstr, sizeof(tstr), "%d", ntype);
+  args[1] = "-c";
+  args[2] = configDir;
+  args[3] = "-n";
+  args[4] = tstr;
+  args[5] = NULL;
+
+  int32_t pid = taosNewProc(args);
+  if (pid <= 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("node:%s, failed to exec in new process since %s", pWrapper->name, terrstr());
+    return -1;
+  }
+
+  pWrapper->proc.pid = pid;
+  dInfo("node:%s, continue running in new process:%d", pWrapper->name, pid);
+  return 0;
+}
+
+int32_t dmOpenNode(SMgmtWrapper *pWrapper) {
+  SDnode *pDnode = pWrapper->pDnode;
+
+  if (taosMkDir(pWrapper->path) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("node:%s, failed to create dir:%s since %s", pWrapper->name, pWrapper->path, terrstr());
+    return -1;
+  }
+
+  SMgmtOutputOpt output = {0};
+  SMgmtInputOpt  input = dmBuildMgmtInputOpt(pWrapper);
+
+  if (pWrapper->ntype == DNODE || InChildProc(pWrapper)) {
+    tmsgSetDefaultMsgCb(&input.msgCb);
+  }
+
+  if (OnlyInSingleProc(pWrapper)) {
+    dInfo("node:%s, start to open", pWrapper->name);
+    if ((*pWrapper->func.openFp)(&input, &output) != 0) {
+      dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
+      return -1;
+    }
+    dInfo("node:%s, has been opened", pWrapper->name);
+    pWrapper->deployed = true;
+  }
+
+  if (InParentProc(pWrapper)) {
+    dDebug("node:%s, start to open", pWrapper->name);
+    if (dmCreateShm(pWrapper) != 0) {
+      return -1;
+    }
+    if (dmWriteShmFile(pWrapper->path, pWrapper->name, &pWrapper->proc.shm) != 0) {
+      return -1;
+    }
+
+    if (OnlyInParentProc(pWrapper)) {
+      if (dmInitProc(pWrapper) != 0) {
+        dError("node:%s, failed to init proc since %s", pWrapper->name, terrstr());
+        return -1;
+      }
+      if (pDnode->rtype == NODE_END) {
+        dInfo("node:%s, should be started manually in child process", pWrapper->name);
+      } else {
+        if (dmNewProc(pWrapper, pWrapper->ntype) != 0) {
+          return -1;
+        }
+      }
+      if (dmRunProc(&pWrapper->proc) != 0) {
+        dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr());
+        return -1;
+      }
+    }
+    dDebug("node:%s, has been opened in parent process", pWrapper->name);
+  }
+
+  if (InChildProc(pWrapper)) {
+    dDebug("node:%s, start to open", pWrapper->name);
+    if ((*pWrapper->func.openFp)(&input, &output) != 0) {
+      dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
+      return -1;
+    }
+    if (dmInitProc(pWrapper) != 0) {
+      return -1;
+    }
+    if (dmRunProc(&pWrapper->proc) != 0) {
+      return -1;
+    }
+    dDebug("node:%s, has been opened in child process", pWrapper->name);
+    pWrapper->deployed = true;
+  }
+
+  if (output.pMgmt != NULL) {
+    pWrapper->pMgmt = output.pMgmt;
+  }
+
+  dmReportStartup(pWrapper->name, "openned");
+  return 0;
+}
+
+int32_t dmStartNode(SMgmtWrapper *pWrapper) {
+  if (OnlyInParentProc(pWrapper)) return 0;
+  if (pWrapper->func.startFp != NULL) {
+    dDebug("node:%s, start to start", pWrapper->name);
+    if ((*pWrapper->func.startFp)(pWrapper->pMgmt) != 0) {
+      dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
+      return -1;
+    }
+    dDebug("node:%s, has been started", pWrapper->name);
+  }
+
+  dmReportStartup(pWrapper->name, "started");
+  return 0;
+}
+
+void dmStopNode(SMgmtWrapper *pWrapper) {
+  if (pWrapper->func.stopFp != NULL && pWrapper->pMgmt != NULL) {
+    dDebug("node:%s, start to stop", pWrapper->name);
+    (*pWrapper->func.stopFp)(pWrapper->pMgmt);
+    dDebug("node:%s, has been stopped", pWrapper->name);
+  }
+}
+
+void dmCloseNode(SMgmtWrapper *pWrapper) {
+  dInfo("node:%s, start to close", pWrapper->name);
+  pWrapper->deployed = false;
+
+  while (pWrapper->refCount > 0) {
+    taosMsleep(10);
+  }
+
+  if (OnlyInParentProc(pWrapper)) {
+    int32_t pid = pWrapper->proc.pid;
+    if (pid > 0 && taosProcExist(pid)) {
+      dInfo("node:%s, send kill signal to the child process:%d", pWrapper->name, pid);
+      taosKillProc(pid);
+      dInfo("node:%s, wait for child process:%d to stop", pWrapper->name, pid);
+      taosWaitProc(pid);
+      dInfo("node:%s, child process:%d is stopped", pWrapper->name, pid);
+    }
+  }
+
+  taosWLockLatch(&pWrapper->latch);
+  if (pWrapper->pMgmt != NULL) {
+    (*pWrapper->func.closeFp)(pWrapper->pMgmt);
+    pWrapper->pMgmt = NULL;
+  }
+  taosWUnLockLatch(&pWrapper->latch);
+
+  if (!OnlyInSingleProc(pWrapper)) {
+    dmCleanupProc(pWrapper);
+  }
+
+  dInfo("node:%s, has been closed", pWrapper->name);
+}
+
+static int32_t dmOpenNodes(SDnode *pDnode) {
+  for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+    if (!pWrapper->required) continue;
+    if (dmOpenNode(pWrapper) != 0) {
+      dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
+      return -1;
+    }
+  }
+
+  dmSetStatus(pDnode, DND_STAT_RUNNING);
+  return 0;
+}
+
+static int32_t dmStartNodes(SDnode *pDnode) {
+  for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+    if (!pWrapper->required) continue;
+    if (dmStartNode(pWrapper) != 0) {
+      dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
+      return -1;
+    }
+  }
+
+  dInfo("TDengine initialized successfully");
+  dmReportStartup("TDengine", "initialized successfully");
+  return 0;
+}
+
+static void dmStopNodes(SDnode *pDnode) {
+  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
+    dmStopNode(pWrapper);
+  }
+}
+
+static void dmCloseNodes(SDnode *pDnode) {
+  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
+    dmCloseNode(pWrapper);
+  }
+}
+
+static void dmWatchNodes(SDnode *pDnode) {
+  if (pDnode->ptype != PARENT_PROC) return;
+  if (pDnode->rtype == NODE_END) return;
+
+  taosThreadMutexLock(&pDnode->mutex);
+  for (EDndNodeType ntype = DNODE + 1; ntype < NODE_END; ++ntype) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+    SProc        *proc = &pWrapper->proc;
+
+    if (!pWrapper->required) continue;
+    if (!OnlyInParentProc(pWrapper)) continue;
+
+    if (proc->pid <= 0 || !taosProcExist(proc->pid)) {
+      dWarn("node:%s, process:%d is killed and needs to restart", pWrapper->name, proc->pid);
+      dmCloseProcRpcHandles(&pWrapper->proc);
+      dmNewProc(pWrapper, ntype);
+    }
+  }
+  taosThreadMutexUnlock(&pDnode->mutex);
+}
+
+int32_t dmRunDnode(SDnode *pDnode) {
+  if (dmOpenNodes(pDnode) != 0) {
+    dError("failed to open nodes since %s", terrstr());
+    return -1;
+  }
+
+  if (dmStartNodes(pDnode) != 0) {
+    dError("failed to start nodes since %s", terrstr());
+    return -1;
+  }
+
+  while (1) {
+    if (pDnode->stop) {
+      dInfo("dnode is about to stop");
+      dmSetStatus(pDnode, DND_STAT_STOPPED);
+      dmStopNodes(pDnode);
+      dmCloseNodes(pDnode);
+      return 0;
+    }
+
+    dmWatchNodes(pDnode);
+    taosMsleep(100);
+  }
+}

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

@@ -0,0 +1,518 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "dmMgmt.h"
+
+static inline int32_t CEIL8(int32_t v) {
+  const int32_t c = ceil((float)(v) / 8) * 8;
+  return c < 8 ? 8 : c;
+}
+
+static int32_t dmInitProcMutex(SProcQueue *queue) {
+  TdThreadMutexAttr mattr = {0};
+
+  if (taosThreadMutexAttrInit(&mattr) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("node:%s, failed to init mutex while init attr since %s", queue->name, terrstr());
+    return -1;
+  }
+
+  if (taosThreadMutexAttrSetPshared(&mattr, PTHREAD_PROCESS_SHARED) != 0) {
+    taosThreadMutexAttrDestroy(&mattr);
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("node:%s, failed to init mutex while set shared since %s", queue->name, terrstr());
+    return -1;
+  }
+
+  if (taosThreadMutexInit(&queue->mutex, &mattr) != 0) {
+    taosThreadMutexAttrDestroy(&mattr);
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("node:%s, failed to init mutex since %s", queue->name, terrstr());
+    return -1;
+  }
+
+  taosThreadMutexAttrDestroy(&mattr);
+  return 0;
+}
+
+static int32_t dmInitProcSem(SProcQueue *queue) {
+  if (tsem_init(&queue->sem, 1, 0) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("node:%s, failed to init sem since %s", queue->name, terrstr());
+    return -1;
+  }
+
+  return 0;
+}
+
+static SProcQueue *dmInitProcQueue(SProc *proc, char *ptr, int32_t size) {
+  SProcQueue *queue = (SProcQueue *)(ptr);
+
+  int32_t bufSize = size - CEIL8(sizeof(SProcQueue));
+  if (bufSize <= 1024) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  if (proc->ptype & DND_PROC_PARENT) {
+    if (dmInitProcMutex(queue) != 0) {
+      return NULL;
+    }
+
+    if (dmInitProcSem(queue) != 0) {
+      return NULL;
+    }
+
+    tstrncpy(queue->name, proc->name, sizeof(queue->name));
+    queue->head = 0;
+    queue->tail = 0;
+    queue->total = bufSize;
+    queue->avail = bufSize;
+    queue->items = 0;
+  }
+
+  return queue;
+}
+
+#if 0
+static void dmDestroyProcQueue(SProcQueue *queue) {
+  if (queue->mutex != NULL) {
+    taosThreadMutexDestroy(queue->mutex);
+    queue->mutex = NULL;
+  }
+}
+
+static void dmDestroyProcSem(SProcQueue *queue) {
+  if (queue->sem != NULL) {
+    tsem_destroy(queue->sem);
+    queue->sem = NULL;
+  }
+}
+#endif
+
+static void dmCleanupProcQueue(SProcQueue *queue) {
+#if 0  
+  if (queue != NULL) {
+    dmDestroyProcQueue(queue);
+    dmDestroyProcSem(queue);
+  }
+#endif
+}
+
+static int32_t dmPushToProcQueue(SProc *proc, SProcQueue *queue, const char *pHead, int16_t rawHeadLen,
+                                 const char *pBody, int32_t rawBodyLen, int64_t handle, int64_t handleRef,
+                                 EProcFuncType ftype) {
+  if (rawHeadLen == 0 || pHead == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return -1;
+  }
+
+  const int32_t headLen = CEIL8(rawHeadLen);
+  const int32_t bodyLen = CEIL8(rawBodyLen);
+  const int32_t fullLen = headLen + bodyLen + 8;
+
+  taosThreadMutexLock(&queue->mutex);
+  if (fullLen > queue->avail) {
+    taosThreadMutexUnlock(&queue->mutex);
+    terrno = TSDB_CODE_OUT_OF_SHM_MEM;
+    return -1;
+  }
+
+  if (handle != 0 && ftype == DND_FUNC_REQ) {
+    if (taosHashPut(proc->hash, &handle, sizeof(int64_t), &handleRef, sizeof(int64_t)) != 0) {
+      taosThreadMutexUnlock(&queue->mutex);
+      return -1;
+    }
+  }
+
+  const int32_t pos = queue->tail;
+  if (queue->tail < queue->total) {
+    *(int16_t *)(queue->pBuffer + queue->tail) = rawHeadLen;
+    *(int8_t *)(queue->pBuffer + queue->tail + 2) = (int8_t)ftype;
+    *(int32_t *)(queue->pBuffer + queue->tail + 4) = rawBodyLen;
+  } else {
+    *(int16_t *)(queue->pBuffer) = rawHeadLen;
+    *(int8_t *)(queue->pBuffer + 2) = (int8_t)ftype;
+    *(int32_t *)(queue->pBuffer + 4) = rawBodyLen;
+  }
+
+  if (queue->tail < queue->head) {
+    memcpy(queue->pBuffer + queue->tail + 8, pHead, rawHeadLen);
+    memcpy(queue->pBuffer + queue->tail + 8 + headLen, pBody, rawBodyLen);
+    queue->tail = queue->tail + 8 + headLen + bodyLen;
+  } else {
+    int32_t remain = queue->total - queue->tail;
+    if (remain == 0) {
+      memcpy(queue->pBuffer + 8, pHead, rawHeadLen);
+      memcpy(queue->pBuffer + 8 + headLen, pBody, rawBodyLen);
+      queue->tail = 8 + headLen + bodyLen;
+    } else if (remain == 8) {
+      memcpy(queue->pBuffer, pHead, rawHeadLen);
+      memcpy(queue->pBuffer + headLen, pBody, rawBodyLen);
+      queue->tail = headLen + bodyLen;
+    } else if (remain < 8 + headLen) {
+      memcpy(queue->pBuffer + queue->tail + 8, pHead, remain - 8);
+      memcpy(queue->pBuffer, pHead + remain - 8, rawHeadLen - (remain - 8));
+      memcpy(queue->pBuffer + headLen - (remain - 8), pBody, rawBodyLen);
+      queue->tail = headLen - (remain - 8) + bodyLen;
+    } else if (remain < 8 + headLen + bodyLen) {
+      memcpy(queue->pBuffer + queue->tail + 8, pHead, rawHeadLen);
+      memcpy(queue->pBuffer + queue->tail + 8 + headLen, pBody, remain - 8 - headLen);
+      memcpy(queue->pBuffer, pBody + remain - 8 - headLen, rawBodyLen - (remain - 8 - headLen));
+      queue->tail = bodyLen - (remain - 8 - headLen);
+    } else {
+      memcpy(queue->pBuffer + queue->tail + 8, pHead, rawHeadLen);
+      memcpy(queue->pBuffer + queue->tail + headLen + 8, pBody, rawBodyLen);
+      queue->tail = queue->tail + headLen + bodyLen + 8;
+    }
+  }
+
+  queue->avail -= fullLen;
+  queue->items++;
+  taosThreadMutexUnlock(&queue->mutex);
+  tsem_post(&queue->sem);
+
+  dTrace("node:%s, push %s msg:%p:%d cont:%p:%d, pos:%d remain:%d", queue->name, dmFuncStr(ftype), pHead, headLen,
+         pBody, bodyLen, pos, queue->items);
+  return 0;
+}
+
+static int32_t dmPopFromProcQueue(SProcQueue *queue, void **ppHead, int16_t *pHeadLen, void **ppBody, int32_t *pBodyLen,
+                                  EProcFuncType *pFuncType) {
+  tsem_wait(&queue->sem);
+
+  taosThreadMutexLock(&queue->mutex);
+  if (queue->total - queue->avail <= 0) {
+    taosThreadMutexUnlock(&queue->mutex);
+    terrno = TSDB_CODE_OUT_OF_SHM_MEM;
+    return 0;
+  }
+
+  int16_t rawHeadLen = 0;
+  int8_t  ftype = 0;
+  int32_t rawBodyLen = 0;
+  if (queue->head < queue->total) {
+    rawHeadLen = *(int16_t *)(queue->pBuffer + queue->head);
+    ftype = *(int8_t *)(queue->pBuffer + queue->head + 2);
+    rawBodyLen = *(int32_t *)(queue->pBuffer + queue->head + 4);
+  } else {
+    rawHeadLen = *(int16_t *)(queue->pBuffer);
+    ftype = *(int8_t *)(queue->pBuffer + 2);
+    rawBodyLen = *(int32_t *)(queue->pBuffer + 4);
+  }
+  int16_t headLen = CEIL8(rawHeadLen);
+  int32_t bodyLen = CEIL8(rawBodyLen);
+
+  void *pHead = taosAllocateQitem(headLen, DEF_QITEM);
+  void *pBody = rpcMallocCont(bodyLen);
+  if (pHead == NULL || pBody == NULL) {
+    taosThreadMutexUnlock(&queue->mutex);
+    tsem_post(&queue->sem);
+    taosFreeQitem(pHead);
+    rpcFreeCont(pBody);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  const int32_t pos = queue->head;
+  if (queue->head < queue->tail) {
+    memcpy(pHead, queue->pBuffer + queue->head + 8, headLen);
+    memcpy(pBody, queue->pBuffer + queue->head + 8 + headLen, bodyLen);
+    queue->head = queue->head + 8 + headLen + bodyLen;
+  } else {
+    int32_t remain = queue->total - queue->head;
+    if (remain == 0) {
+      memcpy(pHead, queue->pBuffer + 8, headLen);
+      memcpy(pBody, queue->pBuffer + 8 + headLen, bodyLen);
+      queue->head = 8 + headLen + bodyLen;
+    } else if (remain == 8) {
+      memcpy(pHead, queue->pBuffer, headLen);
+      memcpy(pBody, queue->pBuffer + headLen, bodyLen);
+      queue->head = headLen + bodyLen;
+    } else if (remain < 8 + headLen) {
+      memcpy(pHead, queue->pBuffer + queue->head + 8, remain - 8);
+      memcpy((char *)pHead + remain - 8, queue->pBuffer, headLen - (remain - 8));
+      memcpy(pBody, queue->pBuffer + headLen - (remain - 8), bodyLen);
+      queue->head = headLen - (remain - 8) + bodyLen;
+    } else if (remain < 8 + headLen + bodyLen) {
+      memcpy(pHead, queue->pBuffer + queue->head + 8, headLen);
+      memcpy(pBody, queue->pBuffer + queue->head + 8 + headLen, remain - 8 - headLen);
+      memcpy((char *)pBody + remain - 8 - headLen, queue->pBuffer, bodyLen - (remain - 8 - headLen));
+      queue->head = bodyLen - (remain - 8 - headLen);
+    } else {
+      memcpy(pHead, queue->pBuffer + queue->head + 8, headLen);
+      memcpy(pBody, queue->pBuffer + queue->head + headLen + 8, bodyLen);
+      queue->head = queue->head + headLen + bodyLen + 8;
+    }
+  }
+
+  queue->avail = queue->avail + headLen + bodyLen + 8;
+  queue->items--;
+  taosThreadMutexUnlock(&queue->mutex);
+
+  *ppHead = pHead;
+  *ppBody = pBody;
+  *pHeadLen = rawHeadLen;
+  *pBodyLen = rawBodyLen;
+  *pFuncType = (EProcFuncType)ftype;
+
+  dTrace("node:%s, pop %s msg:%p:%d cont:%p:%d, pos:%d remain:%d", queue->name, dmFuncStr(ftype), pHead, headLen, pBody,
+         bodyLen, pos, queue->items);
+  return 1;
+}
+
+int32_t dmInitProc(struct SMgmtWrapper *pWrapper) {
+  SProc *proc = &pWrapper->proc;
+  if (proc->name != NULL) return 0;
+
+  proc->wrapper = pWrapper;
+  proc->name = pWrapper->name;
+
+  SShm   *shm = &proc->shm;
+  int32_t cstart = 0;
+  int32_t csize = CEIL8(shm->size / 2);
+  int32_t pstart = csize;
+  int32_t psize = CEIL8(shm->size - pstart);
+  if (pstart + psize > shm->size) {
+    psize -= 8;
+  }
+
+  proc->hash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
+  proc->cqueue = dmInitProcQueue(proc, (char *)shm->ptr + cstart, csize);
+  proc->pqueue = dmInitProcQueue(proc, (char *)shm->ptr + pstart, psize);
+  if (proc->cqueue == NULL || proc->pqueue == NULL || proc->hash == NULL) {
+    dmCleanupProcQueue(proc->cqueue);
+    dmCleanupProcQueue(proc->pqueue);
+    taosHashCleanup(proc->hash);
+    return -1;
+  }
+
+  dDebug("node:%s, proc is initialized, cqueue:%p pqueue:%p", proc->name, proc->cqueue, proc->pqueue);
+  return 0;
+}
+
+static void *dmConsumChildQueue(void *param) {
+  SProc        *proc = param;
+  SMgmtWrapper *pWrapper = proc->wrapper;
+  SProcQueue   *queue = proc->cqueue;
+  void         *pHead = NULL;
+  void         *pBody = NULL;
+  int16_t       headLen = 0;
+  int32_t       bodyLen = 0;
+  int32_t       numOfMsgs = 0;
+  int32_t       code = 0;
+  EProcFuncType ftype = DND_FUNC_REQ;
+  SRpcMsg      *pReq = NULL;
+
+  dDebug("node:%s, start to consume from cqueue", proc->name);
+  do {
+    numOfMsgs = dmPopFromProcQueue(queue, &pHead, &headLen, &pBody, &bodyLen, &ftype);
+    if (numOfMsgs == 0) {
+      dDebug("node:%s, get no msg from cqueue and exit thread", proc->name);
+      break;
+    }
+
+    if (numOfMsgs < 0) {
+      dError("node:%s, get no msg from cqueue since %s", proc->name, terrstr());
+      taosMsleep(1);
+      continue;
+    }
+
+    if (ftype != DND_FUNC_REQ) {
+      dFatal("node:%s, get msg:%p from cqueue, invalid ftype:%d", proc->name, pHead, ftype);
+      taosFreeQitem(pHead);
+      rpcFreeCont(pBody);
+    } else {
+      pReq = pHead;
+      pReq->pCont = pBody;
+      code = dmProcessNodeMsg(pWrapper, pReq);
+      if (code != 0) {
+        dError("node:%s, failed to process msg:%p since %s, put into pqueue", proc->name, pReq, terrstr());
+        SRpcMsg rspMsg = {
+            .info = pReq->info,
+            .pCont = pReq->info.rsp,
+            .contLen = pReq->info.rspLen,
+        };
+        dmPutToProcPQueue(proc, &rspMsg, sizeof(SRpcMsg), rspMsg.pCont, rspMsg.contLen, DND_FUNC_RSP);
+        taosFreeQitem(pHead);
+        rpcFreeCont(pBody);
+        rpcFreeCont(rspMsg.pCont);
+      }
+    }
+  } while (1);
+
+  return NULL;
+}
+
+static void *dmConsumParentQueue(void *param) {
+  SProc        *proc = param;
+  SMgmtWrapper *pWrapper = proc->wrapper;
+  SProcQueue   *queue = proc->pqueue;
+  void         *pHead = NULL;
+  void         *pBody = NULL;
+  int16_t       headLen = 0;
+  int32_t       bodyLen = 0;
+  int32_t       numOfMsgs = 0;
+  int32_t       code = 0;
+  EProcFuncType ftype = DND_FUNC_REQ;
+  SRpcMsg      *pRsp = NULL;
+
+  dDebug("node:%s, start to consume from pqueue", proc->name);
+  do {
+    numOfMsgs = dmPopFromProcQueue(queue, &pHead, &headLen, &pBody, &bodyLen, &ftype);
+    if (numOfMsgs == 0) {
+      dDebug("node:%s, get no msg from pqueue and exit thread", proc->name);
+      break;
+    }
+
+    if (numOfMsgs < 0) {
+      dError("node:%s, get no msg from pqueue since %s", proc->name, terrstr());
+      taosMsleep(1);
+      continue;
+    }
+
+    if (ftype == DND_FUNC_RSP) {
+      pRsp = pHead;
+      pRsp->pCont = pBody;
+      dTrace("node:%s, get rsp msg:%p from pqueue, code:0x%04x handle:%p", proc->name, pRsp, code, pRsp->info.handle);
+      dmRemoveProcRpcHandle(proc, pRsp->info.handle);
+      rpcSendResponse(pRsp);
+    } else if (ftype == DND_FUNC_REGIST) {
+      pRsp = pHead;
+      pRsp->pCont = pBody;
+      dTrace("node:%s, get regist msg:%p from pqueue, code:0x%04x handle:%p", proc->name, pRsp, code,
+             pRsp->info.handle);
+      rpcRegisterBrokenLinkArg(pRsp);
+    } else if (ftype == DND_FUNC_RELEASE) {
+      pRsp = pHead;
+      pRsp->pCont = NULL;
+      dTrace("node:%s, get release msg:%p from pqueue, code:0x%04x handle:%p", proc->name, pRsp, code,
+             pRsp->info.handle);
+      dmRemoveProcRpcHandle(proc, pRsp->info.handle);
+      rpcReleaseHandle(pRsp->info.handle, (int8_t)pRsp->code);
+      rpcFreeCont(pBody);
+    } else {
+      dFatal("node:%s, get msg:%p from pqueue, invalid ftype:%d", proc->name, pHead, ftype);
+      rpcFreeCont(pBody);
+    }
+
+    taosFreeQitem(pHead);
+  } while (1);
+
+  return NULL;
+}
+
+int32_t dmRunProc(SProc *proc) {
+  TdThreadAttr thAttr = {0};
+  taosThreadAttrInit(&thAttr);
+  taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
+
+  if (proc->ptype & DND_PROC_PARENT) {
+    if (taosThreadCreate(&proc->pthread, &thAttr, dmConsumParentQueue, proc) != 0) {
+      terrno = TAOS_SYSTEM_ERROR(errno);
+      dError("node:%s, failed to create pthread since %s", proc->name, terrstr());
+      return -1;
+    }
+    dDebug("node:%s, thread:%" PRId64 " is created to consume pqueue", proc->name, proc->pthread);
+  }
+
+  if (proc->ptype & DND_PROC_CHILD) {
+    if (taosThreadCreate(&proc->cthread, &thAttr, dmConsumChildQueue, proc) != 0) {
+      terrno = TAOS_SYSTEM_ERROR(errno);
+      dError("node:%s, failed to create cthread since %s", proc->name, terrstr());
+      return -1;
+    }
+    dDebug("node:%s, thread:%" PRId64 " is created to consume cqueue", proc->name, proc->cthread);
+  }
+
+  taosThreadAttrDestroy(&thAttr);
+  return 0;
+}
+
+void dmStopProc(SProc *proc) {
+  proc->stop = true;
+  if (taosCheckPthreadValid(proc->pthread)) {
+    dDebug("node:%s, start to join pthread:%" PRId64, proc->name, proc->pthread);
+    tsem_post(&proc->pqueue->sem);
+    taosThreadJoin(proc->pthread, NULL);
+    taosThreadClear(&proc->pthread);
+  }
+
+  if (taosCheckPthreadValid(proc->cthread)) {
+    dDebug("node:%s, start to join cthread:%" PRId64, proc->name, proc->cthread);
+    tsem_post(&proc->cqueue->sem);
+    taosThreadJoin(proc->cthread, NULL);
+    taosThreadClear(&proc->cthread);
+  }
+}
+
+void dmCleanupProc(struct SMgmtWrapper *pWrapper) {
+  SProc *proc = &pWrapper->proc;
+  if (proc->name == NULL) return;
+
+  dDebug("node:%s, start to clean up proc", pWrapper->name);
+  dmStopProc(proc);
+  dmCleanupProcQueue(proc->cqueue);
+  dmCleanupProcQueue(proc->pqueue);
+  taosHashCleanup(proc->hash);
+  dDebug("node:%s, proc is cleaned up", pWrapper->name);
+}
+
+int64_t dmRemoveProcRpcHandle(SProc *proc, void *handle) {
+  int64_t h = (int64_t)handle;
+  taosThreadMutexLock(&proc->cqueue->mutex);
+
+  int64_t *pRef = taosHashGet(proc->hash, &h, sizeof(int64_t));
+  int64_t  ref = 0;
+  if (pRef != NULL) {
+    ref = *pRef;
+  }
+
+  taosHashRemove(proc->hash, &h, sizeof(int64_t));
+  taosThreadMutexUnlock(&proc->cqueue->mutex);
+
+  return ref;
+}
+
+void dmCloseProcRpcHandles(SProc *proc) {
+  taosThreadMutexLock(&proc->cqueue->mutex);
+  void *h = taosHashIterate(proc->hash, NULL);
+  while (h != NULL) {
+    void *handle = *((void **)h);
+    h = taosHashIterate(proc->hash, h);
+
+    dError("node:%s, the child process dies and send an offline rsp to handle:%p", proc->name, handle);
+    SRpcMsg rpcMsg = {.info.handle = handle, .code = TSDB_CODE_NODE_OFFLINE};
+    rpcSendResponse(&rpcMsg);
+  }
+  taosHashClear(proc->hash);
+  taosThreadMutexUnlock(&proc->cqueue->mutex);
+}
+
+void dmPutToProcPQueue(SProc *proc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
+                       EProcFuncType ftype) {
+  int32_t retry = 0;
+  while (dmPushToProcQueue(proc, proc->pqueue, pHead, headLen, pBody, bodyLen, 0, 0, ftype) != 0) {
+    dWarn("node:%s, failed to put msg:%p to pqueue since %s, retry:%d", proc->name, pHead, terrstr(), retry);
+    retry++;
+    taosMsleep(retry);
+  }
+}
+
+int32_t dmPutToProcCQueue(SProc *proc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
+                          void *handle, int64_t ref, EProcFuncType ftype) {
+  return dmPushToProcQueue(proc, proc->cqueue, pHead, headLen, pBody, bodyLen, (int64_t)handle, ref, ftype);
+}

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

@@ -1,355 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "dmMgmt.h"
-
-static int32_t dmInitParentProc(SMgmtWrapper *pWrapper) {
-  int32_t shmsize = tsMnodeShmSize;
-  if (pWrapper->nodeType == VNODE) {
-    shmsize = tsVnodeShmSize;
-  } else if (pWrapper->nodeType == QNODE) {
-    shmsize = tsQnodeShmSize;
-  } else if (pWrapper->nodeType == SNODE) {
-    shmsize = tsSnodeShmSize;
-  } else if (pWrapper->nodeType == MNODE) {
-    shmsize = tsMnodeShmSize;
-  } else if (pWrapper->nodeType == BNODE) {
-    shmsize = tsBnodeShmSize;
-  } else {
-    return -1;
-  }
-
-  if (taosCreateShm(&pWrapper->procShm, pWrapper->nodeType, shmsize) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(terrno);
-    dError("node:%s, failed to create shm size:%d since %s", pWrapper->name, shmsize, terrstr());
-    return -1;
-  }
-  dInfo("node:%s, shm:%d is created, size:%d", pWrapper->name, pWrapper->procShm.id, shmsize);
-
-  SProcCfg cfg = dmGenProcCfg(pWrapper);
-  cfg.isChild = false;
-  pWrapper->procType = DND_PROC_PARENT;
-  pWrapper->procObj = taosProcInit(&cfg);
-  if (pWrapper->procObj == NULL) {
-    dError("node:%s, failed to create proc since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-
-  return 0;
-}
-
-static int32_t dmNewNodeProc(SMgmtWrapper *pWrapper, EDndNodeType n) {
-  char  tstr[8] = {0};
-  char *args[6] = {0};
-  snprintf(tstr, sizeof(tstr), "%d", n);
-  args[1] = "-c";
-  args[2] = configDir;
-  args[3] = "-n";
-  args[4] = tstr;
-  args[5] = NULL;
-
-  int32_t pid = taosNewProc(args);
-  if (pid <= 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("node:%s, failed to exec in new process since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-
-  pWrapper->procId = pid;
-  dInfo("node:%s, continue running in new process:%d", pWrapper->name, pid);
-  return 0;
-}
-
-static int32_t dmRunParentProc(SMgmtWrapper *pWrapper) {
-  if (pWrapper->pDnode->ntype == NODE_END) {
-    dInfo("node:%s, should be started manually in child process", pWrapper->name);
-  } else {
-    if (dmNewNodeProc(pWrapper, pWrapper->nodeType) != 0) {
-      return -1;
-    }
-  }
-  if (taosProcRun(pWrapper->procObj) != 0) {
-    dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-  return 0;
-}
-
-static int32_t dmInitChildProc(SMgmtWrapper *pWrapper) {
-  SProcCfg cfg = dmGenProcCfg(pWrapper);
-  cfg.isChild = true;
-  pWrapper->procObj = taosProcInit(&cfg);
-  if (pWrapper->procObj == NULL) {
-    dError("node:%s, failed to create proc since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-  return 0;
-}
-
-static int32_t dmRunChildProc(SMgmtWrapper *pWrapper) {
-  if (taosProcRun(pWrapper->procObj) != 0) {
-    dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-  return 0;
-}
-
-int32_t dmOpenNode(SMgmtWrapper *pWrapper) {
-  if (taosMkDir(pWrapper->path) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("node:%s, failed to create dir:%s since %s", pWrapper->name, pWrapper->path, terrstr());
-    return -1;
-  }
-
-  SMgmtOutputOpt output = {0};
-  SMgmtInputOpt *pInput = &pWrapper->pDnode->input;
-  pInput->name = pWrapper->name;
-  pInput->path = pWrapper->path;
-  pInput->msgCb = dmGetMsgcb(pWrapper);
-  if (pWrapper->nodeType == DNODE || pWrapper->procType == DND_PROC_CHILD) {
-    tmsgSetDefaultMsgCb(&pInput->msgCb);
-  }
-
-  if (pWrapper->procType == DND_PROC_SINGLE || pWrapper->procType == DND_PROC_CHILD) {
-    if ((*pWrapper->func.openFp)(pInput, &output) != 0) {
-      dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
-      return -1;
-    }
-    if (pWrapper->procType == DND_PROC_CHILD) {
-      if (dmInitChildProc(pWrapper) != 0) return -1;
-      if (dmRunChildProc(pWrapper) != 0) return -1;
-    }
-    dDebug("node:%s, has been opened", pWrapper->name);
-    pWrapper->deployed = true;
-  } else {
-    if (dmInitParentProc(pWrapper) != 0) return -1;
-    if (dmWriteShmFile(pWrapper->path, pWrapper->name, &pWrapper->procShm) != 0) return -1;
-    if (dmRunParentProc(pWrapper) != 0) return -1;
-  }
-
-  if (output.dnodeId != 0) {
-    pInput->dnodeId = output.dnodeId;
-  }
-  if (output.pMgmt != NULL) {
-    pWrapper->pMgmt = output.pMgmt;
-  }
-  if (output.mnodeEps.numOfEps != 0) {
-    pWrapper->pDnode->mnodeEps = output.mnodeEps;
-  }
-
-  dmReportStartup(pWrapper->pDnode, pWrapper->name, "openned");
-  return 0;
-}
-
-int32_t dmStartNode(SMgmtWrapper *pWrapper) {
-  if (!pWrapper->required) return 0;
-
-  if (pWrapper->procType == DND_PROC_PARENT) {
-    dInfo("node:%s, not start in parent process", pWrapper->name);
-  } else if (pWrapper->procType == DND_PROC_CHILD) {
-    dInfo("node:%s, start in child process", pWrapper->name);
-    if (pWrapper->nodeType != DNODE) {
-      if (pWrapper->func.startFp != NULL && (*pWrapper->func.startFp)(pWrapper->pMgmt) != 0) {
-        dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
-        return -1;
-      }
-    }
-  } else {
-    if (pWrapper->func.startFp != NULL && (*pWrapper->func.startFp)(pWrapper->pMgmt) != 0) {
-      dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
-      return -1;
-    }
-  }
-
-  dmReportStartup(pWrapper->pDnode, pWrapper->name, "started");
-  return 0;
-}
-
-void dmStopNode(SMgmtWrapper *pWrapper) {
-  if (pWrapper->func.stopFp != NULL && pWrapper->pMgmt != NULL) {
-    (*pWrapper->func.stopFp)(pWrapper->pMgmt);
-    dDebug("node:%s, has been stopped", pWrapper->name);
-  }
-}
-
-void dmCloseNode(SMgmtWrapper *pWrapper) {
-  dInfo("node:%s, start to close", pWrapper->name);
-  pWrapper->deployed = false;
-
-  while (pWrapper->refCount > 0) {
-    taosMsleep(10);
-  }
-
-  if (pWrapper->procType == DND_PROC_PARENT) {
-    if (pWrapper->procId > 0 && taosProcExist(pWrapper->procId)) {
-      dInfo("node:%s, send kill signal to the child process:%d", pWrapper->name, pWrapper->procId);
-      taosKillProc(pWrapper->procId);
-      dInfo("node:%s, wait for child process:%d to stop", pWrapper->name, pWrapper->procId);
-      taosWaitProc(pWrapper->procId);
-      dInfo("node:%s, child process:%d is stopped", pWrapper->name, pWrapper->procId);
-    }
-  }
-
-  taosWLockLatch(&pWrapper->latch);
-  if (pWrapper->pMgmt != NULL) {
-    (*pWrapper->func.closeFp)(pWrapper->pMgmt);
-    pWrapper->pMgmt = NULL;
-  }
-  taosWUnLockLatch(&pWrapper->latch);
-
-  if (pWrapper->procObj) {
-    taosProcCleanup(pWrapper->procObj);
-    pWrapper->procObj = NULL;
-  }
-
-  dInfo("node:%s, has been closed", pWrapper->name);
-}
-
-static int32_t dmOpenNodes(SDnode *pDnode) {
-  for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
-    if (!pWrapper->required) continue;
-    if (ntype == DNODE) {
-      pWrapper->procType = DND_PROC_SINGLE;
-      if (dmOpenNode(pWrapper) != 0) {
-        return -1;
-      }
-    } else {
-      if (pDnode->ptype == DND_PROC_CHILD) {
-        if (pDnode->ntype == ntype) {
-          pWrapper->procType = DND_PROC_CHILD;
-          if (dmOpenNode(pWrapper) != 0) {
-            return -1;
-          }
-        } else {
-          pWrapper->required = false;
-        }
-      } else {
-        pWrapper->procType = pDnode->ptype;
-        if (dmOpenNode(pWrapper) != 0) {
-          return -1;
-        }
-      }
-    }
-  }
-
-  dmSetStatus(pDnode, DND_STAT_RUNNING);
-  return 0;
-}
-
-static int32_t dmStartNodes(SDnode *pDnode) {
-  for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
-    if (ntype == DNODE && (pDnode->ptype == DND_PROC_CHILD || pDnode->ptype == DND_PROC_TEST)) continue;
-    if (dmStartNode(pWrapper) != 0) {
-      dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
-      return -1;
-    }
-  }
-
-  dInfo("TDengine initialized successfully");
-  dmReportStartup(pDnode, "TDengine", "initialized successfully");
-  return 0;
-}
-
-static void dmStopNodes(SDnode *pDnode) {
-  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    dmStopNode(pWrapper);
-  }
-}
-
-static void dmCloseNodes(SDnode *pDnode) {
-  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    dmCloseNode(pWrapper);
-  }
-}
-
-static void dmProcessProcHandle(void *handle) {
-  dWarn("handle:%p, the child process dies and send an offline rsp", handle);
-  SRpcMsg rpcMsg = {.handle = handle, .code = TSDB_CODE_NODE_OFFLINE};
-  rpcSendResponse(&rpcMsg);
-}
-
-static void dmWatchNodes(SDnode *pDnode) {
-  if (pDnode->ptype != DND_PROC_PARENT) return;
-  if (pDnode->ntype == NODE_END) return;
-
-  taosThreadMutexLock(&pDnode->mutex);
-  for (EDndNodeType n = DNODE + 1; n < NODE_END; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    if (!pWrapper->required) continue;
-    if (pWrapper->procType != DND_PROC_PARENT) continue;
-
-    if (pWrapper->procId <= 0 || !taosProcExist(pWrapper->procId)) {
-      dWarn("node:%s, process:%d is killed and needs to be restarted", pWrapper->name, pWrapper->procId);
-      if (pWrapper->procObj) {
-        taosProcCloseHandles(pWrapper->procObj, dmProcessProcHandle);
-      }
-      dmNewNodeProc(pWrapper, n);
-    }
-  }
-  taosThreadMutexUnlock(&pDnode->mutex);
-}
-
-int32_t dmRun(SDnode *pDnode) {
-  if (tsMultiProcess == 0) {
-    pDnode->ptype = DND_PROC_SINGLE;
-    dInfo("dnode run in single process mode");
-  } else if (tsMultiProcess == 2) {
-    pDnode->ptype = DND_PROC_TEST;
-    dInfo("dnode run in multi-process test mode");
-  } else if (pDnode->ntype == DNODE || pDnode->ntype == NODE_END) {
-    pDnode->ptype = DND_PROC_PARENT;
-    dInfo("dnode run in parent process mode");
-  } else {
-    pDnode->ptype = DND_PROC_CHILD;
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[pDnode->ntype];
-    dInfo("%s run in child process mode", pWrapper->name);
-  }
-
-  if (pDnode->ptype != DND_PROC_CHILD) {
-    if (dmInitServer(pDnode) != 0) {
-      dError("failed to init transport since %s", terrstr());
-      return -1;
-    }
-    dmReportStartup(pDnode, "dnode-transport", "initialized");
-  }
-
-  if (dmOpenNodes(pDnode) != 0) {
-    dError("failed to open nodes since %s", terrstr());
-    return -1;
-  }
-
-  if (dmStartNodes(pDnode) != 0) {
-    dError("failed to start nodes since %s", terrstr());
-    return -1;
-  }
-
-  while (1) {
-    taosMsleep(100);
-    if (pDnode->event & DND_EVENT_STOP) {
-      dInfo("dnode is about to stop");
-      dmSetStatus(pDnode, DND_STAT_STOPPED);
-      dmStopNodes(pDnode);
-      dmCloseNodes(pDnode);
-      return 0;
-    } else {
-      dmWatchNodes(pDnode);
-    }
-  }
-}

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

@@ -21,98 +21,141 @@
 #define INTERNAL_CKEY   "_key"
 #define INTERNAL_SECRET "_pwd"
 
-static void dmGetMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
+static inline int32_t dmBuildNodeMsg(SRpcMsg *pMsg, SRpcMsg *pRpc) {
-  taosRLockLatch(&pDnode->latch);
-  *pEpSet = pDnode->mnodeEps;
-  taosRUnLockLatch(&pDnode->latch);
-}
-
-static void dmSetMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
-  dInfo("mnode is changed, num:%d use:%d", pEpSet->numOfEps, pEpSet->inUse);
-
-  taosWLockLatch(&pDnode->latch);
-  pDnode->mnodeEps = *pEpSet;
-  for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
-    dInfo("mnode index:%d %s:%u", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
-  }
-
-  taosWUnLockLatch(&pDnode->latch);
-}
-
-static inline NodeMsgFp dmGetMsgFp(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
-  NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
-  if (msgFp == NULL) {
-    terrno = TSDB_CODE_MSG_NOT_PROCESSED;
-  }
-
-  return msgFp;
-}
-
-static inline int32_t dmBuildMsg(SNodeMsg *pMsg, SRpcMsg *pRpc) {
   SRpcConnInfo connInfo = {0};
-  if ((pRpc->msgType & 1U) && rpcGetConnInfo(pRpc->handle, &connInfo) != 0) {
+  if (IsReq(pRpc) && rpcGetConnInfo(pRpc->info.handle, &connInfo) != 0) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
-    dError("failed to build msg since %s, app:%p handle:%p", terrstr(), pRpc->ahandle, pRpc->handle);
+    dError("failed to build msg since %s, app:%p handle:%p", terrstr(), pRpc->info.ahandle, pRpc->info.handle);
     return -1;
   }
 
-  memcpy(pMsg->user, connInfo.user, TSDB_USER_LEN);
+  memcpy(pMsg, pRpc, sizeof(SRpcMsg));
-  pMsg->clientIp = connInfo.clientIp;
+  memcpy(pMsg->conn.user, connInfo.user, TSDB_USER_LEN);
-  pMsg->clientPort = connInfo.clientPort;
+  pMsg->conn.clientIp = connInfo.clientIp;
-  memcpy(&pMsg->rpcMsg, pRpc, sizeof(SRpcMsg));
+  pMsg->conn.clientPort = connInfo.clientPort;
-  if ((pRpc->msgType & 1u)) {
-    assert(pRpc->refId != 0);
-  }
-
   return 0;
 }
 
-static void dmProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, SEpSet *pEpSet) {
+int32_t dmProcessNodeMsg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) {
+  NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pMsg->msgType)];
+  if (msgFp == NULL) {
+    terrno = TSDB_CODE_MSG_NOT_PROCESSED;
+    return -1;
+  }
+
+  pMsg->info.wrapper = pWrapper;
+  dTrace("msg:%p, will be processed by %s, handle:%p", pMsg, pWrapper->name, pMsg->info.handle);
+  return (*msgFp)(pWrapper->pMgmt, pMsg);
+}
+
+static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
+  SDnodeTrans  *pTrans = &pDnode->trans;
   int32_t       code = -1;
-  SNodeMsg *pMsg = NULL;
+  SRpcMsg      *pMsg = NULL;
-  NodeMsgFp msgFp = NULL;
-  uint16_t  msgType = pRpc->msgType;
   bool          needRelease = false;
-  bool      isReq = msgType & 1U;
+  SDnodeHandle *pHandle = &pTrans->msgHandles[TMSG_INDEX(pRpc->msgType)];
+  SMgmtWrapper *pWrapper = NULL;
 
-  if (dmMarkWrapper(pWrapper) != 0) goto _OVER;
+  dTrace("msg:%s is received, handle:%p cont:%p len:%d code:0x%04x app:%p refId:%" PRId64, TMSG_INFO(pRpc->msgType),
-  needRelease = true;
+         pRpc->info.handle, pRpc->pCont, pRpc->contLen, pRpc->code, pRpc->info.ahandle, pRpc->info.refId);
+  pRpc->info.noResp = 0;
+  pRpc->info.persistHandle = 0;
+  pRpc->info.wrapper = NULL;
+  pRpc->info.node = NULL;
+  pRpc->info.rsp = NULL;
+  pRpc->info.rspLen = 0;
 
-  if ((msgFp = dmGetMsgFp(pWrapper, pRpc)) == NULL) goto _OVER;
+  if (pRpc->msgType == TDMT_DND_NET_TEST) {
-  if ((pMsg = taosAllocateQitem(sizeof(SNodeMsg), RPC_QITEM)) == NULL) goto _OVER;
+    dmProcessNetTestReq(pDnode, pRpc);
-  if (dmBuildMsg(pMsg, pRpc) != 0) goto _OVER;
+    goto _OVER_JUST_FREE;
-
+  } else if (pRpc->msgType == TDMT_MND_SYSTABLE_RETRIEVE_RSP || pRpc->msgType == TDMT_VND_FETCH_RSP) {
-  if (pWrapper->procType != DND_PROC_PARENT) {
+    qWorkerProcessFetchRsp(NULL, NULL, pRpc);
-    dTrace("msg:%p, created, type:%s handle:%p user:%s", pMsg, TMSG_INFO(msgType), pRpc->handle, pMsg->user);
+    goto _OVER_JUST_FREE;
-    code = (*msgFp)(pWrapper->pMgmt, pMsg);
   } else {
-    dTrace("msg:%p, created and put into child queue, type:%s handle:%p code:0x%04x user:%s contLen:%d", pMsg,
+  }
-           TMSG_INFO(msgType), pRpc->handle, pMsg->rpcMsg.code & 0XFFFF, pMsg->user, pRpc->contLen);
+
-    code = taosProcPutToChildQ(pWrapper->procObj, pMsg, sizeof(SNodeMsg), pRpc->pCont, pRpc->contLen,
+  if (pDnode->status != DND_STAT_RUNNING) {
-                               (isReq && (pMsg->rpcMsg.code == 0)) ? pRpc->handle : NULL, pRpc->refId, PROC_FUNC_REQ);
+    if (pRpc->msgType == TDMT_DND_SERVER_STATUS) {
+      dmProcessServerStartupStatus(pDnode, pRpc);
+      goto _OVER_JUST_FREE;
+    } else {
+      terrno = TSDB_CODE_APP_NOT_READY;
+      goto _OVER_RSP_FREE;
+    }
+  }
+
+  if (IsReq(pRpc) && pRpc->pCont == NULL) {
+    terrno = TSDB_CODE_INVALID_MSG_LEN;
+    goto _OVER_RSP_FREE;
+  }
+
+  if (pHandle->defaultNtype == NODE_END) {
+    terrno = TSDB_CODE_MSG_NOT_PROCESSED;
+    goto _OVER_RSP_FREE;
+  } else {
+    pWrapper = &pDnode->wrappers[pHandle->defaultNtype];
+    if (pHandle->needCheckVgId) {
+      if (pRpc->contLen > 0) {
+        SMsgHead *pHead = pRpc->pCont;
+        int32_t   vgId = ntohl(pHead->vgId);
+        if (vgId == QNODE_HANDLE) {
+          pWrapper = &pDnode->wrappers[QNODE];
+        } else if (vgId == MNODE_HANDLE) {
+          pWrapper = &pDnode->wrappers[MNODE];
+        } else {
+        }
+      } else {
+        terrno = TSDB_CODE_INVALID_MSG_LEN;
+        goto _OVER_RSP_FREE;
+      }
+    }
+  }
+
+  if (dmMarkWrapper(pWrapper) != 0) {
+    goto _OVER_RSP_FREE;
+  } else {
+    needRelease = true;
+    pRpc->info.wrapper = pWrapper;
+  }
+
+  pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
+  if (pMsg == NULL) {
+    goto _OVER;
+  }
+
+  if (dmBuildNodeMsg(pMsg, pRpc) != 0) {
+    goto _OVER;
+  }
+
+  if (InParentProc(pWrapper)) {
+    code = dmPutToProcCQueue(&pWrapper->proc, pMsg, sizeof(SRpcMsg), pRpc->pCont, pRpc->contLen,
+                             (IsReq(pRpc) && (pRpc->code == 0)) ? pRpc->info.handle : NULL, pRpc->info.refId,
+                             DND_FUNC_REQ);
+  } else {
+    code = dmProcessNodeMsg(pWrapper, pMsg);
   }
 
 _OVER:
   if (code == 0) {
-    if (pWrapper->procType == DND_PROC_PARENT) {
+    if (pWrapper != NULL && InParentProc(pWrapper)) {
-      dTrace("msg:%p, freed in parent process", pMsg);
+      dTrace("msg:%p, is freed after push to cqueue", pMsg);
       taosFreeQitem(pMsg);
       rpcFreeCont(pRpc->pCont);
     }
   } else {
-    dError("msg:%p, type:%s handle:%p failed to process since 0x%04x:%s", pMsg, TMSG_INFO(msgType), pRpc->handle,
+    dError("msg:%p, failed to process since %s", pMsg, terrstr());
-           code & 0XFFFF, terrstr());
-    if (isReq) {
     if (terrno != 0) code = terrno;
+
+    if (IsReq(pRpc)) {
       if (code == TSDB_CODE_NODE_NOT_DEPLOYED || code == TSDB_CODE_NODE_OFFLINE) {
-        if (msgType > TDMT_MND_MSG && msgType < TDMT_VND_MSG) {
+        if (pRpc->msgType > TDMT_MND_MSG && pRpc->msgType < TDMT_VND_MSG) {
           code = TSDB_CODE_NODE_REDIRECT;
         }
       }
-
+      SRpcMsg rspMsg = {.code = code, .info = pRpc->info};
-      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = code, .refId = pRpc->refId};
+      tmsgSendRsp(&rspMsg);
-      tmsgSendRsp(&rsp);
     }
+
     dTrace("msg:%p, is freed", pMsg);
     taosFreeQitem(pMsg);
     rpcFreeCont(pRpc->pCont);
@@ -121,83 +164,16 @@ _OVER:
   if (needRelease) {
     dmReleaseWrapper(pWrapper);
   }
-}
-
-static void dmProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SDnodeTrans  *pTrans = &pDnode->trans;
-  tmsg_t        msgType = pMsg->msgType;
-  bool          isReq = msgType & 1u;
-  SMsgHandle   *pHandle = &pTrans->msgHandles[TMSG_INDEX(msgType)];
-  SMgmtWrapper *pWrapper = NULL;
-
-  switch (msgType) {
-    case TDMT_DND_SERVER_STATUS:
-      if (pDnode->status != DND_STAT_RUNNING) {
-        dTrace("server status req will be processed, handle:%p, app:%p", pMsg->handle, pMsg->ahandle);
-        dmProcessServerStartupStatus(pDnode, pMsg);
   return;
-      } else {
-        break;
-      }
-    case TDMT_DND_NET_TEST:
-      dTrace("net test req will be processed, handle:%p, app:%p", pMsg->handle, pMsg->ahandle);
-      dmProcessNetTestReq(pDnode, pMsg);
-      return;
-    case TDMT_MND_SYSTABLE_RETRIEVE_RSP:
-    case TDMT_VND_FETCH_RSP:
-      dTrace("retrieve rsp is received");
-      qWorkerProcessFetchRsp(NULL, NULL, pMsg);
-      pMsg->pCont = NULL;  // already freed in qworker
-      return;
-  }
 
-  if (pDnode->status != DND_STAT_RUNNING) {
+_OVER_JUST_FREE:
-    dError("msg:%s ignored since dnode not running, handle:%p app:%p", TMSG_INFO(msgType), pMsg->handle, pMsg->ahandle);
+  rpcFreeCont(pRpc->pCont);
-    if (isReq) {
-      SRpcMsg rspMsg = {
-          .handle = pMsg->handle, .code = TSDB_CODE_APP_NOT_READY, .ahandle = pMsg->ahandle, .refId = pMsg->refId};
-      rpcSendResponse(&rspMsg);
-    }
-    rpcFreeCont(pMsg->pCont);
   return;
-  }
 
-  if (isReq && pMsg->pCont == NULL) {
+_OVER_RSP_FREE:
-    dError("req:%s not processed since its empty, handle:%p app:%p", TMSG_INFO(msgType), pMsg->handle, pMsg->ahandle);
+  rpcFreeCont(pRpc->pCont);
-    SRpcMsg rspMsg = {
+  SRpcMsg simpleRsp = {.code = terrno, .info = pRpc->info};
-        .handle = pMsg->handle, .code = TSDB_CODE_INVALID_MSG_LEN, .ahandle = pMsg->ahandle, .refId = pMsg->refId};
+  rpcSendResponse(&simpleRsp);
-    rpcSendResponse(&rspMsg);
-    return;
-  }
-
-  if (pHandle->defaultNtype == NODE_END) {
-    dError("msg:%s not processed since no handle, handle:%p app:%p", TMSG_INFO(msgType), pMsg->handle, pMsg->ahandle);
-    if (isReq) {
-      SRpcMsg rspMsg = {
-          .handle = pMsg->handle, .code = TSDB_CODE_MSG_NOT_PROCESSED, .ahandle = pMsg->ahandle, .refId = pMsg->refId};
-      rpcSendResponse(&rspMsg);
-    }
-    rpcFreeCont(pMsg->pCont);
-    return;
-  }
-
-  pWrapper = &pDnode->wrappers[pHandle->defaultNtype];
-  if (pHandle->needCheckVgId) {
-    SMsgHead *pHead = pMsg->pCont;
-    int32_t   vgId = ntohl(pHead->vgId);
-    if (vgId == QNODE_HANDLE) {
-      pWrapper = &pDnode->wrappers[QNODE];
-    } else if (vgId == MNODE_HANDLE) {
-      pWrapper = &pDnode->wrappers[MNODE];
-    } else {
-    }
-  }
-
-  dTrace("msg:%s will be processed by %s, app:%p", TMSG_INFO(msgType), pWrapper->name, pMsg->ahandle);
-  if (isReq) {
-    assert(pMsg->refId != 0);
-  }
-  dmProcessRpcMsg(pWrapper, pMsg, pEpSet);
 }
 
 int32_t dmInitMsgHandle(SDnode *pDnode) {
@@ -210,7 +186,7 @@ int32_t dmInitMsgHandle(SDnode *pDnode) {
 
     for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
       SMgmtHandle  *pMgmt = taosArrayGet(pArray, i);
-      SMsgHandle  *pHandle = &pTrans->msgHandles[TMSG_INDEX(pMgmt->msgType)];
+      SDnodeHandle *pHandle = &pTrans->msgHandles[TMSG_INDEX(pMgmt->msgType)];
       if (pMgmt->needCheckVgId) {
         pHandle->needCheckVgId = pMgmt->needCheckVgId;
       }
@@ -226,41 +202,36 @@ int32_t dmInitMsgHandle(SDnode *pDnode) {
   return 0;
 }
 
-static void dmSendRpcRedirectRsp(SDnode *pDnode, const SRpcMsg *pReq) {
+static void dmSendRpcRedirectRsp(const SRpcMsg *pReq) {
+  SDnode *pDnode = dmInstance();
   SEpSet  epSet = {0};
-  dmGetMnodeEpSet(pDnode, &epSet);
+  dmGetMnodeEpSet(&pDnode->data, &epSet);
 
-  dDebug("RPC %p, req is redirected, num:%d use:%d", pReq->handle, epSet.numOfEps, epSet.inUse);
+  dDebug("RPC %p, req is redirected, num:%d use:%d", pReq->info.handle, epSet.numOfEps, epSet.inUse);
   for (int32_t i = 0; i < epSet.numOfEps; ++i) {
     dDebug("mnode index:%d %s:%u", i, epSet.eps[i].fqdn, epSet.eps[i].port);
-    if (strcmp(epSet.eps[i].fqdn, pDnode->input.localFqdn) == 0 && epSet.eps[i].port == pDnode->input.serverPort) {
+    if (strcmp(epSet.eps[i].fqdn, tsLocalFqdn) == 0 && epSet.eps[i].port == tsServerPort) {
       epSet.inUse = (i + 1) % epSet.numOfEps;
     }
 
     epSet.eps[i].port = htons(epSet.eps[i].port);
   }
-  SRpcMsg resp;
+
   SMEpSet msg = {.epSet = epSet};
   int32_t len = tSerializeSMEpSet(NULL, 0, &msg);
-  resp.pCont = rpcMallocCont(len);
-  resp.contLen = len;
-  tSerializeSMEpSet(resp.pCont, len, &msg);
 
-  resp.code = TSDB_CODE_RPC_REDIRECT;
+  SRpcMsg rsp = {
-  resp.handle = pReq->handle;
+      .code = TSDB_CODE_RPC_REDIRECT,
-  resp.refId = pReq->refId;
+      .info = pReq->info,
-  rpcSendResponse(&resp);
+      .contLen = len,
+  };
+  rsp.pCont = rpcMallocCont(len);
+  tSerializeSMEpSet(rsp.pCont, len, &msg);
+  rpcSendResponse(&rsp);
 }
 
-static inline void dmSendRpcRsp(SDnode *pDnode, const SRpcMsg *pRsp) {
+static inline void dmSendRecv(SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp) {
-  if (pRsp->code == TSDB_CODE_NODE_REDIRECT) {
+  SDnode *pDnode = dmInstance();
-    dmSendRpcRedirectRsp(pDnode, pRsp);
-  } else {
-    rpcSendResponse(pRsp);
-  }
-}
-
-static inline void dmSendRecv(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp) {
   if (pDnode->status != DND_STAT_RUNNING) {
     pRsp->code = TSDB_CODE_NODE_OFFLINE;
     rpcFreeCont(pReq->pCont);
@@ -270,150 +241,71 @@ static inline void dmSendRecv(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pReq, SRp
   }
 }
 
-static inline void dmSendToMnodeRecv(SMgmtWrapper *pWrapper, SRpcMsg *pReq, SRpcMsg *pRsp) {
+static inline int32_t dmSendReq(const SEpSet *pEpSet, SRpcMsg *pReq) {
-  SEpSet epSet = {0};
+  SDnode *pDnode = dmInstance();
-  dmGetMnodeEpSet(pWrapper->pDnode, &epSet);
+  if (pDnode->status != DND_STAT_RUNNING) {
-  dmSendRecv(pWrapper->pDnode, &epSet, pReq, pRsp);
-}
-
-static inline int32_t dmSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq) {
-  SDnode *pDnode = pWrapper->pDnode;
-  if (pDnode->status != DND_STAT_RUNNING || pDnode->trans.clientRpc == NULL) {
     rpcFreeCont(pReq->pCont);
     pReq->pCont = NULL;
     terrno = TSDB_CODE_NODE_OFFLINE;
-    dError("failed to send rpc msg since %s, handle:%p", terrstr(), pReq->handle);
+    dError("failed to send rpc msg since %s, handle:%p", terrstr(), pReq->info.handle);
     return -1;
-  }
+  } else {
-
     rpcSendRequest(pDnode->trans.clientRpc, pEpSet, pReq, NULL);
     return 0;
   }
+}
 
-static inline void dmSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
+static inline void dmSendRsp(const SRpcMsg *pMsg) {
-  if (pWrapper->procType != DND_PROC_CHILD) {
+  SMgmtWrapper *pWrapper = pMsg->info.wrapper;
-    dmSendRpcRsp(pWrapper->pDnode, pRsp);
+  if (InChildProc(pWrapper)) {
+    dmPutToProcPQueue(&pWrapper->proc, pMsg, sizeof(SRpcMsg), pMsg->pCont, pMsg->contLen, DND_FUNC_RSP);
   } else {
-    taosProcPutToParentQ(pWrapper->procObj, pRsp, sizeof(SRpcMsg), pRsp->pCont, pRsp->contLen, PROC_FUNC_RSP);
+    if (pMsg->code == TSDB_CODE_NODE_REDIRECT) {
+      dmSendRpcRedirectRsp(pMsg);
+    } else {
+      rpcSendResponse(pMsg);
+    }
   }
 }
 
-static inline void dmSendRedirectRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp, const SEpSet *pNewEpSet) {
+static inline void dmSendRedirectRsp(const SRpcMsg *pRsp, const SEpSet *pNewEpSet) {
-  ASSERT(pRsp->code == TSDB_CODE_RPC_REDIRECT);
+  SMgmtWrapper *pWrapper = pRsp->info.wrapper;
-  ASSERT(pRsp->pCont == NULL);
+  if (InChildProc(pWrapper)) {
-  if (pWrapper->procType != DND_PROC_CHILD) {
+    dmPutToProcPQueue(&pWrapper->proc, pRsp, sizeof(SRpcMsg), pRsp->pCont, pRsp->contLen, DND_FUNC_RSP);
-    SRpcMsg resp = {0};
+  } else {
+    SRpcMsg rsp = {0};
     SMEpSet msg = {.epSet = *pNewEpSet};
     int32_t len = tSerializeSMEpSet(NULL, 0, &msg);
-    resp.pCont = rpcMallocCont(len);
+    rsp.pCont = rpcMallocCont(len);
-    resp.contLen = len;
+    rsp.contLen = len;
-    tSerializeSMEpSet(resp.pCont, len, &msg);
+    tSerializeSMEpSet(rsp.pCont, len, &msg);
 
-    resp.code = TSDB_CODE_RPC_REDIRECT;
+    rsp.code = TSDB_CODE_RPC_REDIRECT;
-    resp.handle = pRsp->handle;
+    rsp.info = pRsp->info;
-    resp.refId = pRsp->refId;
+    rpcSendResponse(&rsp);
-    rpcSendResponse(&resp);
+  }
+}
+
+static inline void dmRegisterBrokenLinkArg(SRpcMsg *pMsg) {
+  SMgmtWrapper *pWrapper = pMsg->info.wrapper;
+  if (InChildProc(pWrapper)) {
+    dmPutToProcPQueue(&pWrapper->proc, pMsg, sizeof(SRpcMsg), pMsg->pCont, pMsg->contLen, DND_FUNC_REGIST);
   } else {
-    taosProcPutToParentQ(pWrapper->procObj, pRsp, sizeof(SRpcMsg), pRsp->pCont, pRsp->contLen, PROC_FUNC_RSP);
-  }
-}
-
-static inline void dmRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) {
-  if (pWrapper->procType != DND_PROC_CHILD) {
     rpcRegisterBrokenLinkArg(pMsg);
+  }
+}
+
+static inline void dmReleaseHandle(SRpcHandleInfo *pHandle, int8_t type) {
+  SMgmtWrapper *pWrapper = pHandle->wrapper;
+  if (InChildProc(pWrapper)) {
+    SRpcMsg msg = {.code = type, .info = *pHandle};
+    dmPutToProcPQueue(&pWrapper->proc, &msg, sizeof(SRpcMsg), NULL, 0, DND_FUNC_RELEASE);
   } else {
-    taosProcPutToParentQ(pWrapper->procObj, pMsg, sizeof(SRpcMsg), pMsg->pCont, pMsg->contLen, PROC_FUNC_REGIST);
+    rpcReleaseHandle(pHandle->handle, type);
   }
 }
 
-static inline void dmReleaseHandle(SMgmtWrapper *pWrapper, void *handle, int8_t type) {
+static bool rpcRfp(int32_t code) { return code == TSDB_CODE_RPC_REDIRECT; }
-  if (pWrapper->procType != DND_PROC_CHILD) {
-    rpcReleaseHandle(handle, type);
-  } else {
-    SRpcMsg msg = {.handle = handle, .code = type};
-    taosProcPutToParentQ(pWrapper->procObj, &msg, sizeof(SRpcMsg), NULL, 0, PROC_FUNC_RELEASE);
-  }
-}
-
-static void dmConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
-                                EProcFuncType ftype) {
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
-  pRpc->pCont = pCont;
-  dTrace("msg:%p, get from child queue, handle:%p app:%p", pMsg, pRpc->handle, pRpc->ahandle);
-
-  NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
-  int32_t   code = (*msgFp)(pWrapper->pMgmt, pMsg);
-
-  if (code != 0) {
-    dError("msg:%p, failed to process since code:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-    if (pRpc->msgType & 1U) {
-      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno, .refId = pRpc->refId};
-      dmSendRsp(pWrapper, &rsp);
-    }
-
-    dTrace("msg:%p, is freed", pMsg);
-    taosFreeQitem(pMsg);
-    rpcFreeCont(pCont);
-  }
-}
-
-static void dmConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
-                                 EProcFuncType ftype) {
-  int32_t code = pMsg->code & 0xFFFF;
-  pMsg->pCont = pCont;
-
-  if (ftype == PROC_FUNC_REQ) {
-    ASSERT(1);
-    dTrace("msg:%p, get from parent queue, send req:%s handle:%p code:0x%04x, app:%p", pMsg, TMSG_INFO(pMsg->msgType),
-           pMsg->handle, code, pMsg->ahandle);
-    dmSendReq(pWrapper, (SEpSet *)((char *)pMsg + sizeof(SRpcMsg)), pMsg);
-  } else if (ftype == PROC_FUNC_RSP) {
-    dTrace("msg:%p, get from parent queue, rsp handle:%p code:0x%04x, app:%p", pMsg, pMsg->handle, code, pMsg->ahandle);
-    pMsg->refId = taosProcRemoveHandle(pWrapper->procObj, pMsg->handle);
-    dmSendRpcRsp(pWrapper->pDnode, pMsg);
-  } else if (ftype == PROC_FUNC_REGIST) {
-    dTrace("msg:%p, get from parent queue, regist handle:%p code:0x%04x, app:%p", pMsg, pMsg->handle, code,
-           pMsg->ahandle);
-    rpcRegisterBrokenLinkArg(pMsg);
-  } else if (ftype == PROC_FUNC_RELEASE) {
-    dTrace("msg:%p, get from parent queue, release handle:%p code:0x%04x, app:%p", pMsg, pMsg->handle, code,
-           pMsg->ahandle);
-    taosProcRemoveHandle(pWrapper->procObj, pMsg->handle);
-    rpcReleaseHandle(pMsg->handle, (int8_t)pMsg->code);
-    rpcFreeCont(pCont);
-  } else {
-    dError("msg:%p, invalid ftype:%d while get from parent queue, handle:%p", pMsg, ftype, pMsg->handle);
-  }
-
-  taosMemoryFree(pMsg);
-}
-
-SProcCfg dmGenProcCfg(SMgmtWrapper *pWrapper) {
-  SProcCfg cfg = {
-      .childConsumeFp = (ProcConsumeFp)dmConsumeChildQueue,
-      .childMallocHeadFp = (ProcMallocFp)taosAllocateQitem,
-      .childFreeHeadFp = (ProcFreeFp)taosFreeQitem,
-      .childMallocBodyFp = (ProcMallocFp)rpcMallocCont,
-      .childFreeBodyFp = (ProcFreeFp)rpcFreeCont,
-      .parentConsumeFp = (ProcConsumeFp)dmConsumeParentQueue,
-      .parentMallocHeadFp = (ProcMallocFp)taosMemoryMalloc,
-      .parentFreeHeadFp = (ProcFreeFp)taosMemoryFree,
-      .parentMallocBodyFp = (ProcMallocFp)rpcMallocCont,
-      .parentFreeBodyFp = (ProcFreeFp)rpcFreeCont,
-      .shm = pWrapper->procShm,
-      .parent = pWrapper,
-      .name = pWrapper->name,
-  };
-  return cfg;
-}
-
-static bool rpcRfp(int32_t code) {
-  if (code == TSDB_CODE_RPC_REDIRECT) {
-    return true;
-  } else {
-    return false;
-  }
-}
 
 int32_t dmInitClient(SDnode *pDnode) {
   SDnodeTrans *pTrans = &pDnode->trans;
@@ -421,7 +313,7 @@ int32_t dmInitClient(SDnode *pDnode) {
   SRpcInit rpcInit = {0};
   rpcInit.label = "DND";
   rpcInit.numOfThreads = 1;
-  rpcInit.cfp = (RpcCfp)dmProcessMsg;
+  rpcInit.cfp = (RpcCfp)dmProcessRpcMsg;
   rpcInit.sessions = 1024;
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
@@ -454,8 +346,7 @@ void dmCleanupClient(SDnode *pDnode) {
   }
 }
 
-static inline int32_t dmGetHideUserAuth(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret,
+static inline int32_t dmGetHideUserAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
-                                        char *ckey) {
   int32_t code = 0;
   char    pass[TSDB_PASSWORD_LEN + 1] = {0};
 
@@ -479,7 +370,7 @@ static inline int32_t dmGetHideUserAuth(SDnode *pDnode, char *user, char *spi, c
 
 static inline int32_t dmRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret,
                                              char *ckey) {
-  if (dmGetHideUserAuth(pDnode, user, spi, encrypt, secret, ckey) == 0) {
+  if (dmGetHideUserAuth(user, spi, encrypt, secret, ckey) == 0) {
     dTrace("user:%s, get auth from mnode, spi:%d encrypt:%d", user, *spi, *encrypt);
     return 0;
   }
@@ -490,12 +381,12 @@ static inline int32_t dmRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *s
   void   *pReq = rpcMallocCont(contLen);
   tSerializeSAuthReq(pReq, contLen, &authReq);
 
-  SRpcMsg rpcMsg = {.pCont = pReq, .contLen = contLen, .msgType = TDMT_MND_AUTH, .ahandle = (void *)9528};
+  SRpcMsg rpcMsg = {.pCont = pReq, .contLen = contLen, .msgType = TDMT_MND_AUTH, .info.ahandle = (void *)9528};
   SRpcMsg rpcRsp = {0};
   SEpSet  epSet = {0};
   dTrace("user:%s, send user auth req to other mnodes, spi:%d encrypt:%d", user, authReq.spi, authReq.encrypt);
-  dmGetMnodeEpSet(pDnode, &epSet);
+  dmGetMnodeEpSet(&pDnode->data, &epSet);
-  dmSendRecv(pDnode, &epSet, &rpcMsg, &rpcRsp);
+  dmSendRecv(&epSet, &rpcMsg, &rpcRsp);
 
   if (rpcRsp.code != 0) {
     terrno = rpcRsp.code;
@@ -519,12 +410,11 @@ int32_t dmInitServer(SDnode *pDnode) {
   SDnodeTrans *pTrans = &pDnode->trans;
 
   SRpcInit rpcInit = {0};
-
+  strncpy(rpcInit.localFqdn, tsLocalFqdn, strlen(tsLocalFqdn));
-  strncpy(rpcInit.localFqdn, pDnode->input.localFqdn, strlen(pDnode->input.localFqdn));
+  rpcInit.localPort = tsServerPort;
-  rpcInit.localPort = pDnode->input.serverPort;
   rpcInit.label = "DND";
   rpcInit.numOfThreads = tsNumOfRpcThreads;
-  rpcInit.cfp = (RpcCfp)dmProcessMsg;
+  rpcInit.cfp = (RpcCfp)dmProcessRpcMsg;
   rpcInit.sessions = tsMaxShellConns;
   rpcInit.connType = TAOS_CONN_SERVER;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
@@ -550,17 +440,15 @@ void dmCleanupServer(SDnode *pDnode) {
   }
 }
 
-SMsgCb dmGetMsgcb(SMgmtWrapper *pWrapper) {
+SMsgCb dmGetMsgcb(SDnode *pDnode) {
   SMsgCb msgCb = {
-      .pWrapper = pWrapper,
+      .clientRpc = pDnode->trans.clientRpc,
-      .clientRpc = pWrapper->pDnode->trans.clientRpc,
       .sendReqFp = dmSendReq,
       .sendRspFp = dmSendRsp,
-      .sendMnodeRecvFp = dmSendToMnodeRecv,
       .sendRedirectRspFp = dmSendRedirectRsp,
       .registerBrokenLinkArgFp = dmRegisterBrokenLinkArg,
       .releaseHandleFp = dmReleaseHandle,
-      .reportStartupFp = dmReportStartupByWrapper,
+      .reportStartupFp = dmReportStartup,
   };
   return msgCb;
 }

source/dnode/mgmt/node_util/inc/dmUtil.h

@@ -26,7 +26,6 @@
 #include "tlog.h"
 #include "tmsg.h"
 #include "tmsgcb.h"
-#include "tprocess.h"
 #include "tqueue.h"
 #include "trpc.h"
 #include "tthread.h"
@@ -81,44 +80,53 @@ typedef enum {
   DND_PROC_TEST,
 } EDndProcType;
 
-typedef int32_t (*ProcessCreateNodeFp)(struct SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg);
+typedef enum {
-typedef int32_t (*ProcessDropNodeFp)(struct SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg);
+  DND_FUNC_REQ = 1,
-typedef bool (*IsNodeDeployedFp)(struct SDnode *pDnode, EDndNodeType ntype);
+  DND_FUNC_RSP = 2,
+  DND_FUNC_REGIST = 3,
+  DND_FUNC_RELEASE = 4,
+} EProcFuncType;
+
+typedef int32_t (*ProcessCreateNodeFp)(EDndNodeType ntype, SRpcMsg *pMsg);
+typedef int32_t (*ProcessDropNodeFp)(EDndNodeType ntype, SRpcMsg *pMsg);
+typedef bool (*IsNodeRequiredFp)(EDndNodeType ntype);
+
+typedef struct {
+  int32_t      dnodeId;
+  int64_t      clusterId;
+  int64_t      dnodeVer;
+  int64_t      updateTime;
+  int64_t      rebootTime;
+  bool         dropped;
+  bool         stopped;
+  SEpSet       mnodeEps;
+  SArray      *dnodeEps;
+  SHashObj    *dnodeHash;
+  SRWLatch     latch;
+  SMsgCb       msgCb;
+} SDnodeData;
 
 typedef struct {
   const char         *path;
   const char         *name;
+  SDnodeData         *pData;
   SMsgCb              msgCb;
-  int32_t             dnodeId;
-  int64_t             clusterId;
-  const char         *localEp;
-  const char         *firstEp;
-  const char         *secondEp;
-  const char         *localFqdn;
-  uint16_t            serverPort;
-  int32_t             supportVnodes;
-  int32_t             numOfDisks;
-  SDiskCfg           *disks;
-  const char         *dataDir;
-  struct SDnode      *pDnode;
   ProcessCreateNodeFp processCreateNodeFp;
   ProcessDropNodeFp   processDropNodeFp;
-  IsNodeDeployedFp    isNodeDeployedFp;
+  IsNodeRequiredFp    isNodeRequiredFp;
 } SMgmtInputOpt;
 
 typedef struct {
-  int32_t dnodeId;
   void *pMgmt;
-  SEpSet  mnodeEps;
 } SMgmtOutputOpt;
 
-typedef int32_t (*NodeMsgFp)(void *pMgmt, SNodeMsg *pMsg);
+typedef int32_t (*NodeMsgFp)(void *pMgmt, SRpcMsg *pMsg);
-typedef int32_t (*NodeOpenFp)(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput);
+typedef int32_t (*NodeOpenFp)(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput);
 typedef void (*NodeCloseFp)(void *pMgmt);
 typedef int32_t (*NodeStartFp)(void *pMgmt);
 typedef void (*NodeStopFp)(void *pMgmt);
-typedef int32_t (*NodeCreateFp)(const SMgmtInputOpt *pInput, SNodeMsg *pMsg);
+typedef int32_t (*NodeCreateFp)(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
-typedef int32_t (*NodeDropFp)(void *pMgmt, SNodeMsg *pMsg);
+typedef int32_t (*NodeDropFp)(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
 typedef int32_t (*NodeRequireFp)(const SMgmtInputOpt *pInput, bool *required);
 typedef SArray *(*NodeGetHandlesFp)();  // array of SMgmtHandle
 
@@ -144,8 +152,8 @@ const char *dmStatStr(EDndRunStatus stype);
 const char *dmNodeLogName(EDndNodeType ntype);
 const char *dmNodeProcName(EDndNodeType ntype);
 const char *dmNodeName(EDndNodeType ntype);
-const char *dmEventStr(EDndEvent etype);
 const char *dmProcStr(EDndProcType ptype);
+const char *dmFuncStr(EProcFuncType etype);
 void       *dmSetMgmtHandle(SArray *pArray, tmsg_t msgType, void *nodeMsgFp, bool needCheckVgId);
 void        dmGetMonitorSystemInfo(SMonSysInfo *pInfo);
 
@@ -156,30 +164,12 @@ TdFilePtr dmCheckRunning(const char *dataDir);
 int32_t   dmReadShmFile(const char *path, const char *name, EDndNodeType runType, SShm *pShm);
 int32_t   dmWriteShmFile(const char *path, const char *name, const SShm *pShm);
 
-// common define
+// dmEps.c
-typedef struct {
+int32_t dmReadEps(SDnodeData *pData);
-  int32_t     dnodeId;
+int32_t dmWriteEps(SDnodeData *pData);
-  int64_t     clusterId;
+void    dmUpdateEps(SDnodeData *pData, SArray *pDnodeEps);
-  int64_t     dnodeVer;
+void    dmGetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet);
-  int64_t     updateTime;
+void    dmSetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet);
-  int64_t     rebootTime;
-  int32_t     unsyncedVgId;
-  ESyncState  vndState;
-  ESyncState  mndState;
-  bool        dropped;
-  bool        stopped;
-  SEpSet      mnodeEps;
-  SArray     *dnodeEps;
-  SHashObj   *dnodeHash;
-  SRWLatch    latch;
-  SMsgCb      msgCb;
-  const char *localEp;
-  const char *localFqdn;
-  const char *firstEp;
-  const char *secondEp;
-  int32_t     supportVnodes;
-  uint16_t    serverPort;
-} SDnodeData;
 
 #ifdef __cplusplus
 }

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

@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "dmUtil.h"
-
-static int8_t once = DND_ENV_INIT;
-
-int32_t dmInit() {
-  dInfo("start to init env");
-  if (atomic_val_compare_exchange_8(&once, DND_ENV_INIT, DND_ENV_READY) != DND_ENV_INIT) {
-    dError("env is already initialized");
-    terrno = TSDB_CODE_REPEAT_INIT;
-    return -1;
-  }
-
-  taosIgnSIGPIPE();
-  taosBlockSIGPIPE();
-  taosResolveCRC();
-
-  SMonCfg monCfg = {0};
-  monCfg.maxLogs = tsMonitorMaxLogs;
-  monCfg.port = tsMonitorPort;
-  monCfg.server = tsMonitorFqdn;
-  monCfg.comp = tsMonitorComp;
-  if (monInit(&monCfg) != 0) {
-    dError("failed to init monitor since %s", terrstr());
-    return -1;
-  }
-
-  dInfo("env is initialized");
-  return 0;
-}
-
-void dmCleanup() {
-  dDebug("start to cleanup env");
-  if (atomic_val_compare_exchange_8(&once, DND_ENV_READY, DND_ENV_CLEANUP) != DND_ENV_READY) {
-    dError("env is already cleaned up");
-    return;
-  }
-
-  monCleanup();
-  syncCleanUp();
-  walCleanUp();
-  udfcClose();
-  udfStopUdfd();
-  taosStopCacheRefreshWorker();
-  dInfo("env is cleaned up");
-}

source/dnode/mgmt/node_util/src/dmEps.c

@@ -14,16 +14,16 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dmInt.h"
+#include "dmUtil.h"
 
-static void dmPrintEps(SDnodeMgmt *pMgmt);
+static void dmPrintEps(SDnodeData *pData);
-static bool dmIsEpChanged(SDnodeMgmt *pMgmt, int32_t dnodeId, const char *ep);
+static bool dmIsEpChanged(SDnodeData *pData, int32_t dnodeId, const char *ep);
-static void dmResetEps(SDnodeMgmt *pMgmt, SArray *dnodeEps);
+static void dmResetEps(SDnodeData *pData, SArray *dnodeEps);
 
-static void dmGetDnodeEp(SDnodeMgmt *pMgmt, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort) {
+static void dmGetDnodeEp(SDnodeData *pData, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort) {
-  taosRLockLatch(&pMgmt->data.latch);
+  taosRLockLatch(&pData->latch);
 
-  SDnodeEp *pDnodeEp = taosHashGet(pMgmt->data.dnodeHash, &dnodeId, sizeof(int32_t));
+  SDnodeEp *pDnodeEp = taosHashGet(pData->dnodeHash, &dnodeId, sizeof(int32_t));
   if (pDnodeEp != NULL) {
     if (pPort != NULL) {
       *pPort = pDnodeEp->ep.port;
@@ -36,10 +36,10 @@ static void dmGetDnodeEp(SDnodeMgmt *pMgmt, int32_t dnodeId, char *pEp, char *pF
     }
   }
 
-  taosRUnLockLatch(&pMgmt->data.latch);
+  taosRUnLockLatch(&pData->latch);
 }
 
-int32_t dmReadEps(SDnodeMgmt *pMgmt) {
+int32_t dmReadEps(SDnodeData *pData) {
   int32_t   code = TSDB_CODE_INVALID_JSON_FORMAT;
   int32_t   len = 0;
   int32_t   maxLen = 256 * 1024;
@@ -48,13 +48,13 @@ int32_t dmReadEps(SDnodeMgmt *pMgmt) {
   char      file[PATH_MAX] = {0};
   TdFilePtr pFile = NULL;
 
-  pMgmt->data.dnodeEps = taosArrayInit(1, sizeof(SDnodeEp));
+  pData->dnodeEps = taosArrayInit(1, sizeof(SDnodeEp));
-  if (pMgmt->data.dnodeEps == NULL) {
+  if (pData->dnodeEps == NULL) {
     dError("failed to calloc dnodeEp array since %s", strerror(errno));
     goto _OVER;
   }
 
-  snprintf(file, sizeof(file), "%s%sdnode.json", pMgmt->path, TD_DIRSEP);
+  snprintf(file, sizeof(file), "%s%sdnode%sdnode.json", tsDataDir, TD_DIRSEP, TD_DIRSEP);
   pFile = taosOpenFile(file, TD_FILE_READ);
   if (pFile == NULL) {
     code = 0;
@@ -79,21 +79,21 @@ int32_t dmReadEps(SDnodeMgmt *pMgmt) {
     dError("failed to read %s since dnodeId not found", file);
     goto _OVER;
   }
-  pMgmt->data.dnodeId = dnodeId->valueint;
+  pData->dnodeId = dnodeId->valueint;
 
   cJSON *clusterId = cJSON_GetObjectItem(root, "clusterId");
   if (!clusterId || clusterId->type != cJSON_String) {
     dError("failed to read %s since clusterId not found", file);
     goto _OVER;
   }
-  pMgmt->data.clusterId = atoll(clusterId->valuestring);
+  pData->clusterId = atoll(clusterId->valuestring);
 
   cJSON *dropped = cJSON_GetObjectItem(root, "dropped");
   if (!dropped || dropped->type != cJSON_Number) {
     dError("failed to read %s since dropped not found", file);
     goto _OVER;
   }
-  pMgmt->data.dropped = dropped->valueint;
+  pData->dropped = dropped->valueint;
 
   cJSON *dnodes = cJSON_GetObjectItem(root, "dnodes");
   if (!dnodes || dnodes->type != cJSON_Array) {
@@ -143,29 +143,29 @@ int32_t dmReadEps(SDnodeMgmt *pMgmt) {
     }
     dnodeEp.isMnode = isMnode->valueint;
 
-    taosArrayPush(pMgmt->data.dnodeEps, &dnodeEp);
+    taosArrayPush(pData->dnodeEps, &dnodeEp);
   }
 
   code = 0;
   dDebug("succcessed to read file %s", file);
-  dmPrintEps(pMgmt);
+  dmPrintEps(pData);
 
 _OVER:
   if (content != NULL) taosMemoryFree(content);
   if (root != NULL) cJSON_Delete(root);
   if (pFile != NULL) taosCloseFile(&pFile);
 
-  if (taosArrayGetSize(pMgmt->data.dnodeEps) == 0) {
+  if (taosArrayGetSize(pData->dnodeEps) == 0) {
     SDnodeEp dnodeEp = {0};
     dnodeEp.isMnode = 1;
-    taosGetFqdnPortFromEp(pMgmt->data.firstEp, &dnodeEp.ep);
+    taosGetFqdnPortFromEp(tsFirst, &dnodeEp.ep);
-    taosArrayPush(pMgmt->data.dnodeEps, &dnodeEp);
+    taosArrayPush(pData->dnodeEps, &dnodeEp);
   }
 
-  dmResetEps(pMgmt, pMgmt->data.dnodeEps);
+  dmResetEps(pData, pData->dnodeEps);
 
-  if (dmIsEpChanged(pMgmt, pMgmt->data.dnodeId, pMgmt->data.localEp)) {
+  if (dmIsEpChanged(pData, pData->dnodeId, tsLocalEp)) {
-    dError("localEp %s different with %s and need reconfigured", pMgmt->data.localEp, file);
+    dError("localEp %s different with %s and need reconfigured", tsLocalEp, file);
     return -1;
   }
 
@@ -173,11 +173,12 @@ _OVER:
   return code;
 }
 
-int32_t dmWriteEps(SDnodeMgmt *pMgmt) {
+int32_t dmWriteEps(SDnodeData *pData) {
   char file[PATH_MAX] = {0};
   char realfile[PATH_MAX] = {0};
-  snprintf(file, sizeof(file), "%s%sdnode.json.bak", pMgmt->path, TD_DIRSEP);
+
-  snprintf(realfile, sizeof(realfile), "%s%sdnode.json", pMgmt->path, TD_DIRSEP);
+  snprintf(file, sizeof(file), "%s%sdnode%sdnode.json.bak", tsDataDir, TD_DIRSEP, TD_DIRSEP);
+  snprintf(realfile, sizeof(realfile), "%s%sdnode%sdnode.json", tsDataDir, TD_DIRSEP, TD_DIRSEP);
 
   TdFilePtr pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC);
   if (pFile == NULL) {
@@ -191,14 +192,14 @@ int32_t dmWriteEps(SDnodeMgmt *pMgmt) {
   char   *content = taosMemoryCalloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
-  len += snprintf(content + len, maxLen - len, "  \"dnodeId\": %d,\n", pMgmt->data.dnodeId);
+  len += snprintf(content + len, maxLen - len, "  \"dnodeId\": %d,\n", pData->dnodeId);
-  len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%" PRId64 "\",\n", pMgmt->data.clusterId);
+  len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%" PRId64 "\",\n", pData->clusterId);
-  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d,\n", pMgmt->data.dropped);
+  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d,\n", pData->dropped);
   len += snprintf(content + len, maxLen - len, "  \"dnodes\": [{\n");
 
-  int32_t numOfEps = (int32_t)taosArrayGetSize(pMgmt->data.dnodeEps);
+  int32_t numOfEps = (int32_t)taosArrayGetSize(pData->dnodeEps);
   for (int32_t i = 0; i < numOfEps; ++i) {
-    SDnodeEp *pDnodeEp = taosArrayGet(pMgmt->data.dnodeEps, i);
+    SDnodeEp *pDnodeEp = taosArrayGet(pData->dnodeEps, i);
     len += snprintf(content + len, maxLen - len, "    \"id\": %d,\n", pDnodeEp->id);
     len += snprintf(content + len, maxLen - len, "    \"fqdn\": \"%s\",\n", pDnodeEp->ep.fqdn);
     len += snprintf(content + len, maxLen - len, "    \"port\": %u,\n", pDnodeEp->ep.port);
@@ -222,41 +223,41 @@ int32_t dmWriteEps(SDnodeMgmt *pMgmt) {
     return -1;
   }
 
-  pMgmt->data.updateTime = taosGetTimestampMs();
+  pData->updateTime = taosGetTimestampMs();
   dDebug("successed to write %s", realfile);
   return 0;
 }
 
-void dmUpdateEps(SDnodeMgmt *pMgmt, SArray *eps) {
+void dmUpdateEps(SDnodeData *pData, SArray *eps) {
   int32_t numOfEps = taosArrayGetSize(eps);
   if (numOfEps <= 0) return;
 
-  taosWLockLatch(&pMgmt->data.latch);
+  taosWLockLatch(&pData->latch);
 
-  int32_t numOfEpsOld = (int32_t)taosArrayGetSize(pMgmt->data.dnodeEps);
+  int32_t numOfEpsOld = (int32_t)taosArrayGetSize(pData->dnodeEps);
   if (numOfEps != numOfEpsOld) {
-    dmResetEps(pMgmt, eps);
+    dmResetEps(pData, eps);
-    dmWriteEps(pMgmt);
+    dmWriteEps(pData);
   } else {
     int32_t size = numOfEps * sizeof(SDnodeEp);
-    if (memcmp(pMgmt->data.dnodeEps->pData, eps->pData, size) != 0) {
+    if (memcmp(pData->dnodeEps->pData, eps->pData, size) != 0) {
-      dmResetEps(pMgmt, eps);
+      dmResetEps(pData, eps);
-      dmWriteEps(pMgmt);
+      dmWriteEps(pData);
     }
   }
 
-  taosWUnLockLatch(&pMgmt->data.latch);
+  taosWUnLockLatch(&pData->latch);
 }
 
-static void dmResetEps(SDnodeMgmt *pMgmt, SArray *dnodeEps) {
+static void dmResetEps(SDnodeData *pData, SArray *dnodeEps) {
-  if (pMgmt->data.dnodeEps != dnodeEps) {
+  if (pData->dnodeEps != dnodeEps) {
-    SArray *tmp = pMgmt->data.dnodeEps;
+    SArray *tmp = pData->dnodeEps;
-    pMgmt->data.dnodeEps = taosArrayDup(dnodeEps);
+    pData->dnodeEps = taosArrayDup(dnodeEps);
     taosArrayDestroy(tmp);
   }
 
-  pMgmt->data.mnodeEps.inUse = 0;
+  pData->mnodeEps.inUse = 0;
-  pMgmt->data.mnodeEps.numOfEps = 0;
+  pData->mnodeEps.numOfEps = 0;
 
   int32_t mIndex = 0;
   int32_t numOfEps = (int32_t)taosArrayGetSize(dnodeEps);
@@ -265,35 +266,35 @@ static void dmResetEps(SDnodeMgmt *pMgmt, SArray *dnodeEps) {
     SDnodeEp *pDnodeEp = taosArrayGet(dnodeEps, i);
     if (!pDnodeEp->isMnode) continue;
     if (mIndex >= TSDB_MAX_REPLICA) continue;
-    pMgmt->data.mnodeEps.numOfEps++;
+    pData->mnodeEps.numOfEps++;
 
-    pMgmt->data.mnodeEps.eps[mIndex] = pDnodeEp->ep;
+    pData->mnodeEps.eps[mIndex] = pDnodeEp->ep;
     mIndex++;
   }
 
   for (int32_t i = 0; i < numOfEps; i++) {
     SDnodeEp *pDnodeEp = taosArrayGet(dnodeEps, i);
-    taosHashPut(pMgmt->data.dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp));
+    taosHashPut(pData->dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp));
   }
 
-  dmPrintEps(pMgmt);
+  dmPrintEps(pData);
 }
 
-static void dmPrintEps(SDnodeMgmt *pMgmt) {
+static void dmPrintEps(SDnodeData *pData) {
-  int32_t numOfEps = (int32_t)taosArrayGetSize(pMgmt->data.dnodeEps);
+  int32_t numOfEps = (int32_t)taosArrayGetSize(pData->dnodeEps);
   dDebug("print dnode ep list, num:%d", numOfEps);
   for (int32_t i = 0; i < numOfEps; i++) {
-    SDnodeEp *pEp = taosArrayGet(pMgmt->data.dnodeEps, i);
+    SDnodeEp *pEp = taosArrayGet(pData->dnodeEps, i);
-    dDebug("dnode:%d, fqdn:%s port:%u isMnode:%d", pEp->id, pEp->ep.fqdn, pEp->ep.port, pEp->isMnode);
+    dDebug("dnode:%d, fqdn:%s port:%u is_mnode:%d", pEp->id, pEp->ep.fqdn, pEp->ep.port, pEp->isMnode);
   }
 }
 
-static bool dmIsEpChanged(SDnodeMgmt *pMgmt, int32_t dnodeId, const char *ep) {
+static bool dmIsEpChanged(SDnodeData *pData, int32_t dnodeId, const char *ep) {
   bool changed = false;
   if (dnodeId == 0) return changed;
-  taosRLockLatch(&pMgmt->data.latch);
+  taosRLockLatch(&pData->latch);
 
-  SDnodeEp *pDnodeEp = taosHashGet(pMgmt->data.dnodeHash, &dnodeId, sizeof(int32_t));
+  SDnodeEp *pDnodeEp = taosHashGet(pData->dnodeHash, &dnodeId, sizeof(int32_t));
   if (pDnodeEp != NULL) {
     char epstr[TSDB_EP_LEN + 1] = {0};
     snprintf(epstr, TSDB_EP_LEN, "%s:%u", pDnodeEp->ep.fqdn, pDnodeEp->ep.port);
@@ -303,6 +304,24 @@ static bool dmIsEpChanged(SDnodeMgmt *pMgmt, int32_t dnodeId, const char *ep) {
     }
   }
 
-  taosRUnLockLatch(&pMgmt->data.latch);
+  taosRUnLockLatch(&pData->latch);
   return changed;
 }
+
+void dmGetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet) {
+  taosRLockLatch(&pData->latch);
+  *pEpSet = pData->mnodeEps;
+  taosRUnLockLatch(&pData->latch);
+}
+
+void dmSetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet) {
+  dInfo("mnode is changed, num:%d use:%d", pEpSet->numOfEps, pEpSet->inUse);
+
+  taosWLockLatch(&pData->latch);
+  pData->mnodeEps = *pEpSet;
+  for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
+    dInfo("mnode index:%d %s:%u", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
+  }
+
+  taosWUnLockLatch(&pData->latch);
+}

source/dnode/mgmt/node_util/src/dmUtil.c

@@ -80,19 +80,6 @@ const char *dmNodeName(EDndNodeType ntype) {
   }
 }
 
-const char *dmEventStr(EDndEvent ev) {
-  switch (ev) {
-    case DND_EVENT_START:
-      return "start";
-    case DND_EVENT_STOP:
-      return "stop";
-    case DND_EVENT_CHILD:
-      return "child";
-    default:
-      return "UNKNOWN";
-  }
-}
-
 const char *dmProcStr(EDndProcType etype) {
   switch (etype) {
     case DND_PROC_SINGLE:
@@ -108,6 +95,21 @@ const char *dmProcStr(EDndProcType etype) {
   }
 }
 
+const char *dmFuncStr(EProcFuncType etype) {
+  switch (etype) {
+    case DND_FUNC_REQ:
+      return "req";
+    case DND_FUNC_RSP:
+      return "rsp";
+    case DND_FUNC_REGIST:
+      return "regist";
+    case DND_FUNC_RELEASE:
+      return "release";
+    default:
+      return "UNKNOWN";
+  }
+}
+
 void *dmSetMgmtHandle(SArray *pArray, tmsg_t msgType, void *nodeMsgFp, bool needCheckVgId) {
   SMgmtHandle handle = {
       .msgType = msgType,

source/dnode/mgmt/test/CMakeLists.txt

@@ -3,7 +3,7 @@ if(${BUILD_TEST})
     add_subdirectory(qnode)
     add_subdirectory(bnode)
     add_subdirectory(snode)
-    #add_subdirectory(mnode)
+    add_subdirectory(mnode)
     add_subdirectory(vnode)
     add_subdirectory(sut)
 endif(${BUILD_TEST})

source/dnode/mgmt/test/bnode/dbnode.cpp

@@ -14,11 +14,10 @@
 class DndTestBnode : public ::testing::Test {
  protected:
   static void SetUpTestSuite() {
-    test.Init("/tmp/dnode_test_bnode", 9112);
+    test.Init("/tmp/dbnodeTest", 9112);
     taosMsleep(1100);
   }
   static void TearDownTestSuite() { test.Cleanup(); }
-
   static Testbase test;
 
  public:
@@ -68,7 +67,7 @@ TEST_F(DndTestBnode, 01_Create_Bnode) {
     ASSERT_EQ(pRsp->code, TSDB_CODE_NODE_ALREADY_DEPLOYED);
   }
 
-  test.Restart();
+  // test.Restart();
 
   {
     SDCreateBnodeReq createReq = {0};
@@ -84,7 +83,6 @@ TEST_F(DndTestBnode, 01_Create_Bnode) {
 }
 
 TEST_F(DndTestBnode, 02_Drop_Bnode) {
-#if 0  
   {
     SDDropBnodeReq dropReq = {0};
     dropReq.dnodeId = 2;
@@ -97,7 +95,7 @@ TEST_F(DndTestBnode, 02_Drop_Bnode) {
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_INVALID_OPTION);
   }
-#endif
+
   {
     SDDropBnodeReq dropReq = {0};
     dropReq.dnodeId = 1;
@@ -124,7 +122,7 @@ TEST_F(DndTestBnode, 02_Drop_Bnode) {
     ASSERT_EQ(pRsp->code, TSDB_CODE_NODE_NOT_DEPLOYED);
   }
 
-  test.Restart();
+  // test.Restart();
 
   {
     SDDropBnodeReq dropReq = {0};

source/dnode/mgmt/test/mnode/dmnode.cpp

@@ -13,7 +13,7 @@
 
 class DndTestMnode : public ::testing::Test {
  protected:
-  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_mnode", 9114); }
+  static void SetUpTestSuite() { test.Init("/tmp/dmnodeTest", 9114); }
   static void TearDownTestSuite() { test.Cleanup(); }
 
   static Testbase test;

source/dnode/mgmt/test/qnode/dqnode.cpp

@@ -13,7 +13,7 @@
 
 class DndTestQnode : public ::testing::Test {
  protected:
-  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_qnode", 9111); }
+  static void SetUpTestSuite() { test.Init("/tmp/dqnodeTest", 9111); }
   static void TearDownTestSuite() { test.Cleanup(); }
 
   static Testbase test;

source/dnode/mgmt/test/snode/dsnode.cpp

@@ -13,7 +13,7 @@
 
 class DndTestSnode : public ::testing::Test {
  protected:
-  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_snode", 9113); }
+  static void SetUpTestSuite() { test.Init("/tmp/dsnodeTest", 9113); }
   static void TearDownTestSuite() { test.Cleanup(); }
 
   static Testbase test;

source/dnode/mgmt/test/sut/inc/client.h

@@ -18,9 +18,8 @@
 
 class TestClient {
  public:
-  bool Init(const char* user, const char* pass, const char* fqdn, uint16_t port);
+  bool Init(const char* user, const char* pass);
   void Cleanup();
-
   void DoInit();
 
   SRpcMsg* SendReq(SRpcMsg* pReq);
@@ -29,8 +28,6 @@ class TestClient {
   void     Restart();
 
  private:
-  char     fqdn[TSDB_FQDN_LEN];
-  uint16_t port;
   char     user[128];
   char     pass[128];
   void*    clientRpc;

source/dnode/mgmt/test/sut/inc/server.h

@@ -18,21 +18,11 @@
 
 class TestServer {
  public:
-  bool Start(const char* path, const char* fqdn, uint16_t port, const char* firstEp);
+  bool Start();
   void Stop();
-  void Restart();
-  bool DoStart();
 
  private:
-  SDnodeOpt BuildOption(const char* path, const char* fqdn, uint16_t port, const char* firstEp);
-
- private:
-  SDnode*    pDnode;
   TdThread threadId;
-  char       path[PATH_MAX];
-  char       fqdn[TSDB_FQDN_LEN];
-  char       firstEp[TSDB_EP_LEN];
-  uint16_t   port;
 };
 
 #endif /* _TD_TEST_SERVER_H_ */

source/dnode/mgmt/test/sut/src/client.cpp

@@ -58,11 +58,9 @@ void TestClient::DoInit() {
   tsem_init(&this->sem, 0, 0);
 }
 
-bool TestClient::Init(const char* user, const char* pass, const char* fqdn, uint16_t port) {
+bool TestClient::Init(const char* user, const char* pass) {
-  strcpy(this->fqdn, fqdn);
   strcpy(this->user, user);
   strcpy(this->pass, pass);
-  this->port = port;
   this->pRsp = NULL;
   this->DoInit();
   return true;
@@ -77,9 +75,10 @@ void TestClient::Restart() {
   this->Cleanup();
   this->DoInit();
 }
+
 SRpcMsg* TestClient::SendReq(SRpcMsg* pReq) {
   SEpSet epSet = {0};
-  addEpIntoEpSet(&epSet, fqdn, port);
+  addEpIntoEpSet(&epSet, tsLocalFqdn, tsServerPort);
   rpcSendRequest(clientRpc, &epSet, pReq, NULL);
   tsem_wait(&sem);
   uInfo("y response:%s from dnode, code:0x%x, msgSize: %d", TMSG_INFO(pRsp->msgType), pRsp->code, pRsp->contLen);

source/dnode/mgmt/test/sut/src/server.cpp

@@ -16,63 +16,23 @@
 #include "sut.h"
 
 void* serverLoop(void* param) {
-  SDnode* pDnode = (SDnode*)param;
+  dmInit(0);
-  dmRun(pDnode);
+  dmRun();
+  dmCleanup();
   return NULL;
 }
 
-SDnodeOpt TestServer::BuildOption(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+bool TestServer::Start() {
-  SDnodeOpt option = {0};
-  option.numOfSupportVnodes = 16;
-  option.serverPort = port;
-  strcpy(option.dataDir, path);
-  snprintf(option.localEp, TSDB_EP_LEN, "%s:%u", fqdn, port);
-  snprintf(option.localFqdn, TSDB_FQDN_LEN, "%s", fqdn);
-  snprintf(option.firstEp, TSDB_EP_LEN, "%s", firstEp);
-  return option;
-}
-
-bool TestServer::DoStart() {
-  SDnodeOpt option = BuildOption(path, fqdn, port, firstEp);
-  taosMkDir(path);
-
-  pDnode = dmCreate(&option);
-  if (pDnode == NULL) {
-    return false;
-  }
-
   TdThreadAttr thAttr;
   taosThreadAttrInit(&thAttr);
   taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
-  taosThreadCreate(&threadId, &thAttr, serverLoop, pDnode);
+  taosThreadCreate(&threadId, &thAttr, serverLoop, NULL);
   taosThreadAttrDestroy(&thAttr);
   taosMsleep(2100);
   return true;
 }
 
-void TestServer::Restart() {
-  uInfo("start all server");
-  Stop();
-  DoStart();
-  uInfo("all server is running");
-}
-
-bool TestServer::Start(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-  strcpy(this->path, path);
-  strcpy(this->fqdn, fqdn);
-  this->port = port;
-  strcpy(this->firstEp, firstEp);
-
-  taosRemoveDir(path);
-  return DoStart();
-}
-
 void TestServer::Stop() {
-  dmSetEvent(pDnode, DND_EVENT_STOP);
+  dmStop();
   taosThreadJoin(threadId, NULL);
-
-  if (pDnode != NULL) {
-    dmClose(pDnode);
-    pDnode = NULL;
-  }
 }

source/dnode/mgmt/test/sut/src/sut.cpp

@@ -30,6 +30,7 @@ void Testbase::InitLog(const char* path) {
   tsdbDebugFlag = 0;
   tsLogEmbedded = 1;
   tsAsyncLog = 0;
+  tsRpcQueueMemoryAllowed = 1024 * 1024 * 64;
 
   taosRemoveDir(path);
   taosMkDir(path);
@@ -40,15 +41,17 @@ void Testbase::InitLog(const char* path) {
 }
 
 void Testbase::Init(const char* path, int16_t port) {
-  dmInit();
+  tsServerPort = port;
-
+  strcpy(tsLocalFqdn, "localhost");
-  char fqdn[] = "localhost";
+  snprintf(tsLocalEp, TSDB_EP_LEN, "%s:%u", tsLocalFqdn, tsServerPort);
-  char firstEp[TSDB_EP_LEN] = {0};
+  strcpy(tsFirst, tsLocalEp);
-  snprintf(firstEp, TSDB_EP_LEN, "%s:%u", fqdn, port);
+  strcpy(tsDataDir, path);
-
+  taosRemoveDir(path);
+  taosMkDir(path);
   InitLog("/tmp/td");
-  server.Start(path, fqdn, port, firstEp);
+
-  client.Init("root", "taosdata", fqdn, port);
+  server.Start();
+  client.Init("root", "taosdata");
   showRsp = NULL;
 }
 
@@ -64,13 +67,12 @@ void Testbase::Cleanup() {
 }
 
 void Testbase::Restart() {
-  server.Restart();
+  // server.Restart();
   client.Restart();
 }
 
 void Testbase::ServerStop() { server.Stop(); }
-
+void Testbase::ServerStart() { server.Start(); }
-void Testbase::ServerStart() { server.DoStart(); }
 void Testbase::ClientRestart() { client.Restart(); }
 
 SRpcMsg* Testbase::SendReq(tmsg_t msgType, void* pCont, int32_t contLen) {

source/dnode/mgmt/test/vnode/vnode.cpp

@@ -13,7 +13,7 @@
 
 class DndTestVnode : public ::testing::Test {
  protected:
-  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_vnode", 9115); }
+  static void SetUpTestSuite() { test.Init("/tmp/dvnodeTest", 9115); }
   static void TearDownTestSuite() { test.Cleanup(); }
 
   static Testbase test;

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

@@ -150,9 +150,7 @@ typedef struct {
   ETrnType       type;
   int32_t        code;
   int32_t        failedTimes;
-  void*      rpcHandle;
+  SRpcHandleInfo rpcInfo;
-  void*      rpcAHandle;
-  int64_t    rpcRefId;
   void*          rpcRsp;
   int32_t        rpcRspLen;
   SArray*        redoLogs;
@@ -459,6 +457,7 @@ typedef struct {
   char*          ast;
   char*          physicalPlan;
   SSchemaWrapper schema;
+  int32_t        refConsumerCnt;
 } SMqTopicObj;
 
 typedef struct {

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

@@ -42,10 +42,10 @@ extern "C" {
 #define SYSTABLE_SCH_DB_NAME_LEN    ((TSDB_DB_NAME_LEN - 1) + VARSTR_HEADER_SIZE)
 #define SYSTABLE_SCH_COL_NAME_LEN   ((TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE)
 
-typedef int32_t (*MndMsgFp)(SNodeMsg *pMsg);
+typedef int32_t (*MndMsgFp)(SRpcMsg *pMsg);
 typedef int32_t (*MndInitFp)(SMnode *pMnode);
 typedef void (*MndCleanupFp)(SMnode *pMnode);
-typedef int32_t (*ShowRetrieveFp)(SNodeMsg *pMsg, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+typedef int32_t (*ShowRetrieveFp)(SRpcMsg *pMsg, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 typedef void (*ShowFreeIterFp)(SMnode *pMnode, void *pIter);
 typedef struct SQWorker SQHandle;
 

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

@@ -38,6 +38,9 @@ static FORCE_INLINE int32_t mndMakePartitionKey(char *key, const char *cgroup, c
 }
 
 int32_t mndDropOffsetByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
+int32_t mndDropOffsetByTopic(SMnode *pMnode, STrans *pTrans, const char *topic);
+
+bool mndOffsetFromTopic(SMqOffsetObj *pOffset, const char *topic);
 
 #ifdef __cplusplus
 }

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

@@ -32,6 +32,7 @@ void             mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub);
 int32_t mndMakeSubscribeKey(char *key, const char *cgroup, const char *topicName);
 
 int32_t mndDropSubByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
+int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topic);
 
 #ifdef __cplusplus
 }

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

@@ -35,6 +35,8 @@ int32_t mndDropTopicByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
 
 const char *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]);
 
+int32_t mndSetTopicRedoLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -59,7 +59,7 @@ void    mndTransSetCb(STrans *pTrans, ETrnFuncType startFunc, ETrnFuncType stopF
 void    mndTransSetDbInfo(STrans *pTrans, SDbObj *pDb);
 
 int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);
-void    mndTransProcessRsp(SNodeMsg *pRsp);
+void    mndTransProcessRsp(SRpcMsg *pRsp);
 void    mndTransPullup(SMnode *pMnode);
 int32_t mndKillTrans(SMnode *pMnode, STrans *pTrans);
 

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

@@ -26,9 +26,9 @@ static SSdbRow *mndAcctActionDecode(SSdbRaw *pRaw);
 static int32_t  mndAcctActionInsert(SSdb *pSdb, SAcctObj *pAcct);
 static int32_t  mndAcctActionDelete(SSdb *pSdb, SAcctObj *pAcct);
 static int32_t  mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOld, SAcctObj *pNew);
-static int32_t  mndProcessCreateAcctReq(SNodeMsg *pReq);
+static int32_t  mndProcessCreateAcctReq(SRpcMsg *pReq);
-static int32_t  mndProcessAlterAcctReq(SNodeMsg *pReq);
+static int32_t  mndProcessAlterAcctReq(SRpcMsg *pReq);
-static int32_t  mndProcessDropAcctReq(SNodeMsg *pReq);
+static int32_t  mndProcessDropAcctReq(SRpcMsg *pReq);
 
 int32_t mndInitAcct(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_ACCT,
@@ -185,19 +185,19 @@ static int32_t mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOld, SAcctObj *pNew) {
   return 0;
 }
 
-static int32_t mndProcessCreateAcctReq(SNodeMsg *pReq) {
+static int32_t mndProcessCreateAcctReq(SRpcMsg *pReq) {
   terrno = TSDB_CODE_MSG_NOT_PROCESSED;
   mError("failed to process create acct request since %s", terrstr());
   return -1;
 }
 
-static int32_t mndProcessAlterAcctReq(SNodeMsg *pReq) {
+static int32_t mndProcessAlterAcctReq(SRpcMsg *pReq) {
   terrno = TSDB_CODE_MSG_NOT_PROCESSED;
   mError("failed to process create acct request since %s", terrstr());
   return -1;
 }
 
-static int32_t mndProcessDropAcctReq(SNodeMsg *pReq) {
+static int32_t mndProcessDropAcctReq(SRpcMsg *pReq) {
   terrno = TSDB_CODE_MSG_NOT_PROCESSED;
   mError("failed to process create acct request since %s", terrstr());
   return -1;

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

@@ -17,7 +17,7 @@
 #include "mndAuth.h"
 #include "mndUser.h"
 
-static int32_t mndProcessAuthReq(SNodeMsg *pReq);
+static int32_t mndProcessAuthReq(SRpcMsg *pReq);
 
 int32_t mndInitAuth(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_MND_AUTH, mndProcessAuthReq);
@@ -45,9 +45,9 @@ static int32_t mndRetriveAuth(SMnode *pMnode, SAuthRsp *pRsp) {
   return 0;
 }
 
-static int32_t mndProcessAuthReq(SNodeMsg *pReq) {
+static int32_t mndProcessAuthReq(SRpcMsg *pReq) {
   SAuthReq authReq = {0};
-  if (tDeserializeSAuthReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &authReq) != 0) {
+  if (tDeserializeSAuthReq(pReq->pCont, pReq->contLen, &authReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
@@ -55,8 +55,8 @@ static int32_t mndProcessAuthReq(SNodeMsg *pReq) {
   SAuthReq authRsp = {0};
   memcpy(authRsp.user, authReq.user, TSDB_USER_LEN);
 
-  int32_t code = mndRetriveAuth(pReq->pNode, &authRsp);
+  int32_t code = mndRetriveAuth(pReq->info.node, &authRsp);
-  mTrace("user:%s, auth req received, spi:%d encrypt:%d ruser:%s", pReq->user, authRsp.spi, authRsp.encrypt,
+  mTrace("user:%s, auth req received, spi:%d encrypt:%d ruser:%s", pReq->conn.user, authRsp.spi, authRsp.encrypt,
          authRsp.user);
 
   int32_t contLen = tSerializeSAuthReq(NULL, 0, &authRsp);
@@ -68,8 +68,8 @@ static int32_t mndProcessAuthReq(SNodeMsg *pReq) {
 
   tSerializeSAuthReq(pRsp, contLen, &authRsp);
 
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = contLen;
+  pReq->info.rspLen = contLen;
   return code;
 }
 

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

@@ -29,11 +29,11 @@ static SSdbRow *mndBnodeActionDecode(SSdbRaw *pRaw);
 static int32_t  mndBnodeActionInsert(SSdb *pSdb, SBnodeObj *pObj);
 static int32_t  mndBnodeActionUpdate(SSdb *pSdb, SBnodeObj *pOld, SBnodeObj *pNew);
 static int32_t  mndBnodeActionDelete(SSdb *pSdb, SBnodeObj *pObj);
-static int32_t  mndProcessCreateBnodeReq(SNodeMsg *pReq);
+static int32_t  mndProcessCreateBnodeReq(SRpcMsg *pReq);
-static int32_t  mndProcessCreateBnodeRsp(SNodeMsg *pRsp);
+static int32_t  mndProcessCreateBnodeRsp(SRpcMsg *pRsp);
-static int32_t  mndProcessDropBnodeReq(SNodeMsg *pReq);
+static int32_t  mndProcessDropBnodeReq(SRpcMsg *pReq);
-static int32_t  mndProcessDropBnodeRsp(SNodeMsg *pRsp);
+static int32_t  mndProcessDropBnodeRsp(SRpcMsg *pRsp);
-static int32_t  mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+static int32_t  mndRetrieveBnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextBnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitBnode(SMnode *pMnode) {
@@ -238,7 +238,7 @@ static int32_t mndSetCreateBnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S
   return 0;
 }
 
-static int32_t mndCreateBnode(SMnode *pMnode, SNodeMsg *pReq, SDnodeObj *pDnode, SMCreateBnodeReq *pCreate) {
+static int32_t mndCreateBnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SMCreateBnodeReq *pCreate) {
   int32_t code = -1;
 
   SBnodeObj bnodeObj = {0};
@@ -246,7 +246,7 @@ static int32_t mndCreateBnode(SMnode *pMnode, SNodeMsg *pReq, SDnodeObj *pDnode,
   bnodeObj.createdTime = taosGetTimestampMs();
   bnodeObj.updateTime = bnodeObj.createdTime;
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_BNODE, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_BNODE, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create bnode:%d", pTrans->id, pCreate->dnodeId);
@@ -264,15 +264,15 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessCreateBnodeReq(SNodeMsg *pReq) {
+static int32_t mndProcessCreateBnodeReq(SRpcMsg *pReq) {
-  SMnode          *pMnode = pReq->pNode;
+  SMnode          *pMnode = pReq->info.node;
   int32_t          code = -1;
   SBnodeObj       *pObj = NULL;
   SDnodeObj       *pDnode = NULL;
   SUserObj        *pUser = NULL;
   SMCreateBnodeReq createReq = {0};
 
-  if (tDeserializeSCreateDropMQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+  if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -293,7 +293,7 @@ static int32_t mndProcessCreateBnodeReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto _OVER;
@@ -360,10 +360,10 @@ static int32_t mndSetDropBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SBn
   return 0;
 }
 
-static int32_t mndDropBnode(SMnode *pMnode, SNodeMsg *pReq, SBnodeObj *pObj) {
+static int32_t mndDropBnode(SMnode *pMnode, SRpcMsg *pReq, SBnodeObj *pObj) {
   int32_t code = -1;
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_DROP_BNODE, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_DROP_BNODE, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop bnode:%d", pTrans->id, pObj->id);
@@ -379,14 +379,14 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessDropBnodeReq(SNodeMsg *pReq) {
+static int32_t mndProcessDropBnodeReq(SRpcMsg *pReq) {
-  SMnode        *pMnode = pReq->pNode;
+  SMnode        *pMnode = pReq->info.node;
   int32_t        code = -1;
   SUserObj      *pUser = NULL;
   SBnodeObj     *pObj = NULL;
   SMDropBnodeReq dropReq = {0};
 
-  if (tDeserializeSCreateDropMQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+  if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -403,7 +403,7 @@ static int32_t mndProcessDropBnodeReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto _OVER;
@@ -427,18 +427,18 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessCreateBnodeRsp(SNodeMsg *pRsp) {
+static int32_t mndProcessCreateBnodeRsp(SRpcMsg *pRsp) {
   mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessDropBnodeRsp(SNodeMsg *pRsp) {
+static int32_t mndProcessDropBnodeRsp(SRpcMsg *pRsp) {
   mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+static int32_t mndRetrieveBnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SMnode    *pMnode = pReq->pNode;
+  SMnode    *pMnode = pReq->info.node;
   SSdb      *pSdb = pMnode->pSdb;
   int32_t    numOfRows = 0;
   int32_t    cols = 0;

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

@@ -26,7 +26,7 @@ static int32_t  mndClusterActionInsert(SSdb *pSdb, SClusterObj *pCluster);
 static int32_t  mndClusterActionDelete(SSdb *pSdb, SClusterObj *pCluster);
 static int32_t  mndClusterActionUpdate(SSdb *pSdb, SClusterObj *pOldCluster, SClusterObj *pNewCluster);
 static int32_t  mndCreateDefaultCluster(SMnode *pMnode);
-static int32_t  mndRetrieveClusters(SNodeMsg *pMsg, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+static int32_t  mndRetrieveClusters(SRpcMsg *pMsg, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextCluster(SMnode *pMnode, void *pIter);
 
 int32_t mndInitCluster(SMnode *pMnode) {
@@ -180,8 +180,8 @@ static int32_t mndCreateDefaultCluster(SMnode *pMnode) {
   return sdbWrite(pMnode->pSdb, pRaw);
 }
 
-static int32_t mndRetrieveClusters(SNodeMsg *pMsg, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+static int32_t mndRetrieveClusters(SRpcMsg *pMsg, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SMnode      *pMnode = pMsg->pNode;
+  SMnode      *pMnode = pMsg->info.node;
   SSdb        *pSdb = pMnode->pSdb;
   int32_t      numOfRows = 0;
   int32_t      cols = 0;

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

@@ -42,15 +42,15 @@ static const char *mndConsumerStatusName(int status);
 static int32_t mndConsumerActionInsert(SSdb *pSdb, SMqConsumerObj *pConsumer);
 static int32_t mndConsumerActionDelete(SSdb *pSdb, SMqConsumerObj *pConsumer);
 static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pConsumer, SMqConsumerObj *pNewConsumer);
-static int32_t mndProcessConsumerMetaMsg(SNodeMsg *pMsg);
+static int32_t mndProcessConsumerMetaMsg(SRpcMsg *pMsg);
-static int32_t mndRetrieveConsumer(SNodeMsg *pMsg, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+static int32_t mndRetrieveConsumer(SRpcMsg *pMsg, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void    mndCancelGetNextConsumer(SMnode *pMnode, void *pIter);
 
-static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg);
+static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg);
-static int32_t mndProcessAskEpReq(SNodeMsg *pMsg);
+static int32_t mndProcessAskEpReq(SRpcMsg *pMsg);
-static int32_t mndProcessMqTimerMsg(SNodeMsg *pMsg);
+static int32_t mndProcessMqTimerMsg(SRpcMsg *pMsg);
-static int32_t mndProcessConsumerLostMsg(SNodeMsg *pMsg);
+static int32_t mndProcessConsumerLostMsg(SRpcMsg *pMsg);
-static int32_t mndProcessConsumerRecoverMsg(SNodeMsg *pMsg);
+static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg);
 
 int32_t mndInitConsumer(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_CONSUMER,
@@ -86,9 +86,9 @@ void mndRebCntInc() { atomic_add_fetch_8(&mqRebLock, 1); }
 
 void mndRebCntDec() { atomic_sub_fetch_8(&mqRebLock, 1); }
 
-static int32_t mndProcessConsumerLostMsg(SNodeMsg *pMsg) {
+static int32_t mndProcessConsumerLostMsg(SRpcMsg *pMsg) {
-  SMnode             *pMnode = pMsg->pNode;
+  SMnode             *pMnode = pMsg->info.node;
-  SMqConsumerLostMsg *pLostMsg = pMsg->rpcMsg.pCont;
+  SMqConsumerLostMsg *pLostMsg = pMsg->pCont;
   SMqConsumerObj     *pConsumer = mndAcquireConsumer(pMnode, pLostMsg->consumerId);
   ASSERT(pConsumer);
 
@@ -97,7 +97,7 @@ static int32_t mndProcessConsumerLostMsg(SNodeMsg *pMsg) {
 
   mndReleaseConsumer(pMnode, pConsumer);
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_CONSUMER_LOST, &pMsg->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_CONSUMER_LOST, pMsg);
   if (pTrans == NULL) goto FAIL;
   if (mndSetConsumerCommitLogs(pMnode, pTrans, pConsumerNew) != 0) goto FAIL;
   if (mndTransPrepare(pMnode, pTrans) != 0) goto FAIL;
@@ -110,9 +110,9 @@ FAIL:
   return -1;
 }
 
-static int32_t mndProcessConsumerRecoverMsg(SNodeMsg *pMsg) {
+static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg) {
-  SMnode                *pMnode = pMsg->pNode;
+  SMnode                *pMnode = pMsg->info.node;
-  SMqConsumerRecoverMsg *pRecoverMsg = pMsg->rpcMsg.pCont;
+  SMqConsumerRecoverMsg *pRecoverMsg = pMsg->pCont;
   SMqConsumerObj        *pConsumer = mndAcquireConsumer(pMnode, pRecoverMsg->consumerId);
   ASSERT(pConsumer);
 
@@ -121,7 +121,7 @@ static int32_t mndProcessConsumerRecoverMsg(SNodeMsg *pMsg) {
 
   mndReleaseConsumer(pMnode, pConsumer);
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_CONSUMER_RECOVER, &pMsg->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_CONSUMER_RECOVER, pMsg);
   if (pTrans == NULL) goto FAIL;
   if (mndSetConsumerCommitLogs(pMnode, pTrans, pConsumerNew) != 0) goto FAIL;
   if (mndTransPrepare(pMnode, pTrans) != 0) goto FAIL;
@@ -135,20 +135,22 @@ FAIL:
 }
 
 static SMqRebInfo *mndGetOrCreateRebSub(SHashObj *pHash, const char *key) {
-  SMqRebInfo *pRebSub = taosHashGet(pHash, key, strlen(key) + 1);
+  SMqRebInfo *pRebInfo = taosHashGet(pHash, key, strlen(key) + 1);
-  if (pRebSub == NULL) {
+  if (pRebInfo == NULL) {
-    pRebSub = tNewSMqRebSubscribe(key);
+    pRebInfo = tNewSMqRebSubscribe(key);
-    if (pRebSub == NULL) {
+    if (pRebInfo == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return NULL;
     }
-    taosHashPut(pHash, key, strlen(key) + 1, pRebSub, sizeof(SMqRebInfo));
+    taosHashPut(pHash, key, strlen(key) + 1, pRebInfo, sizeof(SMqRebInfo));
+    taosMemoryFree(pRebInfo);
+    pRebInfo = taosHashGet(pHash, key, strlen(key) + 1);
   }
-  return pRebSub;
+  return pRebInfo;
 }
 
-static int32_t mndProcessMqTimerMsg(SNodeMsg *pMsg) {
+static int32_t mndProcessMqTimerMsg(SRpcMsg *pMsg) {
-  SMnode         *pMnode = pMsg->pNode;
+  SMnode         *pMnode = pMsg->info.node;
   SSdb           *pSdb = pMnode->pSdb;
   SMqConsumerObj *pConsumer;
   void           *pIter = NULL;
@@ -237,14 +239,14 @@ static int32_t mndProcessMqTimerMsg(SNodeMsg *pMsg) {
   return 0;
 }
 
-static int32_t mndProcessAskEpReq(SNodeMsg *pMsg) {
+static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
-  SMnode      *pMnode = pMsg->pNode;
+  SMnode      *pMnode = pMsg->info.node;
-  SMqAskEpReq *pReq = (SMqAskEpReq *)pMsg->rpcMsg.pCont;
+  SMqAskEpReq *pReq = (SMqAskEpReq *)pMsg->pCont;
   SMqAskEpRsp  rsp = {0};
   int64_t      consumerId = be64toh(pReq->consumerId);
   int32_t      epoch = ntohl(pReq->epoch);
 
-  SMqConsumerObj *pConsumer = mndAcquireConsumer(pMsg->pNode, consumerId);
+  SMqConsumerObj *pConsumer = mndAcquireConsumer(pMsg->info.node, consumerId);
   if (pConsumer == NULL) {
     terrno = TSDB_CODE_MND_CONSUMER_NOT_EXIST;
     return -1;
@@ -305,8 +307,10 @@ static int32_t mndProcessAskEpReq(SNodeMsg *pMsg) {
       ASSERT(pTopic);
       taosRLockLatch(&pTopic->lock);
       topicEp.schema.nCols = pTopic->schema.nCols;
+      if (topicEp.schema.nCols) {
         topicEp.schema.pSchema = taosMemoryCalloc(topicEp.schema.nCols, sizeof(SSchema));
         memcpy(topicEp.schema.pSchema, pTopic->schema.pSchema, topicEp.schema.nCols * sizeof(SSchema));
+      }
       taosRUnLockLatch(&pTopic->lock);
       mndReleaseTopic(pMnode, pTopic);
 
@@ -366,8 +370,8 @@ static int32_t mndProcessAskEpReq(SNodeMsg *pMsg) {
   mndReleaseConsumer(pMnode, pConsumer);
 
   // send rsp
-  pMsg->pRsp = buf;
+  pMsg->info.rsp = buf;
-  pMsg->rspLen = tlen;
+  pMsg->info.rspLen = tlen;
   return 0;
 FAIL:
   tDeleteSMqAskEpRsp(&rsp);
@@ -383,9 +387,9 @@ int32_t mndSetConsumerCommitLogs(SMnode *pMnode, STrans *pTrans, SMqConsumerObj
   return 0;
 }
 
-static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg) {
+static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
-  SMnode         *pMnode = pMsg->pNode;
+  SMnode         *pMnode = pMsg->info.node;
-  char           *msgStr = pMsg->rpcMsg.pCont;
+  char           *msgStr = pMsg->pCont;
   SCMSubscribeReq subscribe = {0};
   tDeserializeSCMSubscribeReq(msgStr, &subscribe);
   int64_t         consumerId = subscribe.consumerId;
@@ -399,6 +403,9 @@ static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg) {
 
   int32_t newTopicNum = taosArrayGetSize(newSub);
   // check topic existance
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_SUBSCRIBE, pMsg);
+  if (pTrans == NULL) goto SUBSCRIBE_OVER;
+
   for (int32_t i = 0; i < newTopicNum; i++) {
     char        *topic = taosArrayGetP(newSub, i);
     SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic);
@@ -406,7 +413,14 @@ static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg) {
       terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST;
       goto SUBSCRIBE_OVER;
     }
-    // TODO lock topic to prevent drop
+
+    // ref topic to prevent drop
+    // TODO make topic complete
+    SMqTopicObj topicObj = {0};
+    memcpy(&topicObj, pTopic, sizeof(SMqTopicObj));
+    topicObj.refConsumerCnt = pTopic->refConsumerCnt + 1;
+    if (mndSetTopicRedoLogs(pMnode, pTrans, &topicObj) != 0) goto SUBSCRIBE_OVER;
+
     mndReleaseTopic(pMnode, pTopic);
   }
 
@@ -422,8 +436,6 @@ static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg) {
       taosArrayPush(pConsumerNew->assignedTopics, &newTopicCopy);
     }
 
-    STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_SUBSCRIBE, &pMsg->rpcMsg);
-    if (pTrans == NULL) goto SUBSCRIBE_OVER;
     if (mndSetConsumerCommitLogs(pMnode, pTrans, pConsumerNew) != 0) goto SUBSCRIBE_OVER;
     if (mndTransPrepare(pMnode, pTrans) != 0) goto SUBSCRIBE_OVER;
 
@@ -494,8 +506,6 @@ static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg) {
       goto SUBSCRIBE_OVER;
     }
 
-    STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_SUBSCRIBE, &pMsg->rpcMsg);
-    if (pTrans == NULL) goto SUBSCRIBE_OVER;
     if (mndSetConsumerCommitLogs(pMnode, pTrans, pConsumerNew) != 0) goto SUBSCRIBE_OVER;
     if (mndTransPrepare(pMnode, pTrans) != 0) goto SUBSCRIBE_OVER;
   }
@@ -503,12 +513,15 @@ static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg) {
   code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
 SUBSCRIBE_OVER:
+  mndTransDrop(pTrans);
+
   if (pConsumerOld) {
     /*taosRUnLockLatch(&pConsumerOld->lock);*/
     mndReleaseConsumer(pMnode, pConsumerOld);
   }
   if (pConsumerNew) {
     tDeleteSMqConsumerObj(pConsumerNew);
+    taosMemoryFree(pConsumerNew);
   }
   // TODO: replace with destroy subscribe msg
   if (subscribe.topicNames) taosArrayDestroyP(subscribe.topicNames, (FDelete)taosMemoryFree);
@@ -788,8 +801,8 @@ void mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer) {
   sdbRelease(pSdb, pConsumer);
 }
 
-static int32_t mndRetrieveConsumer(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
+static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
-  SMnode         *pMnode = pReq->pNode;
+  SMnode         *pMnode = pReq->info.node;
   SSdb           *pSdb = pMnode->pSdb;
   int32_t         numOfRows = 0;
   SMqConsumerObj *pConsumer = NULL;

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

@@ -36,14 +36,14 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw);
 static int32_t  mndDbActionInsert(SSdb *pSdb, SDbObj *pDb);
 static int32_t  mndDbActionDelete(SSdb *pSdb, SDbObj *pDb);
 static int32_t  mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew);
-static int32_t  mndProcessCreateDbReq(SNodeMsg *pReq);
+static int32_t  mndProcessCreateDbReq(SRpcMsg *pReq);
-static int32_t  mndProcessAlterDbReq(SNodeMsg *pReq);
+static int32_t  mndProcessAlterDbReq(SRpcMsg *pReq);
-static int32_t  mndProcessDropDbReq(SNodeMsg *pReq);
+static int32_t  mndProcessDropDbReq(SRpcMsg *pReq);
-static int32_t  mndProcessUseDbReq(SNodeMsg *pReq);
+static int32_t  mndProcessUseDbReq(SRpcMsg *pReq);
-static int32_t  mndProcessCompactDbReq(SNodeMsg *pReq);
+static int32_t  mndProcessCompactDbReq(SRpcMsg *pReq);
-static int32_t  mndRetrieveDbs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity);
+static int32_t  mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity);
 static void     mndCancelGetNextDb(SMnode *pMnode, void *pIter);
-static int32_t  mndProcessGetDbCfgReq(SNodeMsg *pReq);
+static int32_t  mndProcessGetDbCfgReq(SRpcMsg *pReq);
 
 int32_t mndInitDb(SMnode *pMnode) {
   SSdbTable table = {
@@ -508,7 +508,7 @@ static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
   return 0;
 }
 
-static int32_t mndCreateDb(SMnode *pMnode, SNodeMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser) {
+static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser) {
   SDbObj dbObj = {0};
   memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);
   memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);
@@ -563,7 +563,7 @@ static int32_t mndCreateDb(SMnode *pMnode, SNodeMsg *pReq, SCreateDbReq *pCreate
   }
 
   int32_t code = -1;
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_DB, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_DB, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create db:%s", pTrans->id, pCreate->db);
@@ -584,14 +584,14 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessCreateDbReq(SNodeMsg *pReq) {
+static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
-  SMnode      *pMnode = pReq->pNode;
+  SMnode      *pMnode = pReq->info.node;
   int32_t      code = -1;
   SDbObj      *pDb = NULL;
   SUserObj    *pUser = NULL;
   SCreateDbReq createReq = {0};
 
-  if (tDeserializeSCreateDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+  if (tDeserializeSCreateDbReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -612,7 +612,7 @@ static int32_t mndProcessCreateDbReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     goto _OVER;
   }
@@ -794,9 +794,9 @@ static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
   return 0;
 }
 
-static int32_t mndAlterDb(SMnode *pMnode, SNodeMsg *pReq, SDbObj *pOld, SDbObj *pNew) {
+static int32_t mndAlterDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pOld, SDbObj *pNew) {
   int32_t code = -1;
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_ALTER_DB, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_ALTER_DB, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to alter db:%s", pTrans->id, pOld->name);
@@ -814,15 +814,15 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessAlterDbReq(SNodeMsg *pReq) {
+static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
-  SMnode     *pMnode = pReq->pNode;
+  SMnode     *pMnode = pReq->info.node;
   int32_t     code = -1;
   SDbObj     *pDb = NULL;
   SUserObj   *pUser = NULL;
   SAlterDbReq alterReq = {0};
   SDbObj      dbObj = {0};
 
-  if (tDeserializeSAlterDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &alterReq) != 0) {
+  if (tDeserializeSAlterDbReq(pReq->pCont, pReq->contLen, &alterReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -835,7 +835,7 @@ static int32_t mndProcessAlterDbReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     goto _OVER;
   }
@@ -873,14 +873,14 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessGetDbCfgReq(SNodeMsg *pReq) {
+static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
-  SMnode   *pMnode = pReq->pNode;
+  SMnode   *pMnode = pReq->info.node;
   int32_t   code = -1;
   SDbObj   *pDb = NULL;
   SDbCfgReq cfgReq = {0};
   SDbCfgRsp cfgRsp = {0};
 
-  if (tDeserializeSDbCfgReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &cfgReq) != 0) {
+  if (tDeserializeSDbCfgReq(pReq->pCont, pReq->contLen, &cfgReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -922,8 +922,8 @@ static int32_t mndProcessGetDbCfgReq(SNodeMsg *pReq) {
 
   tSerializeSDbCfgRsp(pRsp, contLen, &cfgRsp);
 
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = contLen;
+  pReq->info.rspLen = contLen;
 
   code = 0;
 
@@ -1055,9 +1055,9 @@ static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bo
   return 0;
 }
 
-static int32_t mndDropDb(SMnode *pMnode, SNodeMsg *pReq, SDbObj *pDb) {
+static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {
   int32_t code = -1;
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_DROP_DB, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_DROP_DB, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop db:%s", pTrans->id, pDb->name);
@@ -1095,14 +1095,14 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessDropDbReq(SNodeMsg *pReq) {
+static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {
-  SMnode    *pMnode = pReq->pNode;
+  SMnode    *pMnode = pReq->info.node;
   int32_t    code = -1;
   SDbObj    *pDb = NULL;
   SUserObj  *pUser = NULL;
   SDropDbReq dropReq = {0};
 
-  if (tDeserializeSDropDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+  if (tDeserializeSDropDbReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -1112,7 +1112,7 @@ static int32_t mndProcessDropDbReq(SNodeMsg *pReq) {
   pDb = mndAcquireDb(pMnode, dropReq.db);
   if (pDb == NULL) {
     if (dropReq.ignoreNotExists) {
-      code = mndBuildDropDbRsp(pDb, &pReq->rspLen, &pReq->pRsp, true);
+      code = mndBuildDropDbRsp(pDb, &pReq->info.rspLen, &pReq->info.rsp, true);
       goto _OVER;
     } else {
       terrno = TSDB_CODE_MND_DB_NOT_EXIST;
@@ -1120,7 +1120,7 @@ static int32_t mndProcessDropDbReq(SNodeMsg *pReq) {
     }
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     goto _OVER;
   }
@@ -1231,15 +1231,15 @@ int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUs
   return 0;
 }
 
-static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
+static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
-  SMnode   *pMnode = pReq->pNode;
+  SMnode   *pMnode = pReq->info.node;
   int32_t   code = -1;
   SDbObj   *pDb = NULL;
   SUserObj *pUser = NULL;
   SUseDbReq usedbReq = {0};
   SUseDbRsp usedbRsp = {0};
 
-  if (tDeserializeSUseDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &usedbReq) != 0) {
+  if (tDeserializeSUseDbReq(pReq->pCont, pReq->contLen, &usedbReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -1275,7 +1275,7 @@ static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
 
       mError("db:%s, failed to process use db req since %s", usedbReq.db, terrstr());
     } else {
-      pUser = mndAcquireUser(pMnode, pReq->user);
+      pUser = mndAcquireUser(pMnode, pReq->conn.user);
       if (pUser == NULL) {
         goto _OVER;
       }
@@ -1302,8 +1302,8 @@ static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
 
   tSerializeSUseDbRsp(pRsp, contLen, &usedbRsp);
 
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = contLen;
+  pReq->info.rspLen = contLen;
 
 _OVER:
   if (code != 0) {
@@ -1385,14 +1385,14 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
   return 0;
 }
 
-static int32_t mndProcessCompactDbReq(SNodeMsg *pReq) {
+static int32_t mndProcessCompactDbReq(SRpcMsg *pReq) {
-  SMnode       *pMnode = pReq->pNode;
+  SMnode       *pMnode = pReq->info.node;
   int32_t       code = -1;
   SDbObj       *pDb = NULL;
   SUserObj     *pUser = NULL;
   SCompactDbReq compactReq = {0};
 
-  if (tDeserializeSCompactDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &compactReq) != 0) {
+  if (tDeserializeSCompactDbReq(pReq->pCont, pReq->contLen, &compactReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -1404,7 +1404,7 @@ static int32_t mndProcessCompactDbReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     goto _OVER;
   }
@@ -1587,8 +1587,8 @@ static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, v
   return true;
 }
 
-static int32_t mndRetrieveDbs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
+static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
-  SMnode *pMnode = pReq->pNode;
+  SMnode *pMnode = pReq->info.node;
   SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfRows = 0;
   SDbObj *pDb = NULL;

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

@@ -46,15 +46,15 @@ static int32_t  mndDnodeActionInsert(SSdb *pSdb, SDnodeObj *pDnode);
 static int32_t  mndDnodeActionDelete(SSdb *pSdb, SDnodeObj *pDnode);
 static int32_t  mndDnodeActionUpdate(SSdb *pSdb, SDnodeObj *pOld, SDnodeObj *pNew);
 
-static int32_t mndProcessCreateDnodeReq(SNodeMsg *pReq);
+static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq);
-static int32_t mndProcessDropDnodeReq(SNodeMsg *pReq);
+static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq);
-static int32_t mndProcessConfigDnodeReq(SNodeMsg *pReq);
+static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq);
-static int32_t mndProcessConfigDnodeRsp(SNodeMsg *pRsp);
+static int32_t mndProcessConfigDnodeRsp(SRpcMsg *pRsp);
-static int32_t mndProcessStatusReq(SNodeMsg *pReq);
+static int32_t mndProcessStatusReq(SRpcMsg *pReq);
 
-static int32_t mndRetrieveConfigs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void    mndCancelGetNextConfig(SMnode *pMnode, void *pIter);
-static int32_t mndRetrieveDnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void    mndCancelGetNextDnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitDnode(SMnode *pMnode) {
@@ -289,13 +289,13 @@ static int32_t mndCheckClusterCfgPara(SMnode *pMnode, const SClusterCfg *pCfg) {
   return 0;
 }
 
-static int32_t mndProcessStatusReq(SNodeMsg *pReq) {
+static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
-  SMnode    *pMnode = pReq->pNode;
+  SMnode    *pMnode = pReq->info.node;
   SStatusReq statusReq = {0};
   SDnodeObj *pDnode = NULL;
   int32_t    code = -1;
 
-  if (tDeserializeSStatusReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &statusReq) != 0) {
+  if (tDeserializeSStatusReq(pReq->pCont, pReq->contLen, &statusReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto PROCESS_STATUS_MSG_OVER;
   }
@@ -419,8 +419,8 @@ static int32_t mndProcessStatusReq(SNodeMsg *pReq) {
     tSerializeSStatusRsp(pHead, contLen, &statusRsp);
     taosArrayDestroy(statusRsp.pDnodeEps);
 
-    pReq->rspLen = contLen;
+    pReq->info.rspLen = contLen;
-    pReq->pRsp = pHead;
+    pReq->info.rsp = pHead;
   }
 
   pDnode->lastAccessTime = curMs;
@@ -432,7 +432,7 @@ PROCESS_STATUS_MSG_OVER:
   return code;
 }
 
-static int32_t mndCreateDnode(SMnode *pMnode, SNodeMsg *pReq, SCreateDnodeReq *pCreate) {
+static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pCreate) {
   SDnodeObj dnodeObj = {0};
   dnodeObj.id = sdbGetMaxId(pMnode->pSdb, SDB_DNODE);
   dnodeObj.createdTime = taosGetTimestampMs();
@@ -441,7 +441,7 @@ static int32_t mndCreateDnode(SMnode *pMnode, SNodeMsg *pReq, SCreateDnodeReq *p
   memcpy(dnodeObj.fqdn, pCreate->fqdn, TSDB_FQDN_LEN);
   snprintf(dnodeObj.ep, TSDB_EP_LEN, "%s:%u", dnodeObj.fqdn, dnodeObj.port);
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_DNODE, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_DNODE, pReq);
   if (pTrans == NULL) {
     mError("dnode:%s, failed to create since %s", dnodeObj.ep, terrstr());
     return -1;
@@ -466,14 +466,14 @@ static int32_t mndCreateDnode(SMnode *pMnode, SNodeMsg *pReq, SCreateDnodeReq *p
   return 0;
 }
 
-static int32_t mndProcessCreateDnodeReq(SNodeMsg *pReq) {
+static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
-  SMnode         *pMnode = pReq->pNode;
+  SMnode         *pMnode = pReq->info.node;
   int32_t         code = -1;
   SUserObj       *pUser = NULL;
   SDnodeObj      *pDnode = NULL;
   SCreateDnodeReq createReq = {0};
 
-  if (tDeserializeSCreateDnodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+  if (tDeserializeSCreateDnodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto CREATE_DNODE_OVER;
   }
@@ -493,7 +493,7 @@ static int32_t mndProcessCreateDnodeReq(SNodeMsg *pReq) {
     goto CREATE_DNODE_OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto CREATE_DNODE_OVER;
@@ -516,8 +516,8 @@ CREATE_DNODE_OVER:
   return code;
 }
 
-static int32_t mndDropDnode(SMnode *pMnode, SNodeMsg *pReq, SDnodeObj *pDnode) {
+static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode) {
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_DNODE, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_DNODE, pReq);
   if (pTrans == NULL) {
     mError("dnode:%d, failed to drop since %s", pDnode->id, terrstr());
     return -1;
@@ -542,15 +542,15 @@ static int32_t mndDropDnode(SMnode *pMnode, SNodeMsg *pReq, SDnodeObj *pDnode) {
   return 0;
 }
 
-static int32_t mndProcessDropDnodeReq(SNodeMsg *pReq) {
+static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
-  SMnode        *pMnode = pReq->pNode;
+  SMnode        *pMnode = pReq->info.node;
   int32_t        code = -1;
   SUserObj      *pUser = NULL;
   SDnodeObj     *pDnode = NULL;
   SMnodeObj     *pMObj = NULL;
   SMDropMnodeReq dropReq = {0};
 
-  if (tDeserializeSCreateDropMQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+  if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto DROP_DNODE_OVER;
   }
@@ -574,7 +574,7 @@ static int32_t mndProcessDropDnodeReq(SNodeMsg *pReq) {
     goto DROP_DNODE_OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto DROP_DNODE_OVER;
@@ -599,11 +599,11 @@ DROP_DNODE_OVER:
   return code;
 }
 
-static int32_t mndProcessConfigDnodeReq(SNodeMsg *pReq) {
+static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
-  SMnode *pMnode = pReq->pNode;
+  SMnode *pMnode = pReq->info.node;
 
   SMCfgDnodeReq cfgReq = {0};
-  if (tDeserializeSMCfgDnodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &cfgReq) != 0) {
+  if (tDeserializeSMCfgDnodeReq(pReq->pCont, pReq->contLen, &cfgReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
@@ -622,22 +622,21 @@ static int32_t mndProcessConfigDnodeReq(SNodeMsg *pReq) {
   void   *pBuf = rpcMallocCont(bufLen);
   tSerializeSMCfgDnodeReq(pBuf, bufLen, &cfgReq);
 
-  SRpcMsg rpcMsg = {
+  SRpcMsg rpcMsg = {.msgType = TDMT_DND_CONFIG_DNODE, .pCont = pBuf, .contLen = bufLen, .info = pReq->info};
-      .msgType = TDMT_DND_CONFIG_DNODE, .pCont = pBuf, .contLen = bufLen, .ahandle = pReq->rpcMsg.ahandle};
 
-  mInfo("dnode:%d, app:%p config:%s req send to dnode", cfgReq.dnodeId, rpcMsg.ahandle, cfgReq.config);
+  mInfo("dnode:%d, app:%p config:%s req send to dnode", cfgReq.dnodeId, rpcMsg.info.ahandle, cfgReq.config);
-  tmsgSendReq(&pMnode->msgCb, &epSet, &rpcMsg);
+  tmsgSendReq(&epSet, &rpcMsg);
 
   return 0;
 }
 
-static int32_t mndProcessConfigDnodeRsp(SNodeMsg *pRsp) {
+static int32_t mndProcessConfigDnodeRsp(SRpcMsg *pRsp) {
-  mInfo("app:%p config rsp from dnode", pRsp->rpcMsg.ahandle);
+  mInfo("app:%p config rsp from dnode", pRsp->info.ahandle);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mndRetrieveConfigs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SMnode *pMnode = pReq->pNode;
+  SMnode *pMnode = pReq->info.node;
   int32_t totalRows = 0;
   int32_t numOfRows = 0;
   char   *cfgOpts[TSDB_CONFIG_NUMBER] = {0};
@@ -685,8 +684,8 @@ static int32_t mndRetrieveConfigs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *
 
 static void mndCancelGetNextConfig(SMnode *pMnode, void *pIter) {}
 
-static int32_t mndRetrieveDnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SMnode    *pMnode = pReq->pNode;
+  SMnode    *pMnode = pReq->info.node;
   SSdb      *pSdb = pMnode->pSdb;
   int32_t    numOfRows = 0;
   int32_t    cols = 0;

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

@@ -29,12 +29,12 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw);
 static int32_t  mndFuncActionInsert(SSdb *pSdb, SFuncObj *pFunc);
 static int32_t  mndFuncActionDelete(SSdb *pSdb, SFuncObj *pFunc);
 static int32_t  mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOld, SFuncObj *pNew);
-static int32_t  mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCreate);
+static int32_t  mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCreate);
-static int32_t  mndDropFunc(SMnode *pMnode, SNodeMsg *pReq, SFuncObj *pFunc);
+static int32_t  mndDropFunc(SMnode *pMnode, SRpcMsg *pReq, SFuncObj *pFunc);
-static int32_t  mndProcessCreateFuncReq(SNodeMsg *pReq);
+static int32_t  mndProcessCreateFuncReq(SRpcMsg *pReq);
-static int32_t  mndProcessDropFuncReq(SNodeMsg *pReq);
+static int32_t  mndProcessDropFuncReq(SRpcMsg *pReq);
-static int32_t  mndProcessRetrieveFuncReq(SNodeMsg *pReq);
+static int32_t  mndProcessRetrieveFuncReq(SRpcMsg *pReq);
-static int32_t  mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+static int32_t  mndRetrieveFuncs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextFunc(SMnode *pMnode, void *pIter);
 
 int32_t mndInitFunc(SMnode *pMnode) {
@@ -186,7 +186,7 @@ static void mndReleaseFunc(SMnode *pMnode, SFuncObj *pFunc) {
   sdbRelease(pSdb, pFunc);
 }
 
-static int32_t mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCreate) {
+static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCreate) {
   int32_t code = -1;
   STrans *pTrans = NULL;
 
@@ -215,7 +215,7 @@ static int32_t mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCr
   }
   memcpy(func.pCode, pCreate->pCode, func.codeSize);
 
-  pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_FUNC, &pReq->rpcMsg);
+  pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_FUNC, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create func:%s", pTrans->id, pCreate->name);
@@ -243,9 +243,9 @@ _OVER:
   return code;
 }
 
-static int32_t mndDropFunc(SMnode *pMnode, SNodeMsg *pReq, SFuncObj *pFunc) {
+static int32_t mndDropFunc(SMnode *pMnode, SRpcMsg *pReq, SFuncObj *pFunc) {
   int32_t code = -1;
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_FUNC, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_FUNC, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop user:%s", pTrans->id, pFunc->name);
@@ -271,14 +271,14 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) {
+static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) {
-  SMnode        *pMnode = pReq->pNode;
+  SMnode        *pMnode = pReq->info.node;
   int32_t        code = -1;
   SUserObj      *pUser = NULL;
   SFuncObj      *pFunc = NULL;
   SCreateFuncReq createReq = {0};
 
-  if (tDeserializeSCreateFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+  if (tDeserializeSCreateFuncReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -319,7 +319,7 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto _OVER;
@@ -344,14 +344,14 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) {
+static int32_t mndProcessDropFuncReq(SRpcMsg *pReq) {
-  SMnode      *pMnode = pReq->pNode;
+  SMnode      *pMnode = pReq->info.node;
   int32_t      code = -1;
   SUserObj    *pUser = NULL;
   SFuncObj    *pFunc = NULL;
   SDropFuncReq dropReq = {0};
 
-  if (tDeserializeSDropFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+  if (tDeserializeSDropFuncReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -375,7 +375,7 @@ static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) {
     }
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto _OVER;
@@ -399,13 +399,13 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) {
+static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
-  SMnode          *pMnode = pReq->pNode;
+  SMnode          *pMnode = pReq->info.node;
   int32_t          code = -1;
   SRetrieveFuncReq retrieveReq = {0};
   SRetrieveFuncRsp retrieveRsp = {0};
 
-  if (tDeserializeSRetrieveFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &retrieveReq) != 0) {
+  if (tDeserializeSRetrieveFuncReq(pReq->pCont, pReq->contLen, &retrieveReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto RETRIEVE_FUNC_OVER;
   }
@@ -472,8 +472,8 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) {
 
   tSerializeSRetrieveFuncRsp(pRsp, contLen, &retrieveRsp);
 
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = contLen;
+  pReq->info.rspLen = contLen;
 
   code = 0;
 
@@ -502,8 +502,8 @@ static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t le
   return tDataTypes[type].name;
 }
 
-static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+static int32_t mndRetrieveFuncs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SMnode   *pMnode = pReq->pNode;
+  SMnode   *pMnode = pReq->info.node;
   SSdb     *pSdb = pMnode->pSdb;
   int32_t   numOfRows = 0;
   SFuncObj *pFunc = NULL;

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

@@ -21,7 +21,7 @@
 #include "mndShow.h"
 
 #ifndef _GRANT
-static int32_t mndRetrieveGrant(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) { return TSDB_CODE_OPS_NOT_SUPPORT; }
+static int32_t mndRetrieveGrant(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) { return TSDB_CODE_OPS_NOT_SUPPORT; }
 
 int32_t mndInitGrant(SMnode *pMnode) {
     mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_GRANTS, mndRetrieveGrant);

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

@@ -30,12 +30,12 @@ static SSdbRow *mndMnodeActionDecode(SSdbRaw *pRaw);
 static int32_t  mndMnodeActionInsert(SSdb *pSdb, SMnodeObj *pObj);
 static int32_t  mndMnodeActionDelete(SSdb *pSdb, SMnodeObj *pObj);
 static int32_t  mndMnodeActionUpdate(SSdb *pSdb, SMnodeObj *pOld, SMnodeObj *pNew);
-static int32_t  mndProcessCreateMnodeReq(SNodeMsg *pReq);
+static int32_t  mndProcessCreateMnodeReq(SRpcMsg *pReq);
-static int32_t  mndProcessDropMnodeReq(SNodeMsg *pReq);
+static int32_t  mndProcessDropMnodeReq(SRpcMsg *pReq);
-static int32_t  mndProcessCreateMnodeRsp(SNodeMsg *pRsp);
+static int32_t  mndProcessCreateMnodeRsp(SRpcMsg *pRsp);
-static int32_t  mndProcessAlterMnodeRsp(SNodeMsg *pRsp);
+static int32_t  mndProcessAlterMnodeRsp(SRpcMsg *pRsp);
-static int32_t  mndProcessDropMnodeRsp(SNodeMsg *pRsp);
+static int32_t  mndProcessDropMnodeRsp(SRpcMsg *pRsp);
-static int32_t  mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+static int32_t  mndRetrieveMnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextMnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitMnode(SMnode *pMnode) {
@@ -337,7 +337,7 @@ static int32_t mndSetCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDno
   return 0;
 }
 
-static int32_t mndCreateMnode(SMnode *pMnode, SNodeMsg *pReq, SDnodeObj *pDnode, SMCreateMnodeReq *pCreate) {
+static int32_t mndCreateMnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SMCreateMnodeReq *pCreate) {
   int32_t code = -1;
 
   SMnodeObj mnodeObj = {0};
@@ -345,7 +345,7 @@ static int32_t mndCreateMnode(SMnode *pMnode, SNodeMsg *pReq, SDnodeObj *pDnode,
   mnodeObj.createdTime = taosGetTimestampMs();
   mnodeObj.updateTime = mnodeObj.createdTime;
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_CREATE_MNODE, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_CREATE_MNODE, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create mnode:%d", pTrans->id, pCreate->dnodeId);
@@ -362,15 +362,15 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessCreateMnodeReq(SNodeMsg *pReq) {
+static int32_t mndProcessCreateMnodeReq(SRpcMsg *pReq) {
-  SMnode          *pMnode = pReq->pNode;
+  SMnode          *pMnode = pReq->info.node;
   int32_t          code = -1;
   SMnodeObj       *pObj = NULL;
   SDnodeObj       *pDnode = NULL;
   SUserObj        *pUser = NULL;
   SMCreateMnodeReq createReq = {0};
 
-  if (tDeserializeSCreateDropMQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+  if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -391,7 +391,7 @@ static int32_t mndProcessCreateMnodeReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto _OVER;
@@ -509,10 +509,10 @@ static int32_t mndSetDropMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnode
   return 0;
 }
 
-static int32_t mndDropMnode(SMnode *pMnode, SNodeMsg *pReq, SMnodeObj *pObj) {
+static int32_t mndDropMnode(SMnode *pMnode, SRpcMsg *pReq, SMnodeObj *pObj) {
   int32_t code = -1;
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_DROP_MNODE, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_DROP_MNODE, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop mnode:%d", pTrans->id, pObj->id);
@@ -529,14 +529,14 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessDropMnodeReq(SNodeMsg *pReq) {
+static int32_t mndProcessDropMnodeReq(SRpcMsg *pReq) {
-  SMnode        *pMnode = pReq->pNode;
+  SMnode        *pMnode = pReq->info.node;
   int32_t        code = -1;
   SUserObj      *pUser = NULL;
   SMnodeObj     *pObj = NULL;
   SMDropMnodeReq dropReq = {0};
 
-  if (tDeserializeSCreateDropMQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+  if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -563,7 +563,7 @@ static int32_t mndProcessDropMnodeReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto _OVER;
@@ -587,23 +587,23 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessCreateMnodeRsp(SNodeMsg *pRsp) {
+static int32_t mndProcessCreateMnodeRsp(SRpcMsg *pRsp) {
   mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessAlterMnodeRsp(SNodeMsg *pRsp) {
+static int32_t mndProcessAlterMnodeRsp(SRpcMsg *pRsp) {
   mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessDropMnodeRsp(SNodeMsg *pRsp) {
+static int32_t mndProcessDropMnodeRsp(SRpcMsg *pRsp) {
   mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+static int32_t mndRetrieveMnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SMnode    *pMnode = pReq->pNode;
+  SMnode    *pMnode = pReq->info.node;
   SSdb      *pSdb = pMnode->pSdb;
   int32_t    numOfRows = 0;
   int32_t    cols = 0;

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

@@ -32,7 +32,7 @@
 static int32_t mndOffsetActionInsert(SSdb *pSdb, SMqOffsetObj *pOffset);
 static int32_t mndOffsetActionDelete(SSdb *pSdb, SMqOffsetObj *pOffset);
 static int32_t mndOffsetActionUpdate(SSdb *pSdb, SMqOffsetObj *pOffset, SMqOffsetObj *pNewOffset);
-static int32_t mndProcessCommitOffsetReq(SNodeMsg *pReq);
+static int32_t mndProcessCommitOffsetReq(SRpcMsg *pReq);
 
 int32_t mndInitOffset(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_OFFSET,
@@ -50,6 +50,14 @@ int32_t mndInitOffset(SMnode *pMnode) {
 
 void mndCleanupOffset(SMnode *pMnode) {}
 
+bool mndOffsetFromTopic(SMqOffsetObj *pOffset, const char *topic) {
+  int32_t i = 0;
+  while (pOffset->key[i] != ':') i++;
+  while (pOffset->key[i] != ':') i++;
+  if (strcmp(&pOffset->key[i + 1], topic) == 0) return true;
+  return false;
+}
+
 SSdbRaw *mndOffsetActionEncode(SMqOffsetObj *pOffset) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   void   *buf = NULL;
@@ -134,10 +142,11 @@ int32_t mndCreateOffsets(STrans *pTrans, const char *cgroup, const char *topicNa
   int32_t sz = taosArrayGetSize(vgs);
   for (int32_t i = 0; i < sz; i++) {
     int32_t      vgId = *(int32_t *)taosArrayGet(vgs, i);
-    SMqOffsetObj offsetObj;
+    SMqOffsetObj offsetObj = {0};
     if (mndMakePartitionKey(offsetObj.key, cgroup, topicName, vgId) < 0) {
       return -1;
     }
+    // TODO assign db
     offsetObj.offset = -1;
     SSdbRaw *pOffsetRaw = mndOffsetActionEncode(&offsetObj);
     if (pOffsetRaw == NULL) {
@@ -151,18 +160,18 @@ int32_t mndCreateOffsets(STrans *pTrans, const char *cgroup, const char *topicNa
   return 0;
 }
 
-static int32_t mndProcessCommitOffsetReq(SNodeMsg *pMsg) {
+static int32_t mndProcessCommitOffsetReq(SRpcMsg *pMsg) {
   char key[TSDB_PARTITION_KEY_LEN];
 
-  SMnode              *pMnode = pMsg->pNode;
+  SMnode              *pMnode = pMsg->info.node;
-  char                *msgStr = pMsg->rpcMsg.pCont;
+  char                *msgStr = pMsg->pCont;
   SMqCMCommitOffsetReq commitOffsetReq;
   SDecoder             decoder;
-  tDecoderInit(&decoder, msgStr, pMsg->rpcMsg.contLen);
+  tDecoderInit(&decoder, msgStr, pMsg->contLen);
 
   tDecodeSMqCMCommitOffsetReq(&decoder, &commitOffsetReq);
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_COMMIT_OFFSET, &pMsg->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_COMMIT_OFFSET, pMsg);
 
   for (int32_t i = 0; i < commitOffsetReq.num; i++) {
     SMqOffset *pOffset = &commitOffsetReq.offsets[i];
@@ -240,6 +249,14 @@ static int32_t mndSetDropOffsetCommitLogs(SMnode *pMnode, STrans *pTrans, SMqOff
   return 0;
 }
 
+static int32_t mndSetDropOffsetRedoLogs(SMnode *pMnode, STrans *pTrans, SMqOffsetObj *pOffset) {
+  SSdbRaw *pRedoRaw = mndOffsetActionEncode(pOffset);
+  if (pRedoRaw == NULL) return -1;
+  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
+  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPED) != 0) return -1;
+  return 0;
+}
+
 int32_t mndDropOffsetByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
   int32_t code = -1;
   SSdb   *pSdb = pMnode->pSdb;
@@ -247,7 +264,7 @@ int32_t mndDropOffsetByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
   void         *pIter = NULL;
   SMqOffsetObj *pOffset = NULL;
   while (1) {
-    pIter = sdbFetch(pSdb, SDB_SUBSCRIBE, pIter, (void **)&pOffset);
+    pIter = sdbFetch(pSdb, SDB_OFFSET, pIter, (void **)&pOffset);
     if (pIter == NULL) break;
 
     if (pOffset->dbUid != pDb->uid) {
@@ -256,8 +273,39 @@ int32_t mndDropOffsetByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
     }
 
     if (mndSetDropOffsetCommitLogs(pMnode, pTrans, pOffset) < 0) {
+      sdbRelease(pSdb, pOffset);
       goto END;
     }
+
+    sdbRelease(pSdb, pOffset);
+  }
+
+  code = 0;
+END:
+  return code;
+}
+
+int32_t mndDropOffsetByTopic(SMnode *pMnode, STrans *pTrans, const char *topic) {
+  int32_t code = -1;
+  SSdb   *pSdb = pMnode->pSdb;
+
+  void         *pIter = NULL;
+  SMqOffsetObj *pOffset = NULL;
+  while (1) {
+    pIter = sdbFetch(pSdb, SDB_OFFSET, pIter, (void **)&pOffset);
+    if (pIter == NULL) break;
+
+    if (!mndOffsetFromTopic(pOffset, topic)) {
+      sdbRelease(pSdb, pOffset);
+      continue;
+    }
+
+    if (mndSetDropOffsetRedoLogs(pMnode, pTrans, pOffset) < 0) {
+      sdbRelease(pSdb, pOffset);
+      goto END;
+    }
+
+    sdbRelease(pSdb, pOffset);
   }
 
   code = 0;

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

@@ -16,11 +16,11 @@
 #define _DEFAULT_SOURCE
 #include "mndProfile.h"
 #include "mndDb.h"
+#include "mndDnode.h"
 #include "mndMnode.h"
 #include "mndShow.h"
 #include "mndStb.h"
 #include "mndUser.h"
-#include "mndDnode.h"
 #include "tglobal.h"
 #include "version.h"
 
@@ -48,12 +48,12 @@ static SConnObj *mndAcquireConn(SMnode *pMnode, uint32_t connId);
 static void      mndReleaseConn(SMnode *pMnode, SConnObj *pConn);
 static void     *mndGetNextConn(SMnode *pMnode, SCacheIter *pIter);
 static void      mndCancelGetNextConn(SMnode *pMnode, void *pIter);
-static int32_t   mndProcessHeartBeatReq(SNodeMsg *pReq);
+static int32_t   mndProcessHeartBeatReq(SRpcMsg *pReq);
-static int32_t   mndProcessConnectReq(SNodeMsg *pReq);
+static int32_t   mndProcessConnectReq(SRpcMsg *pReq);
-static int32_t   mndProcessKillQueryReq(SNodeMsg *pReq);
+static int32_t   mndProcessKillQueryReq(SRpcMsg *pReq);
-static int32_t   mndProcessKillConnReq(SNodeMsg *pReq);
+static int32_t   mndProcessKillConnReq(SRpcMsg *pReq);
-static int32_t   mndRetrieveConns(SNodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
+static int32_t   mndRetrieveConns(SRpcMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
-static int32_t   mndRetrieveQueries(SNodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
+static int32_t   mndRetrieveQueries(SRpcMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void      mndCancelGetNextQuery(SMnode *pMnode, void *pIter);
 
 int32_t mndInitProfile(SMnode *pMnode) {
@@ -175,8 +175,8 @@ static void mndCancelGetNextConn(SMnode *pMnode, void *pIter) {
   }
 }
 
-static int32_t mndProcessConnectReq(SNodeMsg *pReq) {
+static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
-  SMnode     *pMnode = pReq->pNode;
+  SMnode     *pMnode = pReq->info.node;
   SUserObj   *pUser = NULL;
   SDbObj     *pDb = NULL;
   SConnObj   *pConn = NULL;
@@ -184,20 +184,21 @@ static int32_t mndProcessConnectReq(SNodeMsg *pReq) {
   SConnectReq connReq = {0};
   char        ip[30] = {0};
 
-  if (tDeserializeSConnectReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &connReq) != 0) {
+  if (tDeserializeSConnectReq(pReq->pCont, pReq->contLen, &connReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto CONN_OVER;
   }
 
-  taosIp2String(pReq->clientIp, ip);
+  taosIp2String(pReq->conn.clientIp, ip);
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
-    mError("user:%s, failed to login while acquire user since %s", pReq->user, terrstr());
+    mError("user:%s, failed to login while acquire user since %s", pReq->conn.user, terrstr());
     goto CONN_OVER;
   }
   if (0 != strncmp(connReq.passwd, pUser->pass, TSDB_PASSWORD_LEN - 1)) {
-    mError("user:%s, failed to auth while acquire user, input:%s saved:%s", pReq->user, connReq.passwd, pUser->pass);
+    mError("user:%s, failed to auth while acquire user, input:%s saved:%s", pReq->conn.user, connReq.passwd,
+           pUser->pass);
     code = TSDB_CODE_RPC_AUTH_FAILURE;
     goto CONN_OVER;
   }
@@ -208,15 +209,15 @@ static int32_t mndProcessConnectReq(SNodeMsg *pReq) {
     pDb = mndAcquireDb(pMnode, db);
     if (pDb == NULL) {
       terrno = TSDB_CODE_MND_INVALID_DB;
-      mError("user:%s, failed to login from %s while use db:%s since %s", pReq->user, ip, connReq.db, terrstr());
+      mError("user:%s, failed to login from %s while use db:%s since %s", pReq->conn.user, ip, connReq.db, terrstr());
       goto CONN_OVER;
     }
   }
 
-  pConn = mndCreateConn(pMnode, pReq->user, connReq.connType, pReq->clientIp, pReq->clientPort, connReq.pid,
+  pConn = mndCreateConn(pMnode, pReq->conn.user, connReq.connType, pReq->conn.clientIp, pReq->conn.clientPort,
-                        connReq.app, connReq.startTime);
+                        connReq.pid, connReq.app, connReq.startTime);
   if (pConn == NULL) {
-    mError("user:%s, failed to login from %s while create connection since %s", pReq->user, ip, terrstr());
+    mError("user:%s, failed to login from %s while create connection since %s", pReq->conn.user, ip, terrstr());
     goto CONN_OVER;
   }
 
@@ -240,10 +241,10 @@ static int32_t mndProcessConnectReq(SNodeMsg *pReq) {
   if (pRsp == NULL) goto CONN_OVER;
   tSerializeSConnectRsp(pRsp, contLen, &connectRsp);
 
-  pReq->rspLen = contLen;
+  pReq->info.rspLen = contLen;
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
 
-  mDebug("user:%s, login from %s:%d, conn:%u, app:%s", pReq->user, ip, pConn->port, pConn->id, connReq.app);
+  mDebug("user:%s, login from %s:%d, conn:%u, app:%s", pReq->conn.user, ip, pConn->port, pConn->id, connReq.app);
 
   code = 0;
 
@@ -341,7 +342,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
     SQueryHbReqBasic *pBasic = pHbReq->query;
 
     SRpcConnInfo connInfo = {0};
-    rpcGetConnInfo(pMsg->handle, &connInfo);
+    rpcGetConnInfo(pMsg->info.handle, &connInfo);
 
     SConnObj *pConn = mndAcquireConn(pMnode, pBasic->connId);
     if (pConn == NULL) {
@@ -449,11 +450,11 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mndProcessHeartBeatReq(SNodeMsg *pReq) {
+static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
-  SMnode *pMnode = pReq->pNode;
+  SMnode *pMnode = pReq->info.node;
 
   SClientHbBatchReq batchReq = {0};
-  if (tDeserializeSClientHbBatchReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &batchReq) != 0) {
+  if (tDeserializeSClientHbBatchReq(pReq->pCont, pReq->contLen, &batchReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
@@ -465,7 +466,7 @@ static int32_t mndProcessHeartBeatReq(SNodeMsg *pReq) {
   for (int i = 0; i < sz; i++) {
     SClientHbReq *pHbReq = taosArrayGet(batchReq.reqs, i);
     if (pHbReq->connKey.connType == CONN_TYPE__QUERY) {
-      mndProcessQueryHeartBeat(pMnode, &pReq->rpcMsg, pHbReq, &batchRsp);
+      mndProcessQueryHeartBeat(pMnode, pReq, pHbReq, &batchRsp);
     } else if (pHbReq->connKey.connType == CONN_TYPE__TMQ) {
       SClientHbRsp *pRsp = mndMqHbBuildRsp(pMnode, pHbReq);
       if (pRsp != NULL) {
@@ -492,17 +493,17 @@ static int32_t mndProcessHeartBeatReq(SNodeMsg *pReq) {
   }
 
   taosArrayDestroy(batchRsp.rsps);
-  pReq->rspLen = tlen;
+  pReq->info.rspLen = tlen;
-  pReq->pRsp = buf;
+  pReq->info.rsp = buf;
 
   return 0;
 }
 
-static int32_t mndProcessKillQueryReq(SNodeMsg *pReq) {
+static int32_t mndProcessKillQueryReq(SRpcMsg *pReq) {
-  SMnode       *pMnode = pReq->pNode;
+  SMnode       *pMnode = pReq->info.node;
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 
-  SUserObj *pUser = mndAcquireUser(pMnode, pReq->user);
+  SUserObj *pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) return 0;
   if (!pUser->superUser) {
     mndReleaseUser(pMnode, pUser);
@@ -512,7 +513,7 @@ static int32_t mndProcessKillQueryReq(SNodeMsg *pReq) {
   mndReleaseUser(pMnode, pUser);
 
   SKillQueryReq killReq = {0};
-  if (tDeserializeSKillQueryReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &killReq) != 0) {
+  if (tDeserializeSKillQueryReq(pReq->pCont, pReq->contLen, &killReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
@@ -525,18 +526,18 @@ static int32_t mndProcessKillQueryReq(SNodeMsg *pReq) {
     terrno = TSDB_CODE_MND_INVALID_CONN_ID;
     return -1;
   } else {
-    mInfo("connId:%d, queryId:%d is killed by user:%s", killReq.connId, killReq.queryId, pReq->user);
+    mInfo("connId:%d, queryId:%d is killed by user:%s", killReq.connId, killReq.queryId, pReq->conn.user);
     pConn->killId = killReq.queryId;
     taosCacheRelease(pMgmt->cache, (void **)&pConn, false);
     return 0;
   }
 }
 
-static int32_t mndProcessKillConnReq(SNodeMsg *pReq) {
+static int32_t mndProcessKillConnReq(SRpcMsg *pReq) {
-  SMnode       *pMnode = pReq->pNode;
+  SMnode       *pMnode = pReq->info.node;
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 
-  SUserObj *pUser = mndAcquireUser(pMnode, pReq->user);
+  SUserObj *pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) return 0;
   if (!pUser->superUser) {
     mndReleaseUser(pMnode, pUser);
@@ -546,7 +547,7 @@ static int32_t mndProcessKillConnReq(SNodeMsg *pReq) {
   mndReleaseUser(pMnode, pUser);
 
   SKillConnReq killReq = {0};
-  if (tDeserializeSKillConnReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &killReq) != 0) {
+  if (tDeserializeSKillConnReq(pReq->pCont, pReq->contLen, &killReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
@@ -557,15 +558,15 @@ static int32_t mndProcessKillConnReq(SNodeMsg *pReq) {
     terrno = TSDB_CODE_MND_INVALID_CONN_ID;
     return -1;
   } else {
-    mInfo("connId:%d, is killed by user:%s", killReq.connId, pReq->user);
+    mInfo("connId:%d, is killed by user:%s", killReq.connId, pReq->conn.user);
     pConn->killed = 1;
     taosCacheRelease(pMgmt->cache, (void **)&pConn, false);
     return TSDB_CODE_SUCCESS;
   }
 }
 
-static int32_t mndRetrieveConns(SNodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
+static int32_t mndRetrieveConns(SRpcMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode   *pMnode = pReq->pNode;
+  SMnode   *pMnode = pReq->info.node;
   int32_t   numOfRows = 0;
   SConnObj *pConn = NULL;
   int32_t   cols = 0;
@@ -624,8 +625,8 @@ static int32_t mndRetrieveConns(SNodeMsg *pReq, SShowObj *pShow, char *data, int
   return numOfRows;
 }
 
-static int32_t mndRetrieveQueries(SNodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
+static int32_t mndRetrieveQueries(SRpcMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode   *pMnode = pReq->pNode;
+  SMnode *pMnode = pReq->info.node;
   int32_t numOfRows = 0;
 #if 0
   SConnObj *pConn = NULL;

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

@@ -29,12 +29,12 @@ static SSdbRow *mndQnodeActionDecode(SSdbRaw *pRaw);
 static int32_t  mndQnodeActionInsert(SSdb *pSdb, SQnodeObj *pObj);
 static int32_t  mndQnodeActionUpdate(SSdb *pSdb, SQnodeObj *pOld, SQnodeObj *pNew);
 static int32_t  mndQnodeActionDelete(SSdb *pSdb, SQnodeObj *pObj);
-static int32_t  mndProcessCreateQnodeReq(SNodeMsg *pReq);
+static int32_t  mndProcessCreateQnodeReq(SRpcMsg *pReq);
-static int32_t  mndProcessCreateQnodeRsp(SNodeMsg *pRsp);
+static int32_t  mndProcessCreateQnodeRsp(SRpcMsg *pRsp);
-static int32_t  mndProcessDropQnodeReq(SNodeMsg *pReq);
+static int32_t  mndProcessDropQnodeReq(SRpcMsg *pReq);
-static int32_t  mndProcessDropQnodeRsp(SNodeMsg *pRsp);
+static int32_t  mndProcessDropQnodeRsp(SRpcMsg *pRsp);
-static int32_t  mndProcessQnodeListReq(SNodeMsg *pReq);
+static int32_t  mndProcessQnodeListReq(SRpcMsg *pReq);
-static int32_t  mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+static int32_t  mndRetrieveQnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextQnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitQnode(SMnode *pMnode) {
@@ -240,7 +240,7 @@ static int32_t mndSetCreateQnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S
   return 0;
 }
 
-static int32_t mndCreateQnode(SMnode *pMnode, SNodeMsg *pReq, SDnodeObj *pDnode, SMCreateQnodeReq *pCreate) {
+static int32_t mndCreateQnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SMCreateQnodeReq *pCreate) {
   int32_t code = -1;
 
   SQnodeObj qnodeObj = {0};
@@ -248,7 +248,7 @@ static int32_t mndCreateQnode(SMnode *pMnode, SNodeMsg *pReq, SDnodeObj *pDnode,
   qnodeObj.createdTime = taosGetTimestampMs();
   qnodeObj.updateTime = qnodeObj.createdTime;
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_QNODE, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_QNODE, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create qnode:%d", pTrans->id, pCreate->dnodeId);
@@ -266,15 +266,15 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessCreateQnodeReq(SNodeMsg *pReq) {
+static int32_t mndProcessCreateQnodeReq(SRpcMsg *pReq) {
-  SMnode          *pMnode = pReq->pNode;
+  SMnode          *pMnode = pReq->info.node;
   int32_t          code = -1;
   SQnodeObj       *pObj = NULL;
   SDnodeObj       *pDnode = NULL;
   SUserObj        *pUser = NULL;
   SMCreateQnodeReq createReq = {0};
 
-  if (tDeserializeSCreateDropMQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+  if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -295,7 +295,7 @@ static int32_t mndProcessCreateQnodeReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto _OVER;
@@ -362,10 +362,10 @@ static int32_t mndSetDropQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SQn
   return 0;
 }
 
-static int32_t mndDropQnode(SMnode *pMnode, SNodeMsg *pReq, SQnodeObj *pObj) {
+static int32_t mndDropQnode(SMnode *pMnode, SRpcMsg *pReq, SQnodeObj *pObj) {
   int32_t code = -1;
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_DROP_QNODE, &pReq->rpcMsg);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_DROP_QNODE, pReq);
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop qnode:%d", pTrans->id, pObj->id);
@@ -381,14 +381,14 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessDropQnodeReq(SNodeMsg *pReq) {
+static int32_t mndProcessDropQnodeReq(SRpcMsg *pReq) {
-  SMnode        *pMnode = pReq->pNode;
+  SMnode        *pMnode = pReq->info.node;
   int32_t        code = -1;
   SUserObj      *pUser = NULL;
   SQnodeObj     *pObj = NULL;
   SMDropQnodeReq dropReq = {0};
 
-  if (tDeserializeSCreateDropMQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+  if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
@@ -405,7 +405,7 @@ static int32_t mndProcessDropQnodeReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->user);
+  pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
     goto _OVER;
@@ -429,16 +429,16 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessQnodeListReq(SNodeMsg *pReq) {
+static int32_t mndProcessQnodeListReq(SRpcMsg *pReq) {
   int32_t       code = -1;
   int32_t       numOfRows = 0;
-  SMnode       *pMnode = pReq->pNode;
+  SMnode       *pMnode = pReq->info.node;
   SSdb         *pSdb = pMnode->pSdb;
   SQnodeObj    *pObj = NULL;
   SQnodeListReq qlistReq = {0};
   SQnodeListRsp qlistRsp = {0};
 
-  if (tDeserializeSQnodeListReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &qlistReq) != 0) {
+  if (tDeserializeSQnodeListReq(pReq->pCont, pReq->contLen, &qlistReq) != 0) {
     mError("failed to parse qnode list req");
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
@@ -481,8 +481,8 @@ static int32_t mndProcessQnodeListReq(SNodeMsg *pReq) {
 
   tSerializeSQnodeListRsp(pRsp, rspLen, &qlistRsp);
 
-  pReq->rspLen = rspLen;
+  pReq->info.rspLen = rspLen;
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
   code = 0;
 
 _OVER:
@@ -490,18 +490,18 @@ _OVER:
   return code;
 }
 
-static int32_t mndProcessCreateQnodeRsp(SNodeMsg *pRsp) {
+static int32_t mndProcessCreateQnodeRsp(SRpcMsg *pRsp) {
   mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessDropQnodeRsp(SNodeMsg *pRsp) {
+static int32_t mndProcessDropQnodeRsp(SRpcMsg *pRsp) {
   mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+static int32_t mndRetrieveQnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SMnode    *pMnode = pReq->pNode;
+  SMnode    *pMnode = pReq->info.node;
   SSdb      *pSdb = pMnode->pSdb;
   int32_t    numOfRows = 0;
   int32_t    cols = 0;

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

@@ -18,35 +18,35 @@
 #include "mndMnode.h"
 #include "qworker.h"
 
-int32_t mndProcessQueryMsg(SNodeMsg *pReq) {
+int32_t mndProcessQueryMsg(SRpcMsg *pReq) {
-  SMnode     *pMnode = pReq->pNode;
+  SMnode     *pMnode = pReq->info.node;
   SReadHandle handle = {.mnd = pMnode, .pMsgCb = &pMnode->msgCb};
 
   mTrace("msg:%p, in query queue is processing", pReq);
-  switch (pReq->rpcMsg.msgType) {
+  switch (pReq->msgType) {
     case TDMT_VND_QUERY:
-      return qWorkerProcessQueryMsg(&handle, pMnode->pQuery, &pReq->rpcMsg);
+      return qWorkerProcessQueryMsg(&handle, pMnode->pQuery, pReq);
     case TDMT_VND_QUERY_CONTINUE:
-      return qWorkerProcessCQueryMsg(&handle, pMnode->pQuery, &pReq->rpcMsg);
+      return qWorkerProcessCQueryMsg(&handle, pMnode->pQuery, pReq);
     default:
-      mError("unknown msg type:%d in query queue", pReq->rpcMsg.msgType);
+      mError("unknown msg type:%d in query queue", pReq->msgType);
       return TSDB_CODE_VND_APP_ERROR;
   }
 }
 
-int32_t mndProcessFetchMsg(SNodeMsg *pReq) {
+int32_t mndProcessFetchMsg(SRpcMsg *pMsg) {
-  SMnode *pMnode = pReq->pNode;
+  SMnode *pMnode = pMsg->info.node;
-  mTrace("msg:%p, in fetch queue is processing", pReq);
+  mTrace("msg:%p, in fetch queue is processing", pMsg);
 
-  switch (pReq->rpcMsg.msgType) {
+  switch (pMsg->msgType) {
     case TDMT_VND_FETCH:
-      return qWorkerProcessFetchMsg(pMnode, pMnode->pQuery, &pReq->rpcMsg);
+      return qWorkerProcessFetchMsg(pMnode, pMnode->pQuery, pMsg);
     case TDMT_VND_DROP_TASK:
-      return qWorkerProcessDropMsg(pMnode, pMnode->pQuery, &pReq->rpcMsg);
+      return qWorkerProcessDropMsg(pMnode, pMnode->pQuery, pMsg);
     case TDMT_VND_QUERY_HEARTBEAT:
-      return qWorkerProcessHbMsg(pMnode, pMnode->pQuery, &pReq->rpcMsg);
+      return qWorkerProcessHbMsg(pMnode, pMnode->pQuery, pMsg);
     default:
-      mError("unknown msg type:%d in fetch queue", pReq->rpcMsg.msgType);
+      mError("unknown msg type:%d in fetch queue", pMsg->msgType);
       return TSDB_CODE_VND_APP_ERROR;
   }
 }

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

@@ -24,7 +24,7 @@ static void      mndFreeShowObj(SShowObj *pShow);
 static SShowObj *mndAcquireShowObj(SMnode *pMnode, int64_t showId);
 static void      mndReleaseShowObj(SShowObj *pShow, bool forceRemove);
 static bool      mndCheckRetrieveFinished(SShowObj *pShow);
-static int32_t   mndProcessRetrieveSysTableReq(SNodeMsg *pReq);
+static int32_t   mndProcessRetrieveSysTableReq(SRpcMsg *pReq);
 
 int32_t mndInitShow(SMnode *pMnode) {
   SShowMgmt *pMgmt = &pMnode->showMgmt;
@@ -175,8 +175,8 @@ static void mndReleaseShowObj(SShowObj *pShow, bool forceRemove) {
   taosCacheRelease(pMgmt->cache, (void **)(&pShow), forceRemove);
 }
 
-static int32_t mndProcessRetrieveSysTableReq(SNodeMsg *pReq) {
+static int32_t mndProcessRetrieveSysTableReq(SRpcMsg *pReq) {
-  SMnode    *pMnode = pReq->pNode;
+  SMnode    *pMnode = pReq->info.node;
   SShowMgmt *pMgmt = &pMnode->showMgmt;
   SShowObj  *pShow = NULL;
   int32_t    rowsToRead = SHOW_STEP_SIZE;
@@ -184,7 +184,7 @@ static int32_t mndProcessRetrieveSysTableReq(SNodeMsg *pReq) {
   int32_t    rowsRead = 0;
 
   SRetrieveTableReq retrieveReq = {0};
-  if (tDeserializeSRetrieveTableReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &retrieveReq) != 0) {
+  if (tDeserializeSRetrieveTableReq(pReq->pCont, pReq->contLen, &retrieveReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
@@ -300,8 +300,8 @@ static int32_t mndProcessRetrieveSysTableReq(SNodeMsg *pReq) {
 
   pRsp->numOfRows = htonl(rowsRead);
   pRsp->precision = TSDB_TIME_PRECISION_MILLI;  // millisecond time precision
-  pReq->pRsp = pRsp;
+  pReq->info.rsp = pRsp;
-  pReq->rspLen = size;
+  pReq->info.rspLen = size;
 
   if (rowsRead == 0 || rowsRead < rowsToRead) {
     pRsp->completed = 1;