add libuv

cmake/libuv_CMakeLists.txt.in

@@ -4,7 +4,7 @@ ExternalProject_Add(libuv
         GIT_REPOSITORY https://github.com/libuv/libuv.git
         GIT_TAG v1.42.0
         SOURCE_DIR "${CMAKE_CONTRIB_DIR}/libuv"
-        BINARY_DIR ""
+        BINARY_DIR "${CMAKE_CONTRIB_DIR}/libuv"
         CONFIGURE_COMMAND "" 
         BUILD_COMMAND ""  
         INSTALL_COMMAND ""

source/libs/transport/CMakeLists.txt

@@ -13,3 +13,18 @@ target_link_libraries(
     PUBLIC util
     PUBLIC common
 )
+if (${BUILD_WITH_UV}) 
+  target_include_directories(
+    transport    
+    PUBLIC "${CMAKE_SOURCE_DIR}/contrib/libuv/include"
+  )
+
+#LINK_DIRECTORIES("${CMAKE_SOURCE_DIR}/debug/contrib/libuv")
+  target_link_libraries(
+    transport    
+    PUBLIC uv_a
+  )
+  add_definitions(-DUSE_UV) 
+endif(${BUILD_WITH_UV})  
+
+  

source/libs/transport/inc/rpcCache.h

@@ -16,6 +16,8 @@
 #ifndef TDENGINE_RPC_CACHE_H
 #define TDENGINE_RPC_CACHE_H
 
+#include <stdint.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif

source/libs/transport/inc/rpcHead.h

@@ -16,33 +16,38 @@
 #ifndef TDENGINE_RPCHEAD_H
 #define TDENGINE_RPCHEAD_H
 
+#include <tdef.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#ifdef USE_UV
+
+#else
+
 #define RPC_CONN_TCP 2
 
 extern int tsRpcOverhead;
 
 typedef struct {
-  void    *msg;
+  void*    msg;
   int      msgLen;
   uint32_t ip;
   uint16_t port;
   int      connType;
-  void    *shandle;
-  void    *thandle;
-  void    *chandle;
+  void*    shandle;
+  void*    thandle;
+  void*    chandle;
 } SRecvInfo;
 
 #pragma pack(push, 1)
 
 typedef struct {
-  char     version:4; // RPC version
-  char     comp:4;    // compression algorithm, 0:no compression 1:lz4
-  char     resflag:2; // reserved bits
-  char     spi:3;     // security parameter index
-  char     encrypt:3; // encrypt algorithm, 0: no encryption
+  char     version : 4;         // RPC version
+  char     comp : 4;            // compression algorithm, 0:no compression 1:lz4
+  char     resflag : 2;         // reserved bits
+  char     spi : 3;             // security parameter index
+  char     encrypt : 3;         // encrypt algorithm, 0: no encryption
   uint16_t tranId;              // transcation ID
   uint32_t linkUid;             // for unique connection ID assigned by client
   uint64_t ahandle;             // ahandle assigned by client
@@ -70,11 +75,10 @@ typedef struct {
 } SRpcDigest;
 
 #pragma pack(pop)
-
+#endif
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif  // TDENGINE_RPCHEAD_H
-

source/libs/transport/inc/rpcTcp.h

@@ -15,11 +15,14 @@
 
 #ifndef _rpc_tcp_header_
 #define _rpc_tcp_header_
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#ifdef USE_UV
+#else
 void *taosInitTcpServer(uint32_t ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle);
 void  taosStopTcpServer(void *param);
 void  taosCleanUpTcpServer(void *param);
@@ -32,6 +35,8 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uin
 void taosCloseTcpConnection(void *chandle);
 int  taosSendTcpData(uint32_t ip, uint16_t port, void *data, int len, void *chandle);
 
+#endif
+
 #ifdef __cplusplus
 }
 #endif

source/libs/transport/inc/transportInt.h

@@ -20,6 +20,11 @@
 extern "C" {
 #endif
 
+#ifdef USE_UV
+
+#else
+
+#endif
 #ifdef __cplusplus
 }
 #endif

source/libs/transport/src/rpcCache.c

@@ -13,27 +13,30 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "rpcCache.h"
 #include "os.h"
+#include "rpcLog.h"
 #include "taosdef.h"
 #include "tglobal.h"
 #include "tmempool.h"
 #include "ttimer.h"
 #include "tutil.h"
-#include "rpcLog.h"
-#include "rpcCache.h"
 
+#ifdef USE_UV
+
+#else
 typedef struct SConnHash {
   char              fqdn[TSDB_FQDN_LEN];
   uint16_t          port;
   char              connType;
   struct SConnHash *prev;
   struct SConnHash *next;
-  void             *data;
+  void *            data;
   uint64_t          time;
 } SConnHash;
 
 typedef struct {
-  SConnHash     **connHashList;
+  SConnHash **    connHashList;
   mpool_h         connHashMemPool;
   int             maxSessions;
   int             total;
@@ -41,8 +44,8 @@ typedef struct {
   int64_t         keepTimer;
   pthread_mutex_t mutex;
   void (*cleanFp)(void *);
-  void           *tmrCtrl;
-  void           *pTimer;
+  void *   tmrCtrl;
+  void *   pTimer;
   int64_t *lockedBy;
 } SConnCache;
 
@@ -134,7 +137,7 @@ void rpcAddConnIntoCache(void *handle, void *data, char *fqdn, uint16_t port, in
   pNode->prev = NULL;
   pNode->time = time;
 
-  rpcLockCache(pCache->lockedBy+hash);
+  rpcLockCache(pCache->lockedBy + hash);
 
   pNode->next = pCache->connHashList[hash];
   if (pCache->connHashList[hash] != NULL) (pCache->connHashList[hash])->prev = pNode;
@@ -143,10 +146,11 @@ void rpcAddConnIntoCache(void *handle, void *data, char *fqdn, uint16_t port, in
   pCache->count[hash]++;
   rpcRemoveExpiredNodes(pCache, pNode->next, hash, time);
 
-  rpcUnlockCache(pCache->lockedBy+hash);
+  rpcUnlockCache(pCache->lockedBy + hash);
 
   pCache->total++;
-  // tTrace("%p %s:%hu:%d:%d:%p added into cache, connections:%d", data, fqdn, port, connType, hash, pNode, pCache->count[hash]);
+  // tTrace("%p %s:%hu:%d:%d:%p added into cache, connections:%d", data, fqdn, port, connType, hash, pNode,
+  // pCache->count[hash]);
 
   return;
 }
@@ -163,7 +167,7 @@ void *rpcGetConnFromCache(void *handle, char *fqdn, uint16_t port, int8_t connTy
   uint64_t time = taosGetTimestampMs();
 
   hash = rpcHashConn(pCache, fqdn, port, connType);
-  rpcLockCache(pCache->lockedBy+hash);
+  rpcLockCache(pCache->lockedBy + hash);
 
   pNode = pCache->connHashList[hash];
   while (pNode) {
@@ -197,12 +201,14 @@ void *rpcGetConnFromCache(void *handle, char *fqdn, uint16_t port, int8_t connTy
     pCache->count[hash]--;
   }
 
-  rpcUnlockCache(pCache->lockedBy+hash);
+  rpcUnlockCache(pCache->lockedBy + hash);
 
   if (pData) {
-    //tTrace("%p %s:%hu:%d:%d:%p retrieved from cache, connections:%d", pData, fqdn, port, connType, hash, pNode, pCache->count[hash]);
+    // tTrace("%p %s:%hu:%d:%d:%p retrieved from cache, connections:%d", pData, fqdn, port, connType, hash, pNode,
+    // pCache->count[hash]);
   } else {
-    //tTrace("%s:%hu:%d:%d failed to retrieve conn from cache, connections:%d", fqdn, port, connType, hash, pCache->count[hash]);
+    // tTrace("%s:%hu:%d:%d failed to retrieve conn from cache, connections:%d", fqdn, port, connType, hash,
+    // pCache->count[hash]);
   }
 
   return pData;
@@ -221,10 +227,10 @@ static void rpcCleanConnCache(void *handle, void *tmrId) {
   uint64_t time = taosGetTimestampMs();
 
   for (hash = 0; hash < pCache->maxSessions; ++hash) {
-    rpcLockCache(pCache->lockedBy+hash);
+    rpcLockCache(pCache->lockedBy + hash);
     pNode = pCache->connHashList[hash];
     rpcRemoveExpiredNodes(pCache, pNode, hash, time);
-    rpcUnlockCache(pCache->lockedBy+hash);
+    rpcUnlockCache(pCache->lockedBy + hash);
   }
 
   // tTrace("timer, total connections in cache:%d", pCache->total);
@@ -233,7 +239,7 @@ static void rpcCleanConnCache(void *handle, void *tmrId) {
 }
 
 static void rpcRemoveExpiredNodes(SConnCache *pCache, SConnHash *pNode, int hash, uint64_t time) {
-  if (pNode == NULL || (time < pCache->keepTimer + pNode->time) ) return;
+  if (pNode == NULL || (time < pCache->keepTimer + pNode->time)) return;
 
   SConnHash *pPrev = pNode->prev, *pNext;
 
@@ -242,7 +248,8 @@ static void rpcRemoveExpiredNodes(SConnCache *pCache, SConnHash *pNode, int hash
     pNext = pNode->next;
     pCache->total--;
     pCache->count[hash]--;
-    //tTrace("%p %s:%hu:%d:%d:%p removed from cache, connections:%d", pNode->data, pNode->fqdn, pNode->port, pNode->connType, hash, pNode,
+    // tTrace("%p %s:%hu:%d:%d:%p removed from cache, connections:%d", pNode->data, pNode->fqdn, pNode->port,
+    // pNode->connType, hash, pNode,
     //         pCache->count[hash]);
     taosMemPoolFree(pCache->connHashMemPool, (char *)pNode);
     pNode = pNext;
@@ -257,7 +264,7 @@ static void rpcRemoveExpiredNodes(SConnCache *pCache, SConnHash *pNode, int hash
 static int rpcHashConn(void *handle, char *fqdn, uint16_t port, int8_t connType) {
   SConnCache *pCache = (SConnCache *)handle;
   int         hash = 0;
-  char       *temp = fqdn;
+  char *      temp = fqdn;
 
   while (*temp) {
     hash += *temp;
@@ -288,4 +295,4 @@ static void rpcUnlockCache(int64_t *lockedBy) {
     assert(false);
   }
 }
-
+#endif

source/libs/transport/src/rpcTcp.c

@@ -13,24 +13,28 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "rpcTcp.h"
+#include <uv.h>
 #include "os.h"
-#include "tutil.h"
+#include "rpcHead.h"
+#include "rpcLog.h"
 #include "taosdef.h"
 #include "taoserror.h"
-#include "rpcLog.h"
-#include "rpcHead.h"
-#include "rpcTcp.h"
+#include "tutil.h"
+
+#ifdef USE_UV
 
+#else
 typedef struct SFdObj {
-  void              *signature;
+  void *             signature;
   SOCKET             fd;       // TCP socket FD
-  void              *thandle;     // handle from upper layer, like TAOS
+  void *             thandle;  // handle from upper layer, like TAOS
   uint32_t           ip;
   uint16_t           port;
   int16_t            closedByApp;  // 1: already closed by App
   struct SThreadObj *pThreadObj;
-  struct SFdObj     *prev;
-  struct SFdObj     *next;
+  struct SFdObj *    prev;
+  struct SFdObj *    next;
 } SFdObj;
 
 typedef struct SThreadObj {
@@ -43,7 +47,7 @@ typedef struct SThreadObj {
   int             numOfFds;
   int             threadId;
   char            label[TSDB_LABEL_LEN];
-  void           *shandle;  // handle passed by upper layer during server initialization
+  void *          shandle;  // handle passed by upper layer during server initialization
   void *(*processData)(SRecvInfo *pPacket);
 } SThreadObj;
 
@@ -67,11 +71,11 @@ typedef struct {
   pthread_t    thread;
 } SServerObj;
 
-static void   *taosProcessTcpData(void *param);
+static void *  taosProcessTcpData(void *param);
 static SFdObj *taosMallocFdObj(SThreadObj *pThreadObj, SOCKET fd);
 static void    taosFreeFdObj(SFdObj *pFdObj);
 static void    taosReportBrokenLink(SFdObj *pFdObj);
-static void   *taosAcceptTcpConnection(void *arg);
+static void *  taosAcceptTcpConnection(void *arg);
 
 void *taosInitTcpServer(uint32_t ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle) {
   SServerObj *pServerObj;
@@ -110,7 +114,7 @@ void *taosInitTcpServer(uint32_t ip, uint16_t port, char *label, int numOfThread
     if (pThreadObj == NULL) {
       tError("TCP:%s no enough memory", label);
       terrno = TAOS_SYSTEM_ERROR(errno);
-      for (int j=0; j<i; ++j) free(pServerObj->pThreadObj[j]);
+      for (int j = 0; j < i; ++j) free(pServerObj->pThreadObj[j]);
       free(pServerObj->pThreadObj);
       free(pServerObj);
       return NULL;
@@ -172,8 +176,10 @@ void *taosInitTcpServer(uint32_t ip, uint16_t port, char *label, int numOfThread
   return (void *)pServerObj;
 }
 
-static void taosStopTcpThread(SThreadObj* pThreadObj) {
-  if (pThreadObj == NULL)  { return;}
+static void taosStopTcpThread(SThreadObj *pThreadObj) {
+  if (pThreadObj == NULL) {
+    return;
+  }
   // save thread into local variable and signal thread to stop
   pthread_t thread = pThreadObj->thread;
   if (!taosCheckPthreadValid(thread)) {
@@ -227,8 +233,8 @@ static void *taosAcceptTcpConnection(void *arg) {
   SOCKET             connFd = -1;
   struct sockaddr_in caddr;
   int                threadId = 0;
-  SThreadObj        *pThreadObj;
-  SServerObj        *pServerObj;
+  SThreadObj *       pThreadObj;
+  SServerObj *       pServerObj;
 
   pServerObj = (SServerObj *)arg;
   tDebug("%s TCP server is ready, ip:0x%x:%hu", pServerObj->label, pServerObj->ip, pServerObj->port);
@@ -253,7 +259,7 @@ static void *taosAcceptTcpConnection(void *arg) {
     }
 
     taosKeepTcpAlive(connFd);
-    struct timeval to={5, 0};
+    struct timeval to = {5, 0};
     int32_t        ret = taosSetSockOpt(connFd, SOL_SOCKET, SO_RCVTIMEO, &to, sizeof(to));
     if (ret != 0) {
       taosCloseSocket(connFd);
@@ -262,7 +268,6 @@ static void *taosAcceptTcpConnection(void *arg) {
       continue;
     }
 
-
     // pick up the thread to handle this connection
     pThreadObj = pServerObj->pThreadObj[threadId];
 
@@ -297,7 +302,7 @@ void *taosInitTcpClient(uint32_t ip, uint16_t port, char *label, int numOfThread
 
   tstrncpy(pClientObj->label, label, sizeof(pClientObj->label));
   pClientObj->numOfThreads = numOfThreads;
-  pClientObj->pThreadObj = (SThreadObj **)calloc(numOfThreads, sizeof(SThreadObj*));
+  pClientObj->pThreadObj = (SThreadObj **)calloc(numOfThreads, sizeof(SThreadObj *));
   if (pClientObj->pThreadObj == NULL) {
     tError("TCP:%s no enough memory", label);
     tfree(pClientObj);
@@ -314,7 +319,7 @@ void *taosInitTcpClient(uint32_t ip, uint16_t port, char *label, int numOfThread
     if (pThreadObj == NULL) {
       tError("TCP:%s no enough memory", label);
       terrno = TAOS_SYSTEM_ERROR(errno);
-      for (int j=0; j<i; ++j) free(pClientObj->pThreadObj[j]);
+      for (int j = 0; j < i; ++j) free(pClientObj->pThreadObj[j]);
       free(pClientObj);
       pthread_attr_destroy(&thattr);
       return NULL;
@@ -364,14 +369,14 @@ void taosStopTcpClient(void *chandle) {
 
   if (pClientObj == NULL) return;
 
-  tDebug ("%s TCP client is stopped", pClientObj->label);
+  tDebug("%s TCP client is stopped", pClientObj->label);
 }
 
 void taosCleanUpTcpClient(void *chandle) {
   SClientObj *pClientObj = chandle;
   if (pClientObj == NULL) return;
   for (int i = 0; i < pClientObj->numOfThreads; ++i) {
-    SThreadObj *pThreadObj= pClientObj->pThreadObj[i];
+    SThreadObj *pThreadObj = pClientObj->pThreadObj[i];
     taosStopTcpThread(pThreadObj);
   }
 
@@ -381,7 +386,7 @@ void taosCleanUpTcpClient(void *chandle) {
 }
 
 void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uint16_t port) {
-  SClientObj *    pClientObj = shandle;
+  SClientObj *pClientObj = shandle;
   int32_t     index = atomic_load_32(&pClientObj->index) % pClientObj->numOfThreads;
   atomic_store_32(&pClientObj->index, index + 1);
   SThreadObj *pThreadObj = pClientObj->pThreadObj[index];
@@ -396,8 +401,7 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uin
   struct sockaddr_in sin;
   uint16_t           localPort = 0;
   unsigned int       addrlen = sizeof(sin);
-  if (getsockname(fd, (struct sockaddr *)&sin, &addrlen) == 0 &&
-      sin.sin_family == AF_INET && addrlen == sizeof(sin)) {
+  if (getsockname(fd, (struct sockaddr *)&sin, &addrlen) == 0 && sin.sin_family == AF_INET && addrlen == sizeof(sin)) {
     localPort = (uint16_t)ntohs(sin.sin_port);
   }
 
@@ -407,8 +411,8 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uin
     pFdObj->thandle = thandle;
     pFdObj->port = port;
     pFdObj->ip = ip;
-    tDebug("%s %p TCP connection to 0x%x:%hu is created, localPort:%hu FD:%p numOfFds:%d",
-            pThreadObj->label, thandle, ip, port, localPort, pFdObj, pThreadObj->numOfFds);
+    tDebug("%s %p TCP connection to 0x%x:%hu is created, localPort:%hu FD:%p numOfFds:%d", pThreadObj->label, thandle,
+           ip, port, localPort, pFdObj, pThreadObj->numOfFds);
   } else {
     tError("%s failed to malloc client FdObj(%s)", pThreadObj->label, strerror(errno));
     taosCloseSocket(fd);
@@ -441,7 +445,6 @@ int taosSendTcpData(uint32_t ip, uint16_t port, void *data, int len, void *chand
 }
 
 static void taosReportBrokenLink(SFdObj *pFdObj) {
-
   SThreadObj *pThreadObj = pFdObj->pThreadObj;
 
   // notify the upper layer, so it will clean the associated context
@@ -466,7 +469,7 @@ static void taosReportBrokenLink(SFdObj *pFdObj) {
 static int taosReadTcpData(SFdObj *pFdObj, SRecvInfo *pInfo) {
   SRpcHead rpcHead;
   int32_t  msgLen, leftLen, retLen, headLen;
-  char       *buffer, *msg;
+  char *   buffer, *msg;
 
   SThreadObj *pThreadObj = pFdObj->pThreadObj;
 
@@ -483,7 +486,8 @@ static int taosReadTcpData(SFdObj *pFdObj, SRecvInfo *pInfo) {
     tError("%s %p TCP malloc(size:%d) fail", pThreadObj->label, pFdObj->thandle, msgLen);
     return -1;
   } else {
-    tTrace("%s %p read data, FD:%p fd:%d TCP malloc mem:%p", pThreadObj->label, pFdObj->thandle, pFdObj, pFdObj->fd, buffer);
+    tTrace("%s %p read data, FD:%p fd:%d TCP malloc mem:%p", pThreadObj->label, pFdObj->thandle, pFdObj, pFdObj->fd,
+           buffer);
   }
 
   msg = buffer + tsRpcOverhead;
@@ -491,8 +495,7 @@ static int taosReadTcpData(SFdObj *pFdObj, SRecvInfo *pInfo) {
   retLen = taosReadMsg(pFdObj->fd, msg + headLen, leftLen);
 
   if (leftLen != retLen) {
-    tError("%s %p read error, leftLen:%d retLen:%d FD:%p",
-            pThreadObj->label, pFdObj->thandle, leftLen, retLen, pFdObj);
+    tError("%s %p read error, leftLen:%d retLen:%d FD:%p", pThreadObj->label, pFdObj->thandle, leftLen, retLen, pFdObj);
     free(buffer);
     return -1;
   }
@@ -519,8 +522,8 @@ static int taosReadTcpData(SFdObj *pFdObj, SRecvInfo *pInfo) {
 #define maxEvents 10
 
 static void *taosProcessTcpData(void *param) {
-  SThreadObj        *pThreadObj = param;
-  SFdObj            *pFdObj;
+  SThreadObj *       pThreadObj = param;
+  SFdObj *           pFdObj;
   struct epoll_event events[maxEvents];
   SRecvInfo          recvInfo;
 
@@ -569,7 +572,7 @@ static void *taosProcessTcpData(void *param) {
     if (pThreadObj->stop) break;
   }
 
-  if (pThreadObj->pollFd >=0) {
+  if (pThreadObj->pollFd >= 0) {
     EpollClose(pThreadObj->pollFd);
     pThreadObj->pollFd = -1;
   }
@@ -620,7 +623,6 @@ static SFdObj *taosMallocFdObj(SThreadObj *pThreadObj, SOCKET fd) {
 }
 
 static void taosFreeFdObj(SFdObj *pFdObj) {
-
   if (pFdObj == NULL) return;
   if (pFdObj->signature != pFdObj) return;
 
@@ -638,8 +640,8 @@ static void taosFreeFdObj(SFdObj *pFdObj) {
 
   pThreadObj->numOfFds--;
   if (pThreadObj->numOfFds < 0)
-    tError("%s %p TCP thread:%d, number of FDs is negative!!!",
-            pThreadObj->label, pFdObj->thandle, pThreadObj->threadId);
+    tError("%s %p TCP thread:%d, number of FDs is negative!!!", pThreadObj->label, pFdObj->thandle,
+           pThreadObj->threadId);
 
   if (pFdObj->prev) {
     (pFdObj->prev)->next = pFdObj->next;
@@ -653,8 +655,10 @@ static void taosFreeFdObj(SFdObj *pFdObj) {
 
   pthread_mutex_unlock(&pThreadObj->mutex);
 
-  tDebug("%s %p TCP connection is closed, FD:%p fd:%d numOfFds:%d",
-          pThreadObj->label, pFdObj->thandle, pFdObj, pFdObj->fd, pThreadObj->numOfFds);
+  tDebug("%s %p TCP connection is closed, FD:%p fd:%d numOfFds:%d", pThreadObj->label, pFdObj->thandle, pFdObj,
+         pFdObj->fd, pThreadObj->numOfFds);
 
   tfree(pFdObj);
 }
+
+#endif

source/libs/transport/src/rpcUdp.c

@@ -13,15 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "rpcUdp.h"
 #include "os.h"
-#include "ttimer.h"
-#include "tutil.h"
+#include "rpcHead.h"
+#include "rpcLog.h"
 #include "taosdef.h"
 #include "taoserror.h"
-#include "rpcLog.h"
-#include "rpcUdp.h"
-#include "rpcHead.h"
+#include "ttimer.h"
+#include "tutil.h"
 
+#ifdef USE_UV
+// no support upd currently
+#else
 #define RPC_MAX_UDP_CONNS 256
 #define RPC_MAX_UDP_PKTS 1000
 #define RPC_UDP_BUF_TIME 5  // mseconds
@@ -34,9 +37,9 @@ typedef struct {
   uint16_t  localPort;              // local port
   char      label[TSDB_LABEL_LEN];  // copy from udpConnSet;
   pthread_t thread;
-  void           *hash;
-  void           *shandle;  // handle passed by upper layer during server initialization
-  void           *pSet;
+  void *    hash;
+  void *    shandle;  // handle passed by upper layer during server initialization
+  void *    pSet;
   void *(*processData)(SRecvInfo *pRecv);
   char *buffer;  // buffer to receive data
 } SUdpConn;
@@ -46,7 +49,7 @@ typedef struct {
   int      server;
   uint32_t ip;       // local IP
   uint16_t port;     // local Port
-  void     *shandle;  // handle passed by upper layer during server initialization
+  void *   shandle;  // handle passed by upper layer during server initialization
   int      threads;
   char     label[TSDB_LABEL_LEN];
   void *(*fp)(SRecvInfo *pPacket);
@@ -56,7 +59,7 @@ typedef struct {
 static void *taosRecvUdpData(void *param);
 
 void *taosInitUdpConnection(uint32_t ip, uint16_t port, char *label, int threads, void *fp, void *shandle) {
-  SUdpConn    *pConn;
+  SUdpConn *   pConn;
   SUdpConnSet *pSet;
 
   int size = (int)sizeof(SUdpConnSet) + threads * (int)sizeof(SUdpConn);
@@ -98,8 +101,8 @@ void *taosInitUdpConnection(uint32_t ip, uint16_t port, char *label, int threads
 
     struct sockaddr_in sin;
     unsigned int       addrlen = sizeof(sin);
-    if (getsockname(pConn->fd, (struct sockaddr *)&sin, &addrlen) == 0 && 
-        sin.sin_family == AF_INET && addrlen == sizeof(sin)) {
+    if (getsockname(pConn->fd, (struct sockaddr *)&sin, &addrlen) == 0 && sin.sin_family == AF_INET &&
+        addrlen == sizeof(sin)) {
       pConn->localPort = (uint16_t)ntohs(sin.sin_port);
     }
 
@@ -130,14 +133,14 @@ void *taosInitUdpConnection(uint32_t ip, uint16_t port, char *label, int threads
 
 void taosStopUdpConnection(void *handle) {
   SUdpConnSet *pSet = (SUdpConnSet *)handle;
-  SUdpConn    *pConn;
+  SUdpConn *   pConn;
 
   if (pSet == NULL) return;
 
   for (int i = 0; i < pSet->threads; ++i) {
     pConn = pSet->udpConn + i;
-    if (pConn->fd >=0) shutdown(pConn->fd, SHUT_RDWR);
-    if (pConn->fd >=0) taosCloseSocket(pConn->fd);
+    if (pConn->fd >= 0) shutdown(pConn->fd, SHUT_RDWR);
+    if (pConn->fd >= 0) taosCloseSocket(pConn->fd);
     pConn->fd = -1;
   }
 
@@ -155,13 +158,13 @@ void taosStopUdpConnection(void *handle) {
 
 void taosCleanUpUdpConnection(void *handle) {
   SUdpConnSet *pSet = (SUdpConnSet *)handle;
-  SUdpConn    *pConn;
+  SUdpConn *   pConn;
 
   if (pSet == NULL) return;
 
   for (int i = 0; i < pSet->threads; ++i) {
     pConn = pSet->udpConn + i;
-    if (pConn->fd >=0) taosCloseSocket(pConn->fd);
+    if (pConn->fd >= 0) taosCloseSocket(pConn->fd);
   }
 
   tDebug("%s UDP is cleaned up", pSet->label);
@@ -182,7 +185,7 @@ void *taosOpenUdpConnection(void *shandle, void *thandle, uint32_t ip, uint16_t
 }
 
 static void *taosRecvUdpData(void *param) {
-  SUdpConn          *pConn = param;
+  SUdpConn *         pConn = param;
   struct sockaddr_in sourceAdd;
   ssize_t            dataLen;
   unsigned int       addLen;
@@ -218,7 +221,7 @@ static void *taosRecvUdpData(void *param) {
     }
 
     int32_t size = dataLen + tsRpcOverhead;
-    char *tmsg = malloc(size);
+    char *  tmsg = malloc(size);
     if (NULL == tmsg) {
       tError("%s failed to allocate memory, size:%" PRId64, pConn->label, (int64_t)dataLen);
       continue;
@@ -257,4 +260,4 @@ int taosSendUdpData(uint32_t ip, uint16_t port, void *data, int dataLen, void *c
 
   return ret;
 }
-
+#endif