Merge pull request #14214 from taosdata/feat/rpcRefactor1

feat: rpc refactor

include/libs/qcom/query.h

@@ -16,6 +16,7 @@
 #ifndef _TD_QUERY_H_
 #define _TD_QUERY_H_
 
+// clang-foramt off
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -71,7 +72,7 @@ typedef struct SIndexMeta {
 } SIndexMeta;
 
 typedef struct STbVerInfo {
-  char tbFName[TSDB_TABLE_FNAME_LEN];
+  char    tbFName[TSDB_TABLE_FNAME_LEN];
   int32_t sversion;
   int32_t tversion;
 } STbVerInfo;
@@ -141,7 +142,7 @@ typedef struct SDataBuf {
 
 typedef struct STargetInfo {
   ETargetType type;
-  char*       dbFName; // used to update db's vgroup epset
+  char*       dbFName;  // used to update db's vgroup epset
   int32_t     vgId;
 } STargetInfo;
 
@@ -149,15 +150,15 @@ typedef int32_t (*__async_send_cb_fn_t)(void* param, const SDataBuf* pMsg, int32
 typedef int32_t (*__async_exec_fn_t)(void* param);
 
 typedef struct SRequestConnInfo {
-  void*     pTrans;
-  uint64_t  requestId;
-  int64_t   requestObjRefId;
-  SEpSet    mgmtEps;
+  void*    pTrans;
+  uint64_t requestId;
+  int64_t  requestObjRefId;
+  SEpSet   mgmtEps;
 } SRequestConnInfo;
 
 typedef struct SMsgSendInfo {
-  __async_send_cb_fn_t fp;  // async callback function
-  STargetInfo          target; // for update epset
+  __async_send_cb_fn_t fp;      // async callback function
+  STargetInfo          target;  // for update epset
   void*                param;
   uint64_t             requestId;
   uint64_t             requestObjRefId;
@@ -206,13 +207,15 @@ int32_t queryCreateTableMetaFromMsg(STableMetaRsp* msg, bool isSuperTable, STabl
 char*   jobTaskStatusStr(int32_t status);
 
 SSchema createSchema(int8_t type, int32_t bytes, col_id_t colId, const char* name);
-void destroyQueryExecRes(SQueryExecRes* pRes);
-int32_t dataConverToStr(char *str, int type, void *buf, int32_t bufSize, int32_t *len);
-char* parseTagDatatoJson(void* p);
+
+void    destroyQueryExecRes(SQueryExecRes* pRes);
+int32_t dataConverToStr(char* str, int type, void* buf, int32_t bufSize, int32_t* len);
+char*   parseTagDatatoJson(void* p);
 int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst);
 int32_t cloneDbVgInfo(SDBVgInfo* pSrc, SDBVgInfo** pDst);
 
-extern int32_t (*queryBuildMsg[TDMT_MAX])(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void*(*mallocFp)(int32_t));
+extern int32_t (*queryBuildMsg[TDMT_MAX])(void* input, char** msg, int32_t msgSize, int32_t* msgLen,
+                                          void* (*mallocFp)(int32_t));
 extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char* msg, int32_t msgSize);
 
 #define SET_META_TYPE_NULL(t)       (t) = META_TYPE_NULL_TABLE
@@ -223,7 +226,7 @@ extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char* msg, int32_t
 #define NEED_CLIENT_RM_TBLMETA_ERROR(_code)                                                   \
   ((_code) == TSDB_CODE_PAR_TABLE_NOT_EXIST || (_code) == TSDB_CODE_VND_TB_NOT_EXIST ||       \
    (_code) == TSDB_CODE_PAR_INVALID_COLUMNS_NUM || (_code) == TSDB_CODE_PAR_INVALID_COLUMN || \
-   (_code) == TSDB_CODE_PAR_TAGS_NOT_MATCHED || (_code) == TSDB_CODE_PAR_VALUE_TOO_LONG || \
+   (_code) == TSDB_CODE_PAR_TAGS_NOT_MATCHED || (_code) == TSDB_CODE_PAR_VALUE_TOO_LONG ||    \
    (_code) == TSDB_CODE_PAR_INVALID_DROP_COL || ((_code) == TSDB_CODE_TDB_INVALID_TABLE_ID))
 #define NEED_CLIENT_REFRESH_VG_ERROR(_code) \
   ((_code) == TSDB_CODE_VND_HASH_MISMATCH || (_code) == TSDB_CODE_VND_INVALID_VGROUP_ID)
@@ -231,11 +234,13 @@ extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char* msg, int32_t
 #define NEED_CLIENT_HANDLE_ERROR(_code)                                          \
   (NEED_CLIENT_RM_TBLMETA_ERROR(_code) || NEED_CLIENT_REFRESH_VG_ERROR(_code) || \
    NEED_CLIENT_REFRESH_TBLMETA_ERROR(_code))
-#define NEED_CLIENT_RM_TBLMETA_REQ(_type) ((_type) == TDMT_VND_CREATE_TABLE || (_type) == TDMT_VND_CREATE_STB \
-  || (_type) == TDMT_VND_DROP_TABLE || (_type) == TDMT_VND_DROP_STB)
+#define NEED_CLIENT_RM_TBLMETA_REQ(_type)                                                                  \
+  ((_type) == TDMT_VND_CREATE_TABLE || (_type) == TDMT_VND_CREATE_STB || (_type) == TDMT_VND_DROP_TABLE || \
+   (_type) == TDMT_VND_DROP_STB)
 
-#define NEED_SCHEDULER_RETRY_ERROR(_code) \
-  ((_code) == TSDB_CODE_RPC_REDIRECT || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL || (_code) == TSDB_CODE_SCH_TIMEOUT_ERROR)
+#define NEED_SCHEDULER_RETRY_ERROR(_code)                                           \
+  ((_code) == TSDB_CODE_RPC_REDIRECT || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL || \
+   (_code) == TSDB_CODE_SCH_TIMEOUT_ERROR)
 
 #define REQUEST_TOTAL_EXEC_TIMES 2
 
@@ -312,3 +317,4 @@ extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char* msg, int32_t
 #endif
 
 #endif /*_TD_QUERY_H_*/
+       // clang-foramt on

include/os/osSocket.h

@@ -157,7 +157,10 @@ int32_t taosNonblockwrite(TdSocketPtr pSocket, char *ptr, int32_t nbytes);
 int64_t taosCopyFds(TdSocketPtr pSrcSocket, TdSocketPtr pDestSocket, int64_t len);
 void    taosWinSocketInit();
 
-int taosCreateSocketWithTimeOutOpt(uint32_t conn_timeout_sec);
+/*
+ * set timeout(ms)
+ */
+int32_t taosCreateSocketWithTimeout(uint32_t timeout);
 
 TdSocketPtr       taosOpenUdpSocket(uint32_t localIp, uint16_t localPort);
 TdSocketPtr       taosOpenTcpClientSocket(uint32_t ip, uint16_t port, uint32_t localIp);

include/util/ttrace.h

@@ -45,9 +45,11 @@ typedef struct STraceId {
 
 #define TRACE_GET_MSGID(traceId) (traceId)->msgId
 
-#define TRACE_TO_STR(traceId, buf)                                                \
-  do {                                                                            \
-    sprintf(buf, "0x%" PRIx64 ":0x%" PRIx64 "", traceId->rootId, traceId->msgId); \
+#define TRACE_TO_STR(traceId, buf)                              \
+  do {                                                          \
+    int64_t rootId = (traceId) != NULL ? (traceId)->rootId : 0; \
+    int64_t msgId = (traceId) != NULL ? (traceId)->msgId : 0;   \
+    sprintf(buf, "0x%" PRIx64 ":0x%" PRIx64 "", rootId, msgId); \
   } while (0)
 
 #ifdef __cplusplus

source/client/src/clientEnv.c

@@ -13,11 +13,11 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "os.h"
 #include "catalog.h"
-#include "functionMgt.h"
 #include "clientInt.h"
 #include "clientLog.h"
+#include "functionMgt.h"
+#include "os.h"
 #include "query.h"
 #include "scheduler.h"
 #include "tcache.h"
@@ -38,7 +38,7 @@ static TdThreadOnce tscinit = PTHREAD_ONCE_INIT;
 volatile int32_t    tscInitRes = 0;
 
 static void registerRequest(SRequestObj *pRequest) {
-  STscObj *pTscObj = acquireTscObj(*(int64_t*)pRequest->pTscObj->id);
+  STscObj *pTscObj = acquireTscObj(*(int64_t *)pRequest->pTscObj->id);
 
   assert(pTscObj != NULL);
 
@@ -54,14 +54,14 @@ static void registerRequest(SRequestObj *pRequest) {
     int32_t currentInst = atomic_add_fetch_64((int64_t *)&pSummary->currentRequests, 1);
     tscDebug("0x%" PRIx64 " new Request from connObj:0x%" PRIx64
              ", current:%d, app current:%d, total:%d, reqId:0x%" PRIx64,
-             pRequest->self, *(int64_t*)pRequest->pTscObj->id, num, currentInst, total, pRequest->requestId);
+             pRequest->self, *(int64_t *)pRequest->pTscObj->id, num, currentInst, total, pRequest->requestId);
   }
 }
 
 static void deregisterRequest(SRequestObj *pRequest) {
   assert(pRequest != NULL);
 
-  STscObj          *pTscObj = pRequest->pTscObj;
+  STscObj *           pTscObj = pRequest->pTscObj;
   SAppClusterSummary *pActivity = &pTscObj->pAppInfo->summary;
 
   int32_t currentInst = atomic_sub_fetch_64((int64_t *)&pActivity->currentRequests, 1);
@@ -70,8 +70,8 @@ static void deregisterRequest(SRequestObj *pRequest) {
   int64_t duration = taosGetTimestampUs() - pRequest->metric.start;
   tscDebug("0x%" PRIx64 " free Request from connObj: 0x%" PRIx64 ", reqId:0x%" PRIx64 " elapsed:%" PRIu64
            " ms, current:%d, app current:%d",
-           pRequest->self, *(int64_t*)pTscObj->id, pRequest->requestId, duration / 1000, num, currentInst);
-  releaseTscObj(*(int64_t*)pTscObj->id);
+           pRequest->self, *(int64_t *)pTscObj->id, pRequest->requestId, duration / 1000, num, currentInst);
+  releaseTscObj(*(int64_t *)pTscObj->id);
 }
 
 // todo close the transporter properly
@@ -80,12 +80,13 @@ void closeTransporter(STscObj *pTscObj) {
     return;
   }
 
-  tscDebug("free transporter:%p in connObj: 0x%" PRIx64, pTscObj->pAppInfo->pTransporter, *(int64_t*)pTscObj->id);
+  tscDebug("free transporter:%p in connObj: 0x%" PRIx64, pTscObj->pAppInfo->pTransporter, *(int64_t *)pTscObj->id);
   rpcClose(pTscObj->pAppInfo->pTransporter);
 }
 
 static bool clientRpcRfp(int32_t code) {
-  if (code == TSDB_CODE_RPC_REDIRECT) {
+  if (code == TSDB_CODE_RPC_REDIRECT || code == TSDB_CODE_RPC_NETWORK_UNAVAIL || code == TSDB_CODE_NODE_NOT_DEPLOYED ||
+      code == TSDB_CODE_SYN_NOT_LEADER || code == TSDB_CODE_APP_NOT_READY) {
     return true;
   } else {
     return false;
@@ -128,16 +129,17 @@ void closeAllRequests(SHashObj *pRequests) {
 void destroyTscObj(void *pObj) {
   STscObj *pTscObj = pObj;
 
-  SClientHbKey connKey = {.tscRid = *(int64_t*)pTscObj->id, .connType = pTscObj->connType};
+  SClientHbKey connKey = {.tscRid = *(int64_t *)pTscObj->id, .connType = pTscObj->connType};
   hbDeregisterConn(pTscObj->pAppInfo->pAppHbMgr, connKey);
   int64_t connNum = atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
   closeAllRequests(pTscObj->pRequests);
   schedulerStopQueryHb(pTscObj->pAppInfo->pTransporter);
   if (0 == connNum) {
-    // TODO 
-    //closeTransporter(pTscObj);
+    // TODO
+    // closeTransporter(pTscObj);
   }
-  tscDebug("connObj 0x%" PRIx64 " destroyed, totalConn:%" PRId64, *(int64_t*)pTscObj->id, pTscObj->pAppInfo->numOfConns);
+  tscDebug("connObj 0x%" PRIx64 " destroyed, totalConn:%" PRId64, *(int64_t *)pTscObj->id,
+           pTscObj->pAppInfo->numOfConns);
   taosThreadMutexDestroy(&pTscObj->mutex);
   taosMemoryFreeClear(pTscObj);
 }
@@ -167,10 +169,10 @@ void *createTscObj(const char *user, const char *auth, const char *db, int32_t c
 
   taosThreadMutexInit(&pObj->mutex, NULL);
   pObj->id = taosMemoryMalloc(sizeof(int64_t));
-  *(int64_t*)pObj->id = taosAddRef(clientConnRefPool, pObj);
+  *(int64_t *)pObj->id = taosAddRef(clientConnRefPool, pObj);
   pObj->schemalessType = 1;
 
-  tscDebug("connObj created, 0x%" PRIx64, *(int64_t*)pObj->id);
+  tscDebug("connObj created, 0x%" PRIx64, *(int64_t *)pObj->id);
   return pObj;
 }
 
@@ -325,7 +327,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
     return 0;
   }
 
-  SConfig     *pCfg = taosGetCfg();
+  SConfig *    pCfg = taosGetCfg();
   SConfigItem *pItem = NULL;
 
   switch (option) {

source/client/src/clientImpl.c

@@ -617,12 +617,12 @@ int32_t scheduleAsyncQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNod
                            .requestId = pRequest->requestId,
                            .requestObjRefId = pRequest->self};
   SSchedulerReq    req = {.pConn = &conn,
-                          .pNodeList = pNodeList,
-                          .pDag = pDag,
-                          .sql = pRequest->sqlstr,
-                          .startTs = pRequest->metric.start,
-                          .fp = schdExecCallback,
-                          .cbParam = &res};
+                       .pNodeList = pNodeList,
+                       .pDag = pDag,
+                       .sql = pRequest->sqlstr,
+                       .startTs = pRequest->metric.start,
+                       .fp = schdExecCallback,
+                       .cbParam = &res};
 
   int32_t code = schedulerAsyncExecJob(&req, &pRequest->body.queryJob);
 
@@ -669,13 +669,13 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList
                            .requestId = pRequest->requestId,
                            .requestObjRefId = pRequest->self};
   SSchedulerReq    req = {.pConn = &conn,
-                          .pNodeList = pNodeList,
-                          .pDag = pDag,
-                          .sql = pRequest->sqlstr,
-                          .startTs = pRequest->metric.start,
-                          .fp = NULL,
-                          .cbParam = NULL,
-                          .reqKilled = &pRequest->killed};
+                       .pNodeList = pNodeList,
+                       .pDag = pDag,
+                       .sql = pRequest->sqlstr,
+                       .startTs = pRequest->metric.start,
+                       .fp = NULL,
+                       .cbParam = NULL,
+                       .reqKilled = &pRequest->killed};
 
   int32_t code = schedulerExecJob(&req, &pRequest->body.queryJob, &res);
   pRequest->body.resInfo.execRes = res.res;

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

@@ -70,9 +70,9 @@ int32_t dmProcessNodeMsg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) {
 }
 
 static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
-  SDnodeTrans  *pTrans = &pDnode->trans;
+  SDnodeTrans * pTrans = &pDnode->trans;
   int32_t       code = -1;
-  SRpcMsg      *pMsg = NULL;
+  SRpcMsg *     pMsg = NULL;
   SMgmtWrapper *pWrapper = NULL;
   SDnodeHandle *pHandle = &pTrans->msgHandles[TMSG_INDEX(pRpc->msgType)];
 
@@ -194,11 +194,11 @@ int32_t dmInitMsgHandle(SDnode *pDnode) {
 
   for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
     SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
-    SArray       *pArray = (*pWrapper->func.getHandlesFp)();
+    SArray *      pArray = (*pWrapper->func.getHandlesFp)();
     if (pArray == NULL) return -1;
 
     for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
-      SMgmtHandle  *pMgmt = taosArrayGet(pArray, i);
+      SMgmtHandle * pMgmt = taosArrayGet(pArray, i);
       SDnodeHandle *pHandle = &pTrans->msgHandles[TMSG_INDEX(pMgmt->msgType)];
       if (pMgmt->needCheckVgId) {
         pHandle->needCheckVgId = pMgmt->needCheckVgId;
@@ -248,7 +248,14 @@ static inline void dmReleaseHandle(SRpcHandleInfo *pHandle, int8_t type) {
   }
 }
 
-static bool rpcRfp(int32_t code) { return code == TSDB_CODE_RPC_REDIRECT; }
+static bool rpcRfp(int32_t code) {
+  if (code == TSDB_CODE_RPC_REDIRECT || code == TSDB_CODE_RPC_NETWORK_UNAVAIL || code == TSDB_CODE_NODE_NOT_DEPLOYED ||
+      code == TSDB_CODE_SYN_NOT_LEADER || code == TSDB_CODE_APP_NOT_READY) {
+    return true;
+  } else {
+    return false;
+  }
+}
 
 int32_t dmInitClient(SDnode *pDnode) {
   SDnodeTrans *pTrans = &pDnode->trans;

source/libs/function/src/udfd.c

@@ -12,6 +12,8 @@
  * 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/>.
  */
+
+// clang-format off
 #include "uv.h"
 #include "os.h"
 #include "fnLog.h"
@@ -25,6 +27,7 @@
 #include "tglobal.h"
 #include "tmsg.h"
 #include "trpc.h"
+// clang-foramt on
 
 typedef struct SUdfdContext {
   uv_loop_t * loop;
@@ -103,12 +106,12 @@ typedef struct SUdfdRpcSendRecvInfo {
   uv_sem_t           resultSem;
 } SUdfdRpcSendRecvInfo;
 
-static void udfdProcessRpcRsp(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet);
+static void    udfdProcessRpcRsp(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet);
 static int32_t udfdFillUdfInfoFromMNode(void *clientRpc, char *udfName, SUdf *udf);
 static int32_t udfdConnectToMnode();
 static int32_t udfdLoadUdf(char *udfName, SUdf *udf);
-static bool udfdRpcRfp(int32_t code);
-static int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet);
+static bool    udfdRpcRfp(int32_t code);
+static int     initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet);
 static int32_t udfdOpenClientRpc();
 static int32_t udfdCloseClientRpc();
 
@@ -126,19 +129,19 @@ static void udfdUvHandleError(SUdfdUvConn *conn) { uv_close((uv_handle_t *)conn-
 static void udfdPipeRead(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf);
 static void udfdOnNewConnection(uv_stream_t *server, int status);
 
-static void udfdIntrSignalHandler(uv_signal_t *handle, int signum);
+static void    udfdIntrSignalHandler(uv_signal_t *handle, int signum);
 static int32_t removeListeningPipe();
 
-static void udfdPrintVersion();
+static void    udfdPrintVersion();
 static int32_t udfdParseArgs(int32_t argc, char *argv[]);
 static int32_t udfdInitLog();
 
-static void udfdCtrlAllocBufCb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf);
-static void udfdCtrlReadCb(uv_stream_t *q, ssize_t nread, const uv_buf_t *buf);
+static void    udfdCtrlAllocBufCb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf);
+static void    udfdCtrlReadCb(uv_stream_t *q, ssize_t nread, const uv_buf_t *buf);
 static int32_t udfdUvInit();
-static void udfdCloseWalkCb(uv_handle_t *handle, void *arg);
+static void    udfdCloseWalkCb(uv_handle_t *handle, void *arg);
 static int32_t udfdRun();
-static void udfdConnectMnodeThreadFunc(void* args);
+static void    udfdConnectMnodeThreadFunc(void *args);
 
 void udfdProcessRequest(uv_work_t *req) {
   SUvUdfWork *uvUdf = (SUvUdfWork *)(req->data);
@@ -401,11 +404,11 @@ void udfdProcessRpcRsp(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) {
     udf->bufSize = pFuncInfo->bufSize;
 
     char path[PATH_MAX] = {0};
-  #ifdef WINDOWS
+#ifdef WINDOWS
     snprintf(path, sizeof(path), "%s%s.dll", TD_TMP_DIR_PATH, pFuncInfo->name);
-  #else
+#else
     snprintf(path, sizeof(path), "%s/lib%s.so", TD_TMP_DIR_PATH, pFuncInfo->name);
-  #endif
+#endif
     TdFilePtr file =
         taosOpenFile(path, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_READ | TD_FILE_TRUNC | TD_FILE_AUTO_DEL);
     if (file == NULL) {
@@ -544,7 +547,8 @@ int32_t udfdLoadUdf(char *udfName, SUdf *udf) {
   return 0;
 }
 static bool udfdRpcRfp(int32_t code) {
-  if (code == TSDB_CODE_RPC_REDIRECT) {
+  if (code == TSDB_CODE_RPC_REDIRECT || code == TSDB_CODE_RPC_NETWORK_UNAVAIL || code == TSDB_CODE_NODE_NOT_DEPLOYED ||
+      code == TSDB_CODE_SYN_NOT_LEADER || code == TSDB_CODE_APP_NOT_READY) {
     return true;
   } else {
     return false;
@@ -652,8 +656,7 @@ void udfdAllocBuffer(uv_handle_t *handle, size_t suggestedSize, uv_buf_t *buf) {
       buf->base = ctx->inputBuf;
       buf->len = ctx->inputCap;
     } else {
-      fnError("udfd can not allocate enough memory")
-      buf->base = NULL;
+      fnError("udfd can not allocate enough memory") buf->base = NULL;
       buf->len = 0;
     }
   } else {
@@ -664,8 +667,7 @@ void udfdAllocBuffer(uv_handle_t *handle, size_t suggestedSize, uv_buf_t *buf) {
       buf->base = ctx->inputBuf + ctx->inputLen;
       buf->len = ctx->inputCap - ctx->inputLen;
     } else {
-      fnError("udfd can not allocate enough memory")
-      buf->base = NULL;
+      fnError("udfd can not allocate enough memory") buf->base = NULL;
       buf->len = 0;
     }
   }
@@ -881,7 +883,7 @@ static int32_t udfdRun() {
   return 0;
 }
 
-void udfdConnectMnodeThreadFunc(void* args) {
+void udfdConnectMnodeThreadFunc(void *args) {
   int32_t retryMnodeTimes = 0;
   int32_t code = 0;
   while (retryMnodeTimes++ <= TSDB_MAX_REPLICA) {
@@ -939,7 +941,7 @@ int main(int argc, char *argv[]) {
   uv_thread_create(&mnodeConnectThread, udfdConnectMnodeThreadFunc, NULL);
 
   udfdRun();
-  
+
   removeListeningPipe();
   udfdCloseClientRpc();
 

source/libs/qcom/src/queryUtil.c

@@ -19,6 +19,7 @@
 #include "tmsg.h"
 #include "trpc.h"
 #include "tsched.h"
+// clang-format off
 #include "cJSON.h"
 
 #define VALIDNUMOFCOLS(x) ((x) >= TSDB_MIN_COLUMNS && (x) <= TSDB_MAX_COLUMNS)
@@ -147,13 +148,15 @@ int32_t asyncSendMsgToServerExt(void* pTransporter, SEpSet* epSet, int64_t* pTra
   }
 
   memcpy(pMsg, pInfo->msgInfo.pData, pInfo->msgInfo.len);
-  SRpcMsg rpcMsg = {.msgType = pInfo->msgType,
-                    .pCont = pMsg,
-                    .contLen = pInfo->msgInfo.len,
-                    .info.ahandle = (void*)pInfo,
-                    .info.handle = pInfo->msgInfo.handle,
-                    .info.persistHandle = persistHandle,
-                    .code = 0};
+  SRpcMsg rpcMsg = {
+    .msgType = pInfo->msgType,
+    .pCont = pMsg,
+    .contLen = pInfo->msgInfo.len,
+    .info.ahandle = (void*)pInfo,
+    .info.handle = pInfo->msgInfo.handle,
+    .info.persistHandle = persistHandle, 
+    .code = 0
+  };
   assert(pInfo->fp != NULL);
   TRACE_SET_ROOTID(&rpcMsg.info.traceId, pInfo->requestId);
   rpcSendRequestWithCtx(pTransporter, epSet, &rpcMsg, pTransporterId, rpcCtx);
@@ -221,8 +224,9 @@ void destroyQueryExecRes(SQueryExecRes* pRes) {
       qError("invalid exec result for request type %d", pRes->msgType);
   }
 }
+// clang-format on
 
-int32_t dataConverToStr(char *str, int type, void *buf, int32_t bufSize, int32_t *len) {
+int32_t dataConverToStr(char* str, int type, void* buf, int32_t bufSize, int32_t* len) {
   int32_t n = 0;
 
   switch (type) {
@@ -262,7 +266,7 @@ int32_t dataConverToStr(char *str, int type, void *buf, int32_t bufSize, int32_t
     case TSDB_DATA_TYPE_BINARY:
     case TSDB_DATA_TYPE_NCHAR:
       if (bufSize < 0) {
-//        tscError("invalid buf size");
+        //        tscError("invalid buf size");
         return TSDB_CODE_TSC_INVALID_VALUE;
       }
 
@@ -289,7 +293,7 @@ int32_t dataConverToStr(char *str, int type, void *buf, int32_t bufSize, int32_t
       break;
 
     default:
-//      tscError("unsupported type:%d", type);
+      //      tscError("unsupported type:%d", type);
       return TSDB_CODE_TSC_INVALID_VALUE;
   }
 
@@ -332,7 +336,7 @@ char* parseTagDatatoJson(void* p) {
         int32_t length = taosUcs4ToMbs((TdUcs4*)pTagVal->pData, pTagVal->nData, tagJsonValue);
         if (length < 0) {
           qError("charset:%s to %s. val:%s convert json value failed.", DEFAULT_UNICODE_ENCODEC, tsCharset,
-                   pTagVal->pData);
+                 pTagVal->pData);
           taosMemoryFree(tagJsonValue);
           goto end;
         }
@@ -372,7 +376,6 @@ end:
   return string;
 }
 
-
 int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst) {
   if (NULL == pSrc) {
     *pDst = NULL;
@@ -393,37 +396,36 @@ int32_t cloneDbVgInfo(SDBVgInfo* pSrc, SDBVgInfo** pDst) {
     *pDst = NULL;
     return TSDB_CODE_SUCCESS;
   }
-  
+
   *pDst = taosMemoryMalloc(sizeof(*pSrc));
   if (NULL == *pDst) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
   memcpy(*pDst, pSrc, sizeof(*pSrc));
   if (pSrc->vgHash) {
-    (*pDst)->vgHash = taosHashInit(taosHashGetSize(pSrc->vgHash), taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
+    (*pDst)->vgHash = taosHashInit(taosHashGetSize(pSrc->vgHash), taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true,
+                                   HASH_ENTRY_LOCK);
     if (NULL == (*pDst)->vgHash) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
 
     SVgroupInfo* vgInfo = NULL;
-    void *pIter = taosHashIterate(pSrc->vgHash, NULL);
+    void*        pIter = taosHashIterate(pSrc->vgHash, NULL);
     while (pIter) {
       vgInfo = pIter;
       int32_t* vgId = taosHashGetKey(pIter, NULL);
-      
+
       if (0 != taosHashPut((*pDst)->vgHash, vgId, sizeof(*vgId), vgInfo, sizeof(*vgInfo))) {
         qError("taosHashPut failed, vgId:%d", vgInfo->vgId);
-        taosHashCancelIterate(pSrc->vgHash, pIter);    
+        taosHashCancelIterate(pSrc->vgHash, pIter);
         taosHashCleanup((*pDst)->vgHash);
         taosMemoryFreeClear(*pDst);
         return TSDB_CODE_CTG_MEM_ERROR;
       }
-      
+
       pIter = taosHashIterate(pSrc->vgHash, pIter);
     }
   }
-  
+
   return TSDB_CODE_SUCCESS;
 }
-
-

source/libs/transport/inc/transComm.h

@@ -105,6 +105,13 @@ typedef SRpcCtxVal   STransCtxVal;
 typedef SRpcInfo     STrans;
 typedef SRpcConnInfo STransHandleInfo;
 
+// ref mgt
+// handle
+typedef struct SExHandle {
+  void*   handle;
+  int64_t refId;
+  void*   pThrd;
+} SExHandle;
 /*convet from fqdn to ip */
 typedef struct SCvtAddr {
   char ip[TSDB_FQDN_LEN];
@@ -113,14 +120,15 @@ typedef struct SCvtAddr {
 } SCvtAddr;
 
 typedef struct {
-  SEpSet  epSet;  // ip list provided by app
-  SEpSet  origEpSet;
-  void*   ahandle;   // handle provided by app
-  tmsg_t  msgType;   // message type
-  int8_t  connType;  // connection type cli/srv
-  int64_t rid;       // refId returned by taosAddRef
-
-  int8_t     retryCount;
+  SEpSet epSet;  // ip list provided by app
+  SEpSet origEpSet;
+  void*  ahandle;   // handle provided by app
+  tmsg_t msgType;   // message type
+  int8_t connType;  // connection type cli/srv
+
+  int8_t retryCnt;
+  int8_t retryLimit;
+  // bool       setMaxRetry;
   STransCtx  appCtx;  //
   STransMsg* pRsp;    // for synchronous API
   tsem_t*    pSem;    // for synchronous API
@@ -239,6 +247,32 @@ int         transSendAsync(SAsyncPool* pool, queue* mq);
       }                                                       \
     }                                                         \
   } while (0)
+
+#define ASYNC_CHECK_HANDLE(exh1, id)                                                                               \
+  do {                                                                                                             \
+    if (id > 0) {                                                                                                  \
+      tTrace("handle step1");                                                                                      \
+      SExHandle* exh2 = transAcquireExHandle(refMgt, id);                                                          \
+      if (exh2 == NULL || id != exh2->refId) {                                                                     \
+        tTrace("handle %p except, may already freed, ignore msg, ref1: %" PRIu64 ", ref2 : %" PRIu64 "", exh1,     \
+               exh2 ? exh2->refId : 0, id);                                                                        \
+        goto _return1;                                                                                             \
+      }                                                                                                            \
+    } else if (id == 0) {                                                                                          \
+      tTrace("handle step2");                                                                                      \
+      SExHandle* exh2 = transAcquireExHandle(refMgt, id);                                                          \
+      if (exh2 == NULL || id == exh2->refId) {                                                                     \
+        tTrace("handle %p except, may already freed, ignore msg, ref1: %" PRIu64 ", ref2 : %" PRIu64 "", exh1, id, \
+               exh2 ? exh2->refId : 0);                                                                            \
+        goto _return1;                                                                                             \
+      } else {                                                                                                     \
+        id = exh1->refId;                                                                                          \
+      }                                                                                                            \
+    } else if (id < 0) {                                                                                           \
+      tTrace("handle step3");                                                                                      \
+      goto _return2;                                                                                               \
+    }                                                                                                              \
+  } while (0)
 int  transInitBuffer(SConnBuffer* buf);
 int  transClearBuffer(SConnBuffer* buf);
 int  transDestroyBuffer(SConnBuffer* buf);
@@ -349,21 +383,13 @@ void transDQDestroy(SDelayQueue* queue);
 
 int transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg, uint64_t timeoutMs);
 
-void transPrintEpSet(SEpSet* pEpSet);
+// void transPrintEpSet(SEpSet* pEpSet);
 bool transEpSetIsEqual(SEpSet* a, SEpSet* b);
 /*
  * init global func
  */
 void transThreadOnce();
 
-// ref mgt
-// handle
-typedef struct SExHandle {
-  void*   handle;
-  int64_t refId;
-  void*   pThrd;
-} SExHandle;
-
 void       transInitEnv();
 int32_t    transOpenExHandleMgt(int size);
 void       transCloseExHandleMgt(int32_t mgt);

source/libs/transport/src/trans.c

@@ -79,6 +79,7 @@ void* rpcOpen(const SRpcInit* pInit) {
   return pRpc;
 }
 void rpcClose(void* arg) {
+  tInfo("start to close rpc");
   SRpcInfo* pRpc = (SRpcInfo*)arg;
   (*taosCloseHandle[pRpc->connType])(pRpc->tcphandle);
   transCloseExHandleMgt(pRpc->refMgt);

source/libs/transport/src/transComm.c

@@ -455,16 +455,16 @@ void transPrintEpSet(SEpSet* pEpSet) {
     return;
   }
   char buf[512] = {0};
-  int  len = snprintf(buf, sizeof(buf), "epset { ");
+  int  len = snprintf(buf, sizeof(buf), "epset:{");
   for (int i = 0; i < pEpSet->numOfEps; i++) {
     if (i == pEpSet->numOfEps - 1) {
-      len += snprintf(buf + len, sizeof(buf) - len, "%d. %s:%d ", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
+      len += snprintf(buf + len, sizeof(buf) - len, "%d. %s:%d", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
     } else {
       len += snprintf(buf + len, sizeof(buf) - len, "%d. %s:%d, ", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
     }
   }
   len += snprintf(buf + len, sizeof(buf) - len, "}");
-  tTrace("%s, inUse: %d", buf, pEpSet->inUse);
+  tTrace("%s, inUse:%d", buf, pEpSet->inUse);
 }
 bool transEpSetIsEqual(SEpSet* a, SEpSet* b) {
   if (a->numOfEps != b->numOfEps || a->inUse != b->inUse) {

source/libs/transport/src/transSvr.c

@@ -65,7 +65,7 @@ typedef struct SSvrMsg {
   STransMsgType type;
 } SSvrMsg;
 
-typedef struct SWorkThrdObj {
+typedef struct SWorkThrd {
   TdThread      thread;
   uv_connect_t  connect_req;
   uv_pipe_t*    pipe;
@@ -78,7 +78,7 @@ typedef struct SWorkThrdObj {
   queue conn;
   void* pTransInst;
   bool  quit;
-} SWorkThrdObj;
+} SWorkThrd;
 
 typedef struct SServerObj {
   TdThread   thread;
@@ -86,10 +86,10 @@ typedef struct SServerObj {
   uv_loop_t* loop;
 
   // work thread info
-  int            workerIdx;
-  int            numOfThreads;
-  int            numOfWorkerReady;
-  SWorkThrdObj** pThreadObj;
+  int         workerIdx;
+  int         numOfThreads;
+  int         numOfWorkerReady;
+  SWorkThrd** pThreadObj;
 
   uv_pipe_t   pipeListen;
   uv_pipe_t** pipe;
@@ -133,14 +133,14 @@ static SSvrConn* createConn(void* hThrd);
 static void      destroyConn(SSvrConn* conn, bool clear /*clear handle or not*/);
 static void      destroyConnRegArg(SSvrConn* conn);
 
-static int reallocConnRefHandle(SSvrConn* conn);
+static int reallocConnRef(SSvrConn* conn);
 
-static void uvHandleQuit(SSvrMsg* msg, SWorkThrdObj* thrd);
-static void uvHandleRelease(SSvrMsg* msg, SWorkThrdObj* thrd);
-static void uvHandleResp(SSvrMsg* msg, SWorkThrdObj* thrd);
-static void uvHandleRegister(SSvrMsg* msg, SWorkThrdObj* thrd);
-static void (*transAsyncHandle[])(SSvrMsg* msg, SWorkThrdObj* thrd) = {uvHandleResp, uvHandleQuit, uvHandleRelease,
-                                                                       uvHandleRegister, NULL};
+static void uvHandleQuit(SSvrMsg* msg, SWorkThrd* thrd);
+static void uvHandleRelease(SSvrMsg* msg, SWorkThrd* thrd);
+static void uvHandleResp(SSvrMsg* msg, SWorkThrd* thrd);
+static void uvHandleRegister(SSvrMsg* msg, SWorkThrd* thrd);
+static void (*transAsyncHandle[])(SSvrMsg* msg, SWorkThrd* thrd) = {uvHandleResp, uvHandleQuit, uvHandleRelease,
+                                                                    uvHandleRegister, NULL};
 
 static int32_t exHandlesMgt;
 
@@ -160,7 +160,7 @@ static void* transWorkerThread(void* arg);
 static void* transAcceptThread(void* arg);
 
 // add handle loop
-static bool addHandleToWorkloop(SWorkThrdObj* pThrd, char* pipeName);
+static bool addHandleToWorkloop(SWorkThrd* pThrd, char* pipeName);
 static bool addHandleToAcceptloop(void* arg);
 
 #define CONN_SHOULD_RELEASE(conn, head)                                               \
@@ -176,7 +176,7 @@ static bool addHandleToAcceptloop(void* arg);
       srvMsg->msg = tmsg;                                                             \
       srvMsg->type = Release;                                                         \
       srvMsg->pConn = conn;                                                           \
-      reallocConnRefHandle(conn);                                                     \
+      reallocConnRef(conn);                                                           \
       if (!transQueuePush(&conn->srvMsgs, srvMsg)) {                                  \
         return;                                                                       \
       }                                                                               \
@@ -206,32 +206,6 @@ static bool addHandleToAcceptloop(void* arg);
     }                                                   \
   } while (0)
 
-#define ASYNC_CHECK_HANDLE(exh1, refId)                                                                               \
-  do {                                                                                                                \
-    if (refId > 0) {                                                                                                  \
-      tTrace("handle step1");                                                                                         \
-      SExHandle* exh2 = transAcquireExHandle(refMgt, refId);                                                          \
-      if (exh2 == NULL || refId != exh2->refId) {                                                                     \
-        tTrace("handle %p except, may already freed, ignore msg, ref1: %" PRIu64 ", ref2 : %" PRIu64 "", exh1,        \
-               exh2 ? exh2->refId : 0, refId);                                                                        \
-        goto _return1;                                                                                                \
-      }                                                                                                               \
-    } else if (refId == 0) {                                                                                          \
-      tTrace("handle step2");                                                                                         \
-      SExHandle* exh2 = transAcquireExHandle(refMgt, refId);                                                          \
-      if (exh2 == NULL || refId != exh2->refId) {                                                                     \
-        tTrace("handle %p except, may already freed, ignore msg, ref1: %" PRIu64 ", ref2 : %" PRIu64 "", exh1, refId, \
-               exh2 ? exh2->refId : 0);                                                                               \
-        goto _return1;                                                                                                \
-      } else {                                                                                                        \
-        refId = exh1->refId;                                                                                          \
-      }                                                                                                               \
-    } else if (refId < 0) {                                                                                           \
-      tTrace("handle step3");                                                                                         \
-      goto _return2;                                                                                                  \
-    }                                                                                                                 \
-  } while (0)
-
 void uvAllocRecvBufferCb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
   SSvrConn*    conn = handle->data;
   SConnBuffer* pBuf = &conn->readBuf;
@@ -259,7 +233,7 @@ static void uvHandleReq(SSvrConn* pConn) {
   //  wreq->data = pConn;
   //  uv_read_stop((uv_stream_t*)pConn->pTcp);
   //  transRefSrvHandle(pConn);
-  //  uv_queue_work(((SWorkThrdObj*)pConn->hostThrd)->loop, wreq, uvWorkDoTask, uvWorkAfterTask);
+  //  uv_queue_work(((SWorkThrd*)pConn->hostThrd)->loop, wreq, uvWorkDoTask, uvWorkAfterTask);
 
   CONN_SHOULD_RELEASE(pConn, pHead);
 
@@ -379,7 +353,7 @@ void uvOnSendCb(uv_write_t* req, int status) {
       // if (msg->type == Release && conn->status != ConnNormal) {
       //  conn->status = ConnNormal;
       //  transUnrefSrvHandle(conn);
-      //  reallocConnRefHandle(conn);
+      //  reallocConnRef(conn);
       //  destroySmsg(msg);
       //  transQueueClear(&conn->srvMsgs);
       //  return;
@@ -448,6 +422,8 @@ static void uvPrepareSendData(SSvrMsg* smsg, uv_buf_t* wb) {
       transUnrefSrvHandle(pConn);
     } else {
       pHead->msgType = pMsg->msgType;
+      if (pHead->msgType == 0 && transMsgLenFromCont(pMsg->contLen) == sizeof(STransMsgHead))
+        pHead->msgType = pConn->inType + 1;
     }
   }
 
@@ -504,7 +480,7 @@ static void destroySmsg(SSvrMsg* smsg) {
   transFreeMsg(smsg->msg.pCont);
   taosMemoryFree(smsg);
 }
-static void destroyAllConn(SWorkThrdObj* pThrd) {
+static void destroyAllConn(SWorkThrd* pThrd) {
   tTrace("thread %p destroy all conn ", pThrd);
   while (!QUEUE_IS_EMPTY(&pThrd->conn)) {
     queue* h = QUEUE_HEAD(&pThrd->conn);
@@ -519,10 +495,10 @@ static void destroyAllConn(SWorkThrdObj* pThrd) {
   }
 }
 void uvWorkerAsyncCb(uv_async_t* handle) {
-  SAsyncItem*   item = handle->data;
-  SWorkThrdObj* pThrd = item->pThrd;
-  SSvrConn*     conn = NULL;
-  queue         wq;
+  SAsyncItem* item = handle->data;
+  SWorkThrd*  pThrd = item->pThrd;
+  SSvrConn*   conn = NULL;
+  queue       wq;
 
   // batch process to avoid to lock/unlock frequently
   taosThreadMutexLock(&item->mtx);
@@ -650,7 +626,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) {
   assert(buf->base[0] == notify[0]);
   taosMemoryFree(buf->base);
 
-  SWorkThrdObj* pThrd = q->data;
+  SWorkThrd* pThrd = q->data;
 
   uv_pipe_t* pipe = (uv_pipe_t*)q;
   if (!uv_pipe_pending_count(pipe)) {
@@ -718,10 +694,10 @@ void uvOnPipeConnectionCb(uv_connect_t* connect, int status) {
   if (status != 0) {
     return;
   }
-  SWorkThrdObj* pThrd = container_of(connect, SWorkThrdObj, connect_req);
+  SWorkThrd* pThrd = container_of(connect, SWorkThrd, connect_req);
   uv_read_start((uv_stream_t*)pThrd->pipe, uvAllocConnBufferCb, uvOnConnectionCb);
 }
-static bool addHandleToWorkloop(SWorkThrdObj* pThrd, char* pipeName) {
+static bool addHandleToWorkloop(SWorkThrd* pThrd, char* pipeName) {
   pThrd->loop = (uv_loop_t*)taosMemoryMalloc(sizeof(uv_loop_t));
   if (0 != uv_loop_init(pThrd->loop)) {
     return false;
@@ -774,14 +750,14 @@ static bool addHandleToAcceptloop(void* arg) {
 }
 void* transWorkerThread(void* arg) {
   setThreadName("trans-worker");
-  SWorkThrdObj* pThrd = (SWorkThrdObj*)arg;
+  SWorkThrd* pThrd = (SWorkThrd*)arg;
   uv_run(pThrd->loop, UV_RUN_DEFAULT);
 
   return NULL;
 }
 
 static SSvrConn* createConn(void* hThrd) {
-  SWorkThrdObj* pThrd = hThrd;
+  SWorkThrd* pThrd = hThrd;
 
   SSvrConn* pConn = (SSvrConn*)taosMemoryCalloc(1, sizeof(SSvrConn));
   QUEUE_INIT(&pConn->queue);
@@ -826,7 +802,7 @@ static void destroyConnRegArg(SSvrConn* conn) {
     conn->regArg.init = 0;
   }
 }
-static int reallocConnRefHandle(SSvrConn* conn) {
+static int reallocConnRef(SSvrConn* conn) {
   transReleaseExHandle(refMgt, conn->refId);
   transRemoveExHandle(refMgt, conn->refId);
   // avoid app continue to send msg on invalid handle
@@ -844,7 +820,7 @@ static void uvDestroyConn(uv_handle_t* handle) {
   if (conn == NULL) {
     return;
   }
-  SWorkThrdObj* thrd = conn->hostThrd;
+  SWorkThrd* thrd = conn->hostThrd;
 
   transReleaseExHandle(refMgt, conn->refId);
   transRemoveExHandle(refMgt, conn->refId);
@@ -889,7 +865,7 @@ void* transInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads,
   srv->numOfThreads = numOfThreads;
   srv->workerIdx = 0;
   srv->numOfWorkerReady = 0;
-  srv->pThreadObj = (SWorkThrdObj**)taosMemoryCalloc(srv->numOfThreads, sizeof(SWorkThrdObj*));
+  srv->pThreadObj = (SWorkThrd**)taosMemoryCalloc(srv->numOfThreads, sizeof(SWorkThrd*));
   srv->pipe = (uv_pipe_t**)taosMemoryCalloc(srv->numOfThreads, sizeof(uv_pipe_t*));
   srv->ip = ip;
   srv->port = port;
@@ -914,7 +890,7 @@ void* transInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads,
   assert(0 == uv_listen((uv_stream_t*)&srv->pipeListen, SOMAXCONN, uvPipeListenCb));
 
   for (int i = 0; i < srv->numOfThreads; i++) {
-    SWorkThrdObj* thrd = (SWorkThrdObj*)taosMemoryCalloc(1, sizeof(SWorkThrdObj));
+    SWorkThrd* thrd = (SWorkThrd*)taosMemoryCalloc(1, sizeof(SWorkThrd));
     thrd->pTransInst = shandle;
     thrd->quit = false;
     srv->pThreadObj[i] = thrd;
@@ -959,7 +935,7 @@ End:
   return NULL;
 }
 
-void uvHandleQuit(SSvrMsg* msg, SWorkThrdObj* thrd) {
+void uvHandleQuit(SSvrMsg* msg, SWorkThrd* thrd) {
   thrd->quit = true;
   if (QUEUE_IS_EMPTY(&thrd->conn)) {
     uv_walk(thrd->loop, uvWalkCb, NULL);
@@ -968,10 +944,10 @@ void uvHandleQuit(SSvrMsg* msg, SWorkThrdObj* thrd) {
   }
   taosMemoryFree(msg);
 }
-void uvHandleRelease(SSvrMsg* msg, SWorkThrdObj* thrd) {
+void uvHandleRelease(SSvrMsg* msg, SWorkThrd* thrd) {
   SSvrConn* conn = msg->pConn;
   if (conn->status == ConnAcquire) {
-    reallocConnRefHandle(conn);
+    reallocConnRef(conn);
     if (!transQueuePush(&conn->srvMsgs, msg)) {
       return;
     }
@@ -982,12 +958,12 @@ void uvHandleRelease(SSvrMsg* msg, SWorkThrdObj* thrd) {
   }
   destroySmsg(msg);
 }
-void uvHandleResp(SSvrMsg* msg, SWorkThrdObj* thrd) {
+void uvHandleResp(SSvrMsg* msg, SWorkThrd* thrd) {
   // send msg to client
   tDebug("%s conn %p start to send resp (2/2)", transLabel(thrd->pTransInst), msg->pConn);
   uvStartSendResp(msg);
 }
-void uvHandleRegister(SSvrMsg* msg, SWorkThrdObj* thrd) {
+void uvHandleRegister(SSvrMsg* msg, SWorkThrd* thrd) {
   SSvrConn* conn = msg->pConn;
   tDebug("%s conn %p register brokenlink callback", transLabel(thrd->pTransInst), conn);
   if (conn->status == ConnAcquire) {
@@ -1008,7 +984,7 @@ void uvHandleRegister(SSvrMsg* msg, SWorkThrdObj* thrd) {
     taosMemoryFree(msg);
   }
 }
-void destroyWorkThrd(SWorkThrdObj* pThrd) {
+void destroyWorkThrd(SWorkThrd* pThrd) {
   if (pThrd == NULL) {
     return;
   }
@@ -1019,7 +995,7 @@ void destroyWorkThrd(SWorkThrdObj* pThrd) {
   taosMemoryFree(pThrd->loop);
   taosMemoryFree(pThrd);
 }
-void sendQuitToWorkThrd(SWorkThrdObj* pThrd) {
+void sendQuitToWorkThrd(SWorkThrd* pThrd) {
   SSvrMsg* msg = taosMemoryCalloc(1, sizeof(SSvrMsg));
   msg->type = Quit;
   tDebug("server send quit msg to work thread");
@@ -1055,8 +1031,6 @@ void transCloseServer(void* arg) {
 
   int ref = atomic_sub_fetch_32(&tranSSvrInst, 1);
   if (ref == 0) {
-    // TdThreadOnce tmpInit = PTHREAD_ONCE_INIT;
-    // memcpy(&transModuleInit, &tmpInit, sizeof(TdThreadOnce));
     transCloseExHandleMgt(refMgt);
   }
 }
@@ -1086,7 +1060,7 @@ void transReleaseSrvHandle(void* handle) {
 
   ASYNC_CHECK_HANDLE(exh, refId);
 
-  SWorkThrdObj* pThrd = exh->pThrd;
+  SWorkThrd* pThrd = exh->pThrd;
   ASYNC_ERR_JRET(pThrd);
 
   STransMsg tmsg = {.code = 0, .info.handle = exh, .info.ahandle = NULL, .info.refId = refId};
@@ -1116,7 +1090,7 @@ void transSendResponse(const STransMsg* msg) {
   STransMsg tmsg = *msg;
   tmsg.info.refId = refId;
 
-  SWorkThrdObj* pThrd = exh->pThrd;
+  SWorkThrd* pThrd = exh->pThrd;
   ASYNC_ERR_JRET(pThrd);
 
   SSvrMsg* m = taosMemoryCalloc(1, sizeof(SSvrMsg));
@@ -1146,7 +1120,7 @@ void transRegisterMsg(const STransMsg* msg) {
   STransMsg tmsg = *msg;
   tmsg.info.refId = refId;
 
-  SWorkThrdObj* pThrd = exh->pThrd;
+  SWorkThrd* pThrd = exh->pThrd;
   ASYNC_ERR_JRET(pThrd);
 
   SSvrMsg* m = taosMemoryCalloc(1, sizeof(SSvrMsg));

source/os/src/osSocket.c

@@ -946,7 +946,7 @@ int32_t taosGetFqdn(char *fqdn) {
 #endif  // __APPLE__
   int32_t ret = getaddrinfo(hostname, NULL, &hints, &result);
   if (!result) {
-    fprintf(stderr,"failed to get fqdn, code:%d, reason:%s", ret, gai_strerror(ret));
+    fprintf(stderr, "failed to get fqdn, code:%d, reason:%s", ret, gai_strerror(ret));
     return -1;
   }
 
@@ -1073,7 +1073,7 @@ int32_t taosCloseEpoll(TdEpollPtr *ppEpoll) {
  * Set TCP connection timeout per-socket level.
  * ref [https://github.com/libuv/help/issues/54]
  */
-int taosCreateSocketWithTimeOutOpt(uint32_t conn_timeout_sec) {
+int32_t taosCreateSocketWithTimeout(uint32_t timeout) {
 #if defined(WINDOWS)
   SOCKET fd;
 #else
@@ -1083,11 +1083,11 @@ int taosCreateSocketWithTimeOutOpt(uint32_t conn_timeout_sec) {
     return -1;
   }
 #if defined(WINDOWS)
-  if (0 != setsockopt(fd, IPPROTO_TCP, TCP_MAXRT, (char *)&conn_timeout_sec, sizeof(conn_timeout_sec))) {
+  if (0 != setsockopt(fd, IPPROTO_TCP, TCP_MAXRT, (char *)&timeout, sizeof(timeout))) {
     return -1;
   }
 #else  // Linux like systems
-  uint32_t conn_timeout_ms = conn_timeout_sec * 1000;
+  uint32_t conn_timeout_ms = timeout * 1000;
   if (0 != setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, (char *)&conn_timeout_ms, sizeof(conn_timeout_ms))) {
     return -1;
   }