Merge remote-tracking branch 'origin/3.0' into feature/qnode

contrib/CMakeLists.txt

@@ -193,6 +193,7 @@ endif(${BUILD_WITH_TRAFT})
 
 # LIBUV
 if(${BUILD_WITH_UV})
+    add_compile_options(-Wno-sign-compare)
     add_subdirectory(libuv)
 endif(${BUILD_WITH_UV})
 

include/common/tep.h

@@ -23,7 +23,7 @@ typedef struct SBlockOrderInfo {
 //  bool             hasNull;
 } SBlockOrderInfo;
 
-int  taosGetFqdnPortFromEp(const char *ep, uint16_t defaultPort, SEp *pEp);
+int  taosGetFqdnPortFromEp(const char *ep, SEp *pEp);
 void addEpIntoEpSet(SEpSet *pEpSet, const char *fqdn, uint16_t port);
 
 bool isEpsetEqual(const SEpSet *s1, const SEpSet *s2);

include/common/tglobal.h

@@ -20,31 +20,48 @@
 extern "C" {
 #endif
 
+#include "tcfg.h"
 #include "tdef.h"
 
+// cluster
+extern char     tsFirst[];
+extern char     tsSecond[];
+extern char     tsLocalFqdn[];
+extern char     tsLocalEp[];
+extern uint16_t tsServerPort;
+extern int32_t  tsVersion;
+extern int32_t  tsStatusInterval;
+extern bool     tsEnableTelemetryReporting;
+
 // common
-extern int8_t   tsDaylight;
+extern int32_t tsRpcTimer;
+extern int32_t tsRpcMaxTime;
+extern bool    tsRpcForceTcp;  // all commands go to tcp protocol if this is enabled
+extern int32_t tsMaxConnections;
+extern int32_t tsMaxShellConns;
+extern int32_t tsShellActivityTimer;
+extern int32_t tsMaxTmrCtrl;
+extern float   tsNumOfThreadsPerCore;
+extern int32_t tsNumOfCommitThreads;
+extern float   tsRatioOfQueryCores;
 extern int32_t tsCompressMsgSize;
 extern int32_t tsCompressColData;
 extern int32_t tsMaxNumOfDistinctResults;
-extern char     tsTempDir[];
-extern int      tsCompatibleModel;  // 2.0 compatible model
-extern int8_t   tsEnableSlaveQuery;
-extern int8_t   tsEnableAdjustMaster;
-extern int8_t   tsPrintAuth;
+extern int32_t tsCompatibleModel;
+extern bool    tsEnableSlaveQuery;
+extern bool    tsPrintAuth;
 extern int64_t tsTickPerDay[3];
 
 // query buffer management
 extern int32_t tsQueryBufferSize;  // maximum allowed usage buffer size in MB for each data node during query processing
 extern int64_t tsQueryBufferSizeBytes;   // maximum allowed usage buffer size in byte for each data node
-extern int32_t tsRetrieveBlockingModel;  // retrieve threads will be blocked
-extern int8_t  tsKeepOriginalColumnName;
-extern int8_t  tsDeadLockKillQuery;
+extern bool    tsRetrieveBlockingModel;  // retrieve threads will be blocked
+extern bool    tsKeepOriginalColumnName;
+extern bool    tsDeadLockKillQuery;
 
 // client
 extern int32_t tsMaxWildCardsLen;
 extern int32_t tsMaxRegexStringLen;
-extern int8_t  tsTscEnableRecordSql;
 extern int32_t tsMaxNumOfOrderedResults;
 extern int32_t tsMinSlidingTime;
 extern int32_t tsMinIntervalTime;
@@ -55,10 +72,12 @@ extern float   tsStreamComputDelayRatio;  // the delayed computing ration of the
 extern int32_t tsProjectExecInterval;
 extern int64_t tsMaxRetentWindow;
 
-// system info
-
-extern uint32_t tsVersion;
-
+// build info
+extern char version[];
+extern char compatible_version[];
+extern char gitinfo[];
+extern char gitinfoOfInternal[];
+extern char buildinfo[];
 
 // lossy
 extern char     tsLossyColumns[];
@@ -68,15 +87,19 @@ extern uint32_t tsMaxRange;
 extern uint32_t tsCurRange;
 extern char     tsCompressor[];
 
+// tfs
+extern int32_t  tsDiskCfgNum;
+extern SDiskCfg tsDiskCfg[];
 
 #define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
 
-void    taosInitGlobalCfg();
-int32_t taosCfgDynamicOptions(char *msg);
-bool    taosCheckBalanceCfgOptions(const char *option, int32_t *vnodeId, int32_t *dnodeId);
-void    taosAddDataDir(int index, char *v1, int level, int primary);
-void    taosReadDataDirCfg(char *v1, char *v2, char *v3);
-void    taosPrintDataDirCfg();
+int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDir, const char *envFile,
+                      const char *apolloUrl, bool tsc);
+int32_t taosInitCfg(const char *cfgDir, const char *envFile, const char *apolloUrl, bool tsc);
+void    taosCleanupCfg();
+void    taosCfgDynamicOptions(const char *option, const char *value);
+
+struct SConfig *taosGetCfg();
 
 #ifdef __cplusplus
 }

include/common/tmsg.h

@@ -656,9 +656,9 @@ int32_t tDeserializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp
 typedef struct {
   int32_t statusInterval;
   int64_t checkTime;                    // 1970-01-01 00:00:00.000
-  char    timezone[TSDB_TIMEZONE_LEN];  // tsTimezone
-  char    locale[TSDB_LOCALE_LEN];      // tsLocale
-  char    charset[TSDB_LOCALE_LEN];     // tsCharset
+  char    timezone[TD_TIMEZONE_LEN];  // tsTimezone
+  char    locale[TD_LOCALE_LEN];      // tsLocale
+  char    charset[TD_LOCALE_LEN];     // tsCharset
 } SClusterCfg;
 
 typedef struct {

include/common/ttszip.h

@@ -73,7 +73,7 @@ typedef struct STSGroupBlockInfoEx {
 } STSGroupBlockInfoEx;
 
 typedef struct STSBuf {
-  FILE*    f;
+  TdFilePtr pFile;
   char      path[PATH_MAX];
   uint32_t  fileSize;
 

include/dnode/mgmt/dnode.h

@@ -25,27 +25,12 @@ extern "C" {
 /* ------------------------ TYPES EXPOSED ---------------- */
 typedef struct SDnode SDnode;
 
-/* ------------------------ Environment ------------------ */
-typedef struct {
-  int32_t  sver;
-  int32_t  numOfCores;
-  uint16_t numOfCommitThreads;
-  bool     enableTelem;
-  bool     printAuth;
-  char     timezone[TSDB_TIMEZONE_LEN];
-  char     locale[TSDB_LOCALE_LEN];
-  char     charset[TSDB_LOCALE_LEN];
-  char     buildinfo[64];
-  char     gitinfo[48];
-} SDnodeEnvCfg;
-
 /**
  * @brief Initialize the environment
  *
- * @param pOption Option of the environment
  * @return int32_t 0 for success and -1 for failure
  */
-int32_t dndInit(const SDnodeEnvCfg *pCfg);
+int32_t dndInit();
 
 /**
  * @brief clear the environment
@@ -56,11 +41,6 @@ void dndCleanup();
 /* ------------------------ SDnode ----------------------- */
 typedef struct {
   int32_t  numOfSupportVnodes;
-  int32_t  statusInterval;
-  float    numOfThreadsPerCore;
-  float    ratioOfQueryCores;
-  int32_t  maxShellConns;
-  int32_t  shellActivityTimer;
   uint16_t serverPort;
   char     dataDir[TSDB_FILENAME_LEN];
   char     localEp[TSDB_EP_LEN];

include/dnode/mnode/mnode.h

@@ -44,26 +44,12 @@ typedef struct SMnodeLoad {
   int64_t compStorage;
 } SMnodeLoad;
 
-typedef struct SMnodeCfg {
-  int32_t sver;
-  bool    enableTelem;
-  bool    printAuth;
-  int32_t statusInterval;
-  int32_t shellActivityTimer;
-  char   *timezone;
-  char   *locale;
-  char   *charset;
-  char   *buildinfo;
-  char   *gitinfo;
-} SMnodeCfg;
-
 typedef struct {
   int32_t           dnodeId;
   int64_t           clusterId;
   int8_t            replica;
   int8_t            selfIndex;
   SReplica          replicas[TSDB_MAX_REPLICA];
-  SMnodeCfg         cfg;
   SDnode           *pDnode;
   PutReqToMWriteQFp putReqToMWriteQFp;
   PutReqToMReadQFp  putReqToMReadQFp;

include/libs/nodes/nodes.h

@@ -62,7 +62,6 @@ typedef enum ENodeType {
   QUERY_NODE_NODE_LIST,
   QUERY_NODE_FILL,
   QUERY_NODE_RAW_EXPR, // Only be used in parser module.
-  QUERY_NODE_COLUMN_REF,
   QUERY_NODE_TARGET,
   QUERY_NODE_TUPLE_DESC,
   QUERY_NODE_SLOT_DESC,
@@ -81,7 +80,9 @@ typedef enum ENodeType {
   // physical plan node
   QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN,
   QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_PROJECT
+  QUERY_NODE_PHYSICAL_PLAN_PROJECT,
+  QUERY_NODE_PHYSICAL_PLAN_JOIN,
+  QUERY_NODE_PHYSICAL_PLAN_AGG
 } ENodeType;
 
 /**

include/libs/nodes/plannodes.h

@@ -69,8 +69,6 @@ typedef struct SSlotDescNode {
   ENodeType type;
   int16_t slotId;
   SDataType dataType;
-  int16_t srcTupleId;
-  int16_t srcSlotId;
   bool reserve;
   bool output;
 } SSlotDescNode;
@@ -115,6 +113,20 @@ typedef struct SProjectPhysiNode {
   SNodeList* pProjections;
 } SProjectPhysiNode;
 
+typedef struct SJoinPhysiNode {
+  SPhysiNode node;
+  EJoinType joinType;
+  SNode* pOnConditions; // in or out tuple ?
+  SNodeList* pTargets;
+} SJoinPhysiNode;
+
+typedef struct SAggPhysiNode {
+  SPhysiNode node;
+  SNodeList* pExprs;   // these are expression list of group_by_clause and parameter expression of aggregate function
+  SNodeList* pGroupKeys; // SColumnRefNode list
+  SNodeList* pAggFuncs;
+} SAggPhysiNode;
+
 #ifdef __cplusplus
 }
 #endif

include/libs/nodes/querynodes.h

@@ -58,15 +58,17 @@ typedef struct SColumnNode {
   char tableAlias[TSDB_TABLE_NAME_LEN];
   char colName[TSDB_COL_NAME_LEN];
   SNode* pProjectRef;
-} SColumnNode;
-
-typedef struct SColumnRefNode {
-  ENodeType type;
-  SDataType dataType;
   int16_t tupleId;
   int16_t slotId;
-  int16_t columnId;
-} SColumnRefNode;
+} SColumnNode;
+
+// typedef struct SColumnRefNode {
+//   ENodeType type;
+//   SDataType dataType;
+//   int16_t tupleId;
+//   int16_t slotId;
+//   int16_t columnId;
+// } SColumnRefNode;
 
 typedef struct STargetNode {
   ENodeType type;

include/libs/transport/trpc.h

@@ -86,7 +86,7 @@ typedef struct SRpcInit {
 
 int32_t rpcInit();
 void    rpcCleanup();
-void *  rpcOpen(const SRpcInit *pRpc);
+void   *rpcOpen(const SRpcInit *pRpc);
 void    rpcClose(void *);
 void *  rpcMallocCont(int contLen);
 void    rpcFreeCont(void *pCont);

include/libs/wal/wal.h

@@ -120,8 +120,8 @@ typedef struct SWal {
   int32_t fsyncSeq;
   // meta
   SWalVer vers;
-  int64_t writeLogTfd;
-  int64_t writeIdxTfd;
+  TdFilePtr pWriteLogTFile;
+  TdFilePtr pWriteIdxTFile;
   int32_t writeCur;
   SArray *fileInfoSet;
   // status
@@ -138,8 +138,8 @@ typedef struct SWal {
 
 typedef struct SWalReadHandle {
   SWal     *pWal;
-  int64_t   readLogTfd;
-  int64_t   readIdxTfd;
+  TdFilePtr pReadLogTFile;
+  TdFilePtr pReadIdxTFile;
   int64_t   curFileFirstVer;
   int64_t   curVersion;
   int64_t   capacity;

include/os/os.h

@@ -59,6 +59,7 @@ extern "C" {
 #include "osEndian.h"
 #include "osEnv.h"
 #include "osFile.h"
+#include "osLocale.h"
 #include "osLz4.h"
 #include "osMath.h"
 #include "osMemory.h"
@@ -73,6 +74,7 @@ extern "C" {
 #include "osThread.h"
 #include "osTime.h"
 #include "osTimer.h"
+#include "osTimezone.h"
 
 void osInit();
 

include/os/osDef.h

@@ -191,6 +191,10 @@ extern "C" {
 #define TD_DIRSEP	"/"
 #endif
 
+#define TD_LOCALE_LEN   64
+#define TD_CHARSET_LEN  64
+#define TD_TIMEZONE_LEN 96
+
 #ifdef __cplusplus
 }
 #endif

include/os/osDir.h

@@ -23,7 +23,7 @@ extern "C" {
 void    taosRemoveDir(const char *dirname);
 int32_t taosDirExist(char *dirname);
 int32_t taosMkDir(const char *dirname);
-void    taosRemoveOldFiles(char *dirname, int32_t keepDays);
+void    taosRemoveOldFiles(const char *dirname, int32_t keepDays);
 int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen);
 int32_t taosRealPath(char *dirname, int32_t maxlen);
 

include/os/osEnv.h

@@ -16,28 +16,37 @@
 #ifndef _TD_OS_ENV_H_
 #define _TD_OS_ENV_H_
 
+#include "osSysinfo.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 extern char    tsOsName[];
+extern char    tsTimezone[];
+extern char    tsCharset[];
+extern char    tsLocale[];
+extern int8_t  tsDaylight;
+extern bool    tsEnableCoreFile;
+extern int64_t tsPageSize;
+extern int64_t tsOpenMax;
+extern int64_t tsStreamMax;
+extern int32_t tsNumOfCores;
+extern int32_t tsTotalMemoryMB;
 
+extern char configDir[];
 extern char tsDataDir[];
 extern char tsLogDir[];
 extern char tsTempDir[];
-extern char configDir[];
 
-extern struct SDiskSpace tsLogSpace;
-extern struct SDiskSpace tsTempSpace;
-extern struct SDiskSpace tsDataSpace;
-
-void taosUpdateLogSpace();
-void taosUpdateTempSpace();
-void taosUpdateDataSpace();
-bool taosLogSpaceAvailable();
-bool taosTmpSpaceAvailable();
-bool taosDataSpaceAvailable();
-void taosUpdateAllSpace();
+extern SDiskSpace tsDataSpace;
+extern SDiskSpace tsLogSpace;
+extern SDiskSpace tsTempSpace;
+
+void osInit();
+void osUpdate();
+bool osLogSpaceAvailable();
+void osSetTimezone(const char *timezone);
 
 #ifdef __cplusplus
 }

include/os/osFile.h

@@ -22,49 +22,63 @@ extern "C" {
 
 #include "osSocket.h"
 
-#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
-typedef int32_t FileFd;
-#else
-typedef int32_t FileFd;
+#ifndef ALLOW_FORBID_FUNC
+    #define open OPEN_FUNC_TAOS_FORBID
+    #define fopen FOPEN_FUNC_TAOS_FORBID
+    // #define close CLOSE_FUNC_TAOS_FORBID
+    // #define fclose FCLOSE_FUNC_TAOS_FORBID
 #endif
 
-#define FD_INITIALIZER ((int32_t)-1)
-
 #ifndef PATH_MAX
 #define PATH_MAX 256
 #endif
 
-int32_t taosLockFile(FileFd fd);
-int32_t taosUnLockFile(FileFd fd);
+typedef struct TdFile *TdFilePtr;
+ 
+#define TD_FILE_CTEATE    0x0001
+#define TD_FILE_WRITE     0x0002
+#define TD_FILE_READ      0x0004
+#define TD_FILE_TRUNC     0x0008
+#define TD_FILE_APPEND    0x0010
+#define TD_FILE_TEXT      0x0020
+#define TD_FILE_AUTO_DEL  0x0040
+#define TD_FILE_EXCL      0x0080
+ 
+int32_t taosLockFile(TdFilePtr pFile);
+int32_t taosUnLockFile(TdFilePtr pFile);
  
-int32_t taosUmaskFile(FileFd fd);
+int32_t taosUmaskFile(int32_t maskVal);
  
 int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime);
-int32_t taosFStatFile(FileFd fd, int64_t *size, int32_t *mtime);
+int32_t taosFStatFile(TdFilePtr pFile, int64_t *size, int32_t *mtime);
  
-FileFd taosOpenFileWrite(const char *path);
-FileFd taosOpenFileCreateWrite(const char *path);
-FileFd taosOpenFileCreateWriteTrunc(const char *path);
-FileFd taosOpenFileCreateWriteAppend(const char *path);
-FileFd taosOpenFileRead(const char *path);
-FileFd taosOpenFileReadWrite(const char *path);
+TdFilePtr taosOpenFile(const char *path,int32_t tdFileOptions);
  
-int64_t taosLSeekFile(FileFd fd, int64_t offset, int32_t whence);
-int32_t taosFtruncateFile(FileFd fd, int64_t length);
-int32_t taosFsyncFile(FileFd fd);
+int64_t taosLSeekFile(TdFilePtr pFile, int64_t offset, int32_t whence);
+int32_t taosFtruncateFile(TdFilePtr pFile, int64_t length);
+int32_t taosFsyncFile(TdFilePtr pFile);
  
-int64_t taosReadFile(FileFd fd, void *buf, int64_t count);
-int64_t taosWriteFile(FileFd fd, const void *buf, int64_t count);
+int64_t taosReadFile(TdFilePtr pFile, void *buf, int64_t count);
+int64_t taosPReadFile(TdFilePtr pFile, void *buf, int64_t count, int64_t offset);
+int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count);
+void taosFprintfFile(TdFilePtr pFile, const char *format, ...);
+size_t taosGetLineFile(TdFilePtr pFile, char ** __restrict__ ptrBuf);
+int32_t taosEOFFile(TdFilePtr pFile);
  
-void taosCloseFile(FileFd fd);
+int64_t taosCloseFile(TdFilePtr *ppFile);
  
 int32_t taosRenameFile(const char *oldName, const char *newName);
 int64_t taosCopyFile(const char *from, const char *to);
  
 void taosGetTmpfilePath(const char *inputTmpDir, const char *fileNamePrefix, char *dstPath);
  
-int64_t taosSendFile(SocketFd dfd, FileFd sfd, int64_t *offset, int64_t size);
-int64_t taosFSendFile(FILE *outfile, FILE *infile, int64_t *offset, int64_t size);
+int64_t taosSendFile(SocketFd fdDst, TdFilePtr pFileSrc, int64_t *offset, int64_t size);
+int64_t taosFSendFile(TdFilePtr pFileOut, TdFilePtr pFileIn, int64_t *offset, int64_t size);
+
+void *taosMmapReadOnlyFile(TdFilePtr pFile, int64_t length);
+bool taosValidFile(TdFilePtr pFile);
+
+int taosGetErrorFile(TdFilePtr pFile);
 
 #ifdef __cplusplus
 }

include/common/ttimezone.h → include/os/osLocale.h

@@ -13,17 +13,22 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_COMMON_TIMEZONE_H_
-#define _TD_COMMON_TIMEZONE_H_
+#ifndef _TD_OS_LOCALE_H_
+#define _TD_OS_LOCALE_H_
+
+#include "os.h"
+#include "osString.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-void tsSetTimeZone();
+char *taosCharsetReplace(char *charsetstr);
+void  taosGetSystemLocale(char *outLocale, char *outCharset);
+void  taosSetSystemLocale(const char *inLocale, const char *inCharSet);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_COMMON_TIMEZONE_H_*/
+#endif /*_TD_OS_LOCALE_H_*/

include/os/osString.h

@@ -45,7 +45,6 @@ int32_t taosUcs4ToMbs(void *ucs4, int32_t ucs4_max_len, char *mbs);
 bool    taosMbsToUcs4(const char *mbs, size_t mbs_len, char *ucs4, int32_t ucs4_max_len, int32_t *len);
 int32_t tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int32_t bytes, int8_t ncharSize);
 bool    taosValidateEncodec(const char *encodec);
-char *  taosCharsetReplace(char *charsetstr);
 
 #ifdef __cplusplus
 }

include/os/osSysinfo.h

@@ -22,31 +22,17 @@ extern "C" {
 
 #include "os.h"
 
-#define TSDB_LOCALE_LEN   64
-#define TSDB_TIMEZONE_LEN 96
-
 typedef struct {
   int64_t total;
   int64_t used;
   int64_t avail;
 } SDiskSize;
 
-typedef struct SDiskSpace {
+typedef struct {
   int64_t   reserved;
   SDiskSize size;
 } SDiskSpace;
 
-extern int64_t tsPageSize;
-extern int64_t tsOpenMax;
-extern int64_t tsStreamMax;
-extern int32_t tsNumOfCores;
-extern int32_t tsTotalMemoryMB;
-extern char    tsTimezone[];
-extern char    tsLocale[];
-extern char    tsCharset[];  // default encode string
-
-
-
 int32_t taosGetDiskSize(char *dataDir, SDiskSize *diskSize);
 int32_t taosGetCpuCores();
 void    taosGetSystemInfo();
@@ -58,7 +44,6 @@ void    taosGetDisk();
 bool    taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage);
 bool    taosGetProcMemory(float *memoryUsedMB);
 bool    taosGetSysMemory(float *memoryUsedMB);
-void    taosPrintOsInfo();
 int     taosSystem(const char *cmd);
 void    taosKillSystem();
 int32_t taosGetSystemUUID(char *uid, int32_t uidlen);

include/common/tlocale.h → include/os/osTimezone.h

@@ -13,17 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_COMMON_LOCALE_H_
-#define _TD_COMMON_LOCALE_H_
+#ifndef _TD_OS_TIMEZONE_H_
+#define _TD_OS_TIMEZONE_H_
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-void tsSetLocale();
+void taosGetSystemTimezone(char *outTimezone);
+void taosSetSystemTimezone(const char *inTimezone, char *outTimezone, int8_t *outDaylight);
 
 #ifdef __cplusplus
 }
-#endif /*_TD_COMMON_LOCALE_H_*/
-
 #endif
+
+#endif /*_TD_OS_TIMEZONE_H_*/

include/libs/config/config.h → include/util/tconfig.h

@@ -42,7 +42,6 @@ typedef enum {
   CFG_DTYPE_INT64,
   CFG_DTYPE_FLOAT,
   CFG_DTYPE_STRING,
-  CFG_DTYPE_IPSTR,
   CFG_DTYPE_DIR,
   CFG_DTYPE_LOCALE,
   CFG_DTYPE_CHARSET,
@@ -52,6 +51,7 @@ typedef enum {
 typedef struct SConfigItem {
   ECfgSrcType  stype;
   ECfgDataType dtype;
+  bool         tsc;
   char        *name;
   union {
     bool     bval;
@@ -80,14 +80,14 @@ int32_t      cfgGetSize(SConfig *pCfg);
 SConfigItem *cfgIterate(SConfig *pCfg, SConfigItem *pIter);
 void         cfgCancelIterate(SConfig *pCfg, SConfigItem *pIter);
 SConfigItem *cfgGetItem(SConfig *pCfg, const char *name);
-
-int32_t cfgAddBool(SConfig *pCfg, const char *name, bool defaultVal);
-int32_t cfgAddInt32(SConfig *pCfg, const char *name, int32_t defaultVal, int64_t minval, int64_t maxval);
-int32_t cfgAddInt64(SConfig *pCfg, const char *name, int64_t defaultVal, int64_t minval, int64_t maxval);
-int32_t cfgAddFloat(SConfig *pCfg, const char *name, float defaultVal, double minval, double maxval);
-int32_t cfgAddString(SConfig *pCfg, const char *name, const char *defaultVal);
-int32_t cfgAddIpStr(SConfig *pCfg, const char *name, const char *defaultVa);
-int32_t cfgAddDir(SConfig *pCfg, const char *name, const char *defaultVal);
+int32_t      cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcType stype);
+
+int32_t cfgAddBool(SConfig *pCfg, const char *name, bool defaultVal, bool tsc);
+int32_t cfgAddInt32(SConfig *pCfg, const char *name, int32_t defaultVal, int64_t minval, int64_t maxval, bool tsc);
+int32_t cfgAddInt64(SConfig *pCfg, const char *name, int64_t defaultVal, int64_t minval, int64_t maxval, bool tsc);
+int32_t cfgAddFloat(SConfig *pCfg, const char *name, float defaultVal, double minval, double maxval, bool tsc);
+int32_t cfgAddString(SConfig *pCfg, const char *name, const char *defaultVal, bool tsc);
+int32_t cfgAddDir(SConfig *pCfg, const char *name, const char *defaultVal, bool tsc);
 int32_t cfgAddLocale(SConfig *pCfg, const char *name, const char *defaultVal);
 int32_t cfgAddCharset(SConfig *pCfg, const char *name, const char *defaultVal);
 int32_t cfgAddTimezone(SConfig *pCfg, const char *name, const char *defaultVal);
@@ -95,7 +95,7 @@ int32_t cfgAddTimezone(SConfig *pCfg, const char *name, const char *defaultVal);
 const char *cfgStypeStr(ECfgSrcType type);
 const char *cfgDtypeStr(ECfgDataType type);
 
-void cfgDumpCfg(SConfig *pCfg);
+void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump);
 
 #ifdef __cplusplus
 }

include/util/tfile.h

@@ -30,20 +30,20 @@ void tfCleanup();
 
 // the same syntax as UNIX standard open/close/read/write
 // but FD is int64_t and will never be reused
-int64_t tfOpenRead(const char *pathname);
-int64_t tfOpenReadWrite(const char *pathname);
-int64_t tfOpenCreateWrite(const char *pathname);
-int64_t tfOpenCreateWriteAppend(const char *pathname);
-
-int64_t tfClose(int64_t tfd);
-int64_t tfWrite(int64_t tfd, void *buf, int64_t count);
-int64_t tfRead(int64_t tfd, void *buf, int64_t count);
-int64_t tfPread(int64_t tfd, void *buf, int64_t count, int64_t offset);
-int32_t tfFsync(int64_t tfd);
-bool    tfValid(int64_t tfd);
-int64_t tfLseek(int64_t tfd, int64_t offset, int32_t whence);
-int32_t tfFtruncate(int64_t tfd, int64_t length);
-void *  tfMmapReadOnly(int64_t tfd, int64_t length);
+// int64_t tfOpenRead(const char *pathname);
+// int64_t tfOpenReadWrite(const char *pathname);
+// int64_t tfOpenCreateWrite(const char *pathname);
+// int64_t tfOpenCreateWriteAppend(const char *pathname);
+
+// int64_t tfClose(int64_t tfd);
+// int64_t tfWrite(int64_t tfd, void *buf, int64_t count);
+// int64_t tfRead(int64_t tfd, void *buf, int64_t count);
+// int64_t tfPread(int64_t tfd, void *buf, int64_t count, int64_t offset);
+// int32_t tfFsync(int64_t tfd);
+// bool    tfValid(int64_t tfd);
+// int64_t tfLseek(int64_t tfd, int64_t offset, int32_t whence);
+// int32_t tfFtruncate(int64_t tfd, int64_t length);
+// void *  tfMmapReadOnly(int64_t tfd, int64_t length);
 #ifdef __cplusplus
 }
 #endif

include/util/tnote.h

-/*
- * 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_NOTE_H
-#define _TD_UTIL_NOTE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define MAX_NOTE_LINE_SIZE 66000
-#define NOTE_FILE_NAME_LEN 300
-
-typedef struct {
-  int32_t fileNum;
-  int32_t maxLines;
-  int32_t lines;
-  int32_t flag;
-  int32_t fd;
-  int32_t openInProgress;
-  char    name[NOTE_FILE_NAME_LEN];
-  pthread_mutex_t mutex;
-} SNoteObj;
-
-extern SNoteObj tsHttpNote;
-extern SNoteObj tsTscNote;
-extern SNoteObj tsInfoNote;
-
-int32_t taosInitNotes();
-void    taosNotePrint(SNoteObj* pNote, const char* const format, ...);
-void    taosNotePrintBuffer(SNoteObj* pNote, char* buffer, int32_t len);
-
-#define nPrintHttp(...)                      \
-  if (tsHttpEnableRecordSql) {               \
-    taosNotePrint(&tsHttpNote, __VA_ARGS__); \
-  }
-
-#define nPrintTsc(...)                      \
-  if (tsTscEnableRecordSql) {               \
-    taosNotePrint(&tsTscNote, __VA_ARGS__); \
-  }
-
-#define nInfo(buffer, len)                         \
-  if (tscEmbeddedInUtil == 1) {                          \
-    taosNotePrintBuffer(&tsInfoNote, buffer, len); \
-  }
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_UTIL_NOTE_H*/

source/client/CMakeLists.txt

@@ -8,7 +8,7 @@ target_include_directories(
 target_link_libraries(
     taos
     INTERFACE api
-    PRIVATE os util common transport parser planner catalog scheduler function qcom config
+    PRIVATE os util common transport parser planner catalog scheduler function qcom
 )
 
 if(${BUILD_TEST})

source/client/inc/clientInt.h

@@ -32,7 +32,7 @@ extern "C" {
 #include "tmsgtype.h"
 #include "trpc.h"
 
-#include "config.h"
+#include "tconfig.h"
 
 #define CHECK_CODE_GOTO(expr, label) \
   do {                               \
@@ -253,13 +253,6 @@ int hbAddConnInfo(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, void* key, void* v
 // --- mq
 void hbMgrInitMqHbRspHandle();
 
-
-// config
-int32_t tscInitLog(const char *cfgDir, const char *envFile, const char *apolloUrl);
-int32_t tscInitCfg(const char *cfgDir, const char *envFile, const char *apolloUrl);
-
-extern SConfig *tscCfg;
-
 #ifdef __cplusplus
 }
 #endif

source/client/src/clientCfg.c

-/*
- * 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 "clientInt.h"
-#include "ulog.h"
-
-// todo refact 
-SConfig *tscCfg;
-
-static int32_t tscLoadCfg(SConfig *pConfig, const char *inputCfgDir, const char *envFile, const char *apolloUrl) {
-  char cfgDir[PATH_MAX] = {0};
-  char cfgFile[PATH_MAX + 100] = {0};
-
-  taosExpandDir(inputCfgDir, cfgDir, PATH_MAX);
-  snprintf(cfgFile, sizeof(cfgFile), "%s" TD_DIRSEP "taos.cfg", cfgDir);
-
-  if (cfgLoad(pConfig, CFG_STYPE_APOLLO_URL, apolloUrl) != 0) {
-    uError("failed to load from apollo url:%s since %s\n", apolloUrl, terrstr());
-    return -1;
-  }
-
-  if (cfgLoad(pConfig, CFG_STYPE_CFG_FILE, cfgFile) != 0) {
-    if (cfgLoad(pConfig, CFG_STYPE_CFG_FILE, cfgDir) != 0) {
-      uError("failed to load from config file:%s since %s\n", cfgFile, terrstr());
-      return -1;
-    }
-  }
-
-  if (cfgLoad(pConfig, CFG_STYPE_ENV_FILE, envFile) != 0) {
-    uError("failed to load from env file:%s since %s\n", envFile, terrstr());
-    return -1;
-  }
-
-  if (cfgLoad(pConfig, CFG_STYPE_ENV_VAR, NULL) != 0) {
-    uError("failed to load from global env variables since %s\n", terrstr());
-    return -1;
-  }
-
-  return 0;
-}
-
-static int32_t tscAddLogCfg(SConfig *pCfg) {
-  if (cfgAddDir(pCfg, "logDir", "/var/log/taos") != 0) return -1;
-  if (cfgAddBool(pCfg, "asyncLog", 1) != 0) return -1;
-  if (cfgAddInt32(pCfg, "numOfLogLines", 10000000, 1000, 2000000000) != 0) return -1;
-  if (cfgAddInt32(pCfg, "logKeepDays", 0, -365000, 365000) != 0) return -1;
-  if (cfgAddInt32(pCfg, "debugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "cDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "jniDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "tmrDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "uDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "rpcDebugFlag", 0, 0, 255) != 0) return -1;
-  return 0;
-}
-
-static int32_t tscSetLogCfg(SConfig *pCfg) {
-  tstrncpy(tsLogDir, cfgGetItem(pCfg, "logDir")->str, PATH_MAX);
-  tsAsyncLog = cfgGetItem(pCfg, "asyncLog")->bval;
-  tsNumOfLogLines = cfgGetItem(pCfg, "numOfLogLines")->i32;
-  tsLogKeepDays = cfgGetItem(pCfg, "logKeepDays")->i32;
-  cDebugFlag = cfgGetItem(pCfg, "cDebugFlag")->i32;
-  jniDebugFlag = cfgGetItem(pCfg, "jniDebugFlag")->i32;
-  tmrDebugFlag = cfgGetItem(pCfg, "tmrDebugFlag")->i32;
-  uDebugFlag = cfgGetItem(pCfg, "uDebugFlag")->i32;
-  rpcDebugFlag = cfgGetItem(pCfg, "rpcDebugFlag")->i32;
-
-  int32_t debugFlag = cfgGetItem(pCfg, "debugFlag")->i32;
-  taosSetAllDebugFlag(debugFlag);
-  return 0;
-}
-
-int32_t tscInitLog(const char *cfgDir, const char *envFile, const char *apolloUrl) {
-  if (tsLogInited) return 0;
-
-  SConfig *pCfg = cfgInit();
-  if (pCfg == NULL) return -1;
-
-  if (tscAddLogCfg(pCfg) != 0) {
-    printf("failed to add log cfg since %s\n", terrstr());
-    cfgCleanup(pCfg);
-    return -1;
-  }
-
-  if (tscLoadCfg(pCfg, cfgDir, envFile, apolloUrl) != 0) {
-    printf("failed to load log cfg since %s\n", terrstr());
-    cfgCleanup(pCfg);
-    return -1;
-  }
-
-  if (tscSetLogCfg(pCfg) != 0) {
-    printf("failed to set log cfg since %s\n", terrstr());
-    cfgCleanup(pCfg);
-    return -1;
-  }
-
-  const int32_t maxLogFileNum = 10;
-  if (taosInitLog("taoslog", maxLogFileNum) != 0) {
-    printf("failed to init log file since %s\n", terrstr());
-    cfgCleanup(pCfg);
-    return -1;
-  }
-
-  cfgDumpCfg(pCfg);
-  cfgCleanup(pCfg);
-  return 0;
-}
-
-static int32_t tscAddEpCfg(SConfig *pCfg) {
-  char defaultFqdn[TSDB_FQDN_LEN] = {0};
-  if (taosGetFqdn(defaultFqdn) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    return -1;
-  }
-  if (cfgAddString(pCfg, "fqdn", defaultFqdn) != 0) return -1;
-  
-  int32_t defaultServerPort = 6030;
-  if (cfgAddInt32(pCfg, "serverPort", defaultServerPort, 1, 65056) != 0) return -1;
-
-  char defaultFirstEp[TSDB_EP_LEN] = {0};
-  char defaultSecondEp[TSDB_EP_LEN] = {0};
-  snprintf(defaultFirstEp, TSDB_EP_LEN, "%s:%d", defaultFqdn, defaultServerPort);
-  snprintf(defaultSecondEp, TSDB_EP_LEN, "%s:%d", defaultFqdn, defaultServerPort);
-  if (cfgAddString(pCfg, "firstEp", defaultFirstEp) != 0) return -1;
-  if (cfgAddString(pCfg, "secondEp", defaultSecondEp) != 0) return -1;
-
-  return 0;
-}
-
-static int32_t tscAddCfg(SConfig *pCfg) {
-  if (tscAddEpCfg(pCfg) != 0) return -1;
-
-
-  // if (cfgAddString(pCfg, "buildinfo", buildinfo) != 0) return -1;
-  // if (cfgAddString(pCfg, "gitinfo", gitinfo) != 0) return -1;
-  // if (cfgAddString(pCfg, "version", version) != 0) return -1;
- 
-  // if (cfgAddDir(pCfg, "dataDir", tsDataDir) != 0) return -1;
-  if (cfgAddTimezone(pCfg, "timezone", "") != 0) return -1;
-  if (cfgAddLocale(pCfg, "locale", "") != 0) return -1;
-  if (cfgAddCharset(pCfg, "charset", "") != 0) return -1;
-  if (cfgAddInt32(pCfg, "numOfCores", 1, 1, 100000) != 0) return -1;
-  if (cfgAddInt32(pCfg, "numOfCommitThreads", 4, 1, 1000) != 0) return -1;
-  // if (cfgAddBool(pCfg, "telemetryReporting", 0) != 0) return -1;
-  if (cfgAddBool(pCfg, "enableCoreFile", 0) != 0) return -1;
-  // if (cfgAddInt32(pCfg, "supportVnodes", 256, 0, 65536) != 0) return -1;
-  if (cfgAddInt32(pCfg, "statusInterval", 1, 1, 30) != 0) return -1;
-  if (cfgAddFloat(pCfg, "numOfThreadsPerCore", 1, 0, 10) != 0) return -1;
-  if (cfgAddFloat(pCfg, "ratioOfQueryCores", 1, 0, 5) != 0) return -1;
-  if (cfgAddInt32(pCfg, "shellActivityTimer", 3, 1, 120) != 0) return -1;
-
-  if (cfgAddInt32(pCfg, "maxConnections", 50000, 1, 100000) != 0) return -1;
-  return 0;
-}
-
-int32_t tscCheckCfg(SConfig *pCfg) {
-  bool enableCore = cfgGetItem(pCfg, "enableCoreFile")->bval;
-  taosSetCoreDump(enableCore);
-
-
-
-  return 0;
-}
-
-SConfig *tscInitCfgImp(const char *cfgDir, const char *envFile, const char *apolloUrl) {
-  SConfig *pCfg = cfgInit();
-  if (pCfg == NULL) return NULL;
-
-  if (tscAddCfg(pCfg) != 0) {
-    uError("failed to init tsc cfg since %s", terrstr());
-    cfgCleanup(pCfg);
-    return NULL;
-  }
-
-  if (tscLoadCfg(pCfg, cfgDir, envFile, apolloUrl) != 0) {
-    printf("failed to load tsc cfg since %s\n", terrstr());
-    cfgCleanup(pCfg);
-    return NULL;
-  }
-
-  if (tscCheckCfg(pCfg) != 0) {
-    uError("failed to check cfg since %s", terrstr());
-    cfgCleanup(pCfg);
-    return NULL;
-  }
-
-  cfgDumpCfg(pCfg);
-  return pCfg;
-}
-
-int32_t tscInitCfg(const char *cfgDir, const char *envFile, const char *apolloUrl) {
-  tscCfg = tscInitCfgImp(cfgDir, envFile, apolloUrl);
-  if (tscCfg == NULL) return -1;
-
-  return 0;
-}
\ No newline at end of file

source/client/src/clientEnv.c

@@ -22,11 +22,9 @@
 #include "tcache.h"
 #include "tglobal.h"
 #include "tmsg.h"
-#include "tnote.h"
 #include "tref.h"
 #include "trpc.h"
 #include "ttime.h"
-#include "ttimezone.h"
 
 #define TSC_VAR_NOT_RELEASE 1
 #define TSC_VAR_RELEASED 0
@@ -95,10 +93,10 @@ void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   rpcInit.numOfThreads = numOfThread;
   rpcInit.cfp = processMsgFromServer;
   rpcInit.pfp = persistConnForSpecificMsg;
-  rpcInit.sessions = cfgGetItem(tscCfg, "maxConnections")->i32;
+  rpcInit.sessions = tsMaxConnections;
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.user = (char *)user;
-  rpcInit.idleTime = cfgGetItem(tscCfg, "shellActivityTimer")->i32 * 1000;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.ckey = "key";
   rpcInit.spi = 1;
   rpcInit.secret = (char *)auth;
@@ -214,17 +212,16 @@ void taos_init_imp(void) {
 
   deltaToUtcInitOnce();
 
-  if (tscInitLog(configDir, NULL, NULL) != 0) {
+  if (taosCreateLog("taoslog", 10, configDir, NULL, NULL, 1) != 0) {
     tscInitRes = -1;
     return;
   }
 
-  if (tscInitCfg(configDir, NULL, NULL) != 0) {
+  if (taosInitCfg(configDir, NULL, NULL, 1) != 0) {
     tscInitRes = -1;
     return;
   }
 
-  taosInitNotes();
   initMsgHandleFp();
   initQueryModuleMsgHandle();
 
@@ -298,7 +295,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
       assert(cfg != NULL);
 
       size_t len = strlen(str);
-      if (len == 0 || len > TSDB_LOCALE_LEN) {
+      if (len == 0 || len > TD_LOCALE_LEN) {
         tscInfo("Invalid locale:%s, use default", str);
         return -1;
       }
@@ -316,7 +313,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
             return -1;
           }
 
-          tstrncpy(tsLocale, defaultLocale, TSDB_LOCALE_LEN);
+          tstrncpy(tsLocale, defaultLocale, TD_LOCALE_LEN);
         }
 
         // set the user specified locale
@@ -330,7 +327,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
           tscInfo("failed to set locale:%s, current locale:%s", str, tsLocale);
         }
 
-        tstrncpy(tsLocale, locale, TSDB_LOCALE_LEN);
+        tstrncpy(tsLocale, locale, TD_LOCALE_LEN);
 
         char *charset = strrchr(tsLocale, sep);
         if (charset != NULL) {
@@ -345,7 +342,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
               tscInfo("charset changed from %s to %s", tsCharset, charset);
             }
 
-            tstrncpy(tsCharset, charset, TSDB_LOCALE_LEN);
+            tstrncpy(tsCharset, charset, TD_LOCALE_LEN);
             cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
 
           } else {
@@ -369,7 +366,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
       assert(cfg != NULL);
 
       size_t len = strlen(str);
-      if (len == 0 || len > TSDB_LOCALE_LEN) {
+      if (len == 0 || len > TD_LOCALE_LEN) {
         tscInfo("failed to set charset:%s", str);
         return -1;
       }
@@ -382,7 +379,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
             tscInfo("charset changed from %s to %s", tsCharset, str);
           }
 
-          tstrncpy(tsCharset, str, TSDB_LOCALE_LEN);
+          tstrncpy(tsCharset, str, TD_LOCALE_LEN);
           cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
         } else {
           tscInfo("charset:%s not valid", str);
@@ -400,7 +397,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
       assert(cfg != NULL);
 
       if (cfg->cfgStatus <= TAOS_CFG_CSTATUS_OPTION) {
-        tstrncpy(tsTimezone, str, TSDB_TIMEZONE_LEN);
+        tstrncpy(tsTimezone, str, TD_TIMEZONE_LEN);
         tsSetTimeZone();
         cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
         tscDebug("timezone set:%s, input:%s by taos_options", tsTimezone, str);

source/client/src/clientImpl.c

@@ -8,11 +8,10 @@
 #include "tep.h"
 #include "tglobal.h"
 #include "tmsgtype.h"
-#include "tnote.h"
 #include "tpagedbuf.h"
 #include "tref.h"
 
-static int32_t       initEpSetFromCfg(const char* ip, uint16_t port, SCorEpSet* pEpSet);
+static int32_t       initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSet);
 static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest);
 static void          destroySendMsgInfo(SMsgSendInfo* pMsgBody);
 static void          setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp);
@@ -81,7 +80,19 @@ TAOS* taos_connect_internal(const char* ip, const char* user, const char* pass,
   }
 
   SCorEpSet epSet = {0};
-  initEpSetFromCfg(ip, port, &epSet);
+  if (ip) {
+    if (initEpSetFromCfg(ip, NULL, &epSet) < 0) {
+      return NULL;
+    }
+
+    if (port) {
+      epSet.epSet.eps[0].port = port;
+    }
+  } else {
+    if (initEpSetFromCfg(tsFirst, tsSecond, &epSet) < 0) {
+      return NULL;
+    }
+  }
 
   char*          key = getClusterKey(user, secretEncrypt, ip, port);
   SAppInstInfo** pInst = NULL;
@@ -242,8 +253,6 @@ TAOS_RES* taos_query_l(TAOS* taos, const char* sql, int sqlLen) {
     return NULL;
   }
 
-  nPrintTsc("%s", sql)
-
   SRequestObj* pRequest = NULL;
   SQueryNode*  pQueryNode = NULL;
   SArray*      pNodeList = taosArrayInit(4, sizeof(struct SQueryNodeAddr));
@@ -270,41 +279,33 @@ _return:
   return pRequest;
 }
 
-int initEpSetFromCfg(const char* ip, uint16_t port, SCorEpSet* pEpSet) {
-  SConfigItem* pFirst = cfgGetItem(tscCfg, "firstEp");
-  SConfigItem* pSecond = cfgGetItem(tscCfg, "secondEp");
-  SConfigItem* pPort = cfgGetItem(tscCfg, "serverPort");
+int initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSet) {
+  pEpSet->version = 0;
 
   // init mnode ip set
   SEpSet* mgmtEpSet = &(pEpSet->epSet);
   mgmtEpSet->numOfEps = 0;
   mgmtEpSet->inUse = 0;
-  pEpSet->version = 0;
 
-  if (ip != NULL) {
-    taosGetFqdnPortFromEp(ip, (uint16_t)pPort->i32, &mgmtEpSet->eps[0]);
-    mgmtEpSet->numOfEps++;
-    if (port) {
-      mgmtEpSet->eps[0].port = port;
-    }
-  } else {
-    if (pFirst->str[0] != 0) {
-      if (strlen(pFirst->str) >= TSDB_EP_LEN) {
+  if (firstEp && firstEp[0] != 0) {
+    if (strlen(firstEp) >= TSDB_EP_LEN) {
       terrno = TSDB_CODE_TSC_INVALID_FQDN;
       return -1;
     }
-      taosGetFqdnPortFromEp(pFirst->str, (uint16_t)pPort->i32, &mgmtEpSet->eps[0]);
+
+    taosGetFqdnPortFromEp(firstEp, &mgmtEpSet->eps[0]);
     mgmtEpSet->numOfEps++;
   }
-    if (pSecond->str[0] != 0) {
-      if (strlen(pSecond->str) >= TSDB_EP_LEN) {
+
+  if (secondEp && secondEp[0] != 0) {
+    if (strlen(secondEp) >= TSDB_EP_LEN) {
       terrno = TSDB_CODE_TSC_INVALID_FQDN;
       return -1;
     }
-      taosGetFqdnPortFromEp(pSecond->str, (uint16_t)pPort->i32, &mgmtEpSet->eps[1]);
+
+    taosGetFqdnPortFromEp(secondEp, &mgmtEpSet->eps[mgmtEpSet->numOfEps]);
     mgmtEpSet->numOfEps++;
   }
-  }
 
   if (mgmtEpSet->numOfEps == 0) {
     terrno = TSDB_CODE_TSC_INVALID_FQDN;

source/client/src/tmq.c

@@ -24,7 +24,6 @@
 #include "tep.h"
 #include "tglobal.h"
 #include "tmsgtype.h"
-#include "tnote.h"
 #include "tpagedbuf.h"
 #include "tref.h"
 

source/client/test/CMakeLists.txt

@@ -8,13 +8,13 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 ADD_EXECUTABLE(clientTest clientTests.cpp)
 TARGET_LINK_LIBRARIES(
         clientTest
-        PUBLIC os util common transport parser catalog scheduler function gtest taos qcom config
+        PUBLIC os util common transport parser catalog scheduler function gtest taos qcom
 )
 
 ADD_EXECUTABLE(tmqTest tmqTest.cpp)
 TARGET_LINK_LIBRARIES(
         tmqTest
-        PUBLIC os util common transport parser catalog scheduler function gtest taos qcom config
+        PUBLIC os util common transport parser catalog scheduler function gtest taos qcom
 )
 
 TARGET_INCLUDE_DIRECTORIES(

source/client/test/clientTests.cpp

@@ -49,7 +49,7 @@ int main(int argc, char** argv) {
 }
 
 TEST(testCase, driverInit_Test) {
-  taosInitGlobalCfg();
+  // taosInitGlobalCfg();
 //  taos_init();
 }
 

source/client/test/tmqTest.cpp

@@ -34,7 +34,7 @@ int main(int argc, char** argv) {
 }
 
 TEST(testCase, driverInit_Test) {
-  taosInitGlobalCfg();
+  // taosInitGlobalCfg();
 //  taos_init();
 }
 

source/common/src/tep.c

@@ -4,7 +4,7 @@
 #include "tglobal.h"
 #include "tlockfree.h"
 
-int taosGetFqdnPortFromEp(const char *ep, uint16_t defaultPort, SEp* pEp) {
+int taosGetFqdnPortFromEp(const char *ep, SEp* pEp) {
   pEp->port = 0;
   strcpy(pEp->fqdn, ep);
 
@@ -15,7 +15,7 @@ int taosGetFqdnPortFromEp(const char *ep, uint16_t defaultPort, SEp* pEp) {
   }
 
   if (pEp->port == 0) {
-    pEp->port = defaultPort;
+    pEp->port = tsServerPort;
     return -1;
   }
 

source/common/src/tlocale.c

-/*
- * 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 "os.h"
-#include "ulog.h"
-#include "tglobal.h"
-#include "tutil.h"
-
-/**
- * In some Linux systems, setLocale(LC_CTYPE, "") may return NULL, in which case the launch of
- * both the TDengine Server and the Client may be interrupted.
- *
- * In case that the setLocale failed to be executed, the right charset needs to be set.
- */
-void tsSetLocale() {
-  char *locale = setlocale(LC_CTYPE, tsLocale);
-
-  // default locale or user specified locale is not valid, abort launch
-  if (locale == NULL) {
-    uError("Invalid locale:%s, please set the valid locale in config file", tsLocale);
-  }
-
-  if (strlen(tsCharset) == 0) {
-    uError("failed to get charset, please set the valid charset in config file");
-    exit(-1);
-  }
-
-  if (!taosValidateEncodec(tsCharset)) {
-    uError("Invalid charset:%s, please set the valid charset in config file", tsCharset);
-    exit(-1);
-  }
-}
\ No newline at end of file

source/common/src/ttszip.c

@@ -24,8 +24,9 @@ STSBuf* tsBufCreate(bool autoDelete, int32_t order) {
   pTSBuf->autoDelete = autoDelete;
   
   taosGetTmpfilePath(tsTempDir, "join", pTSBuf->path);
-  pTSBuf->f = fopen(pTSBuf->path, "wb+");
-  if (pTSBuf->f == NULL) {
+  // pTSBuf->pFile = fopen(pTSBuf->path, "wb+");
+  pTSBuf->pFile = taosOpenFile(pTSBuf->path, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_READ | TD_FILE_TRUNC);
+  if (pTSBuf->pFile == NULL) {
     free(pTSBuf);
     return NULL;
   }
@@ -60,8 +61,9 @@ STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
   
   tstrncpy(pTSBuf->path, path, sizeof(pTSBuf->path));
   
-  pTSBuf->f = fopen(pTSBuf->path, "rb+");
-  if (pTSBuf->f == NULL) {
+  // pTSBuf->pFile = fopen(pTSBuf->path, "rb+");
+  pTSBuf->pFile = taosOpenFile(pTSBuf->path, TD_FILE_WRITE | TD_FILE_READ);
+  if (pTSBuf->pFile == NULL) {
     free(pTSBuf);
     return NULL;
   }
@@ -72,9 +74,9 @@ STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
   
   // validate the file magic number
   STSBufFileHeader header = {0};
-  int32_t ret = fseek(pTSBuf->f, 0, SEEK_SET);
+  int32_t ret = taosLSeekFile(pTSBuf->pFile, 0, SEEK_SET);
   UNUSED(ret);
-  size_t sz = fread(&header, 1, sizeof(STSBufFileHeader), pTSBuf->f);
+  size_t sz = taosReadFile(pTSBuf->pFile, &header, sizeof(STSBufFileHeader));
   UNUSED(sz);
 
   // invalid file
@@ -112,8 +114,8 @@ STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
     return NULL; 
   } 
   
-  //int64_t pos = ftell(pTSBuf->f); //pos not used
-  sz = fread(buf, infoSize, 1, pTSBuf->f);
+  //int64_t pos = ftell(pTSBuf->pFile); //pos not used
+  sz = taosReadFile(pTSBuf->pFile, buf, infoSize);
   UNUSED(sz);
   
   // the length value for each vnode is not kept in file, so does not set the length value
@@ -123,22 +125,22 @@ STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
   }
   free(buf);
   
-  ret = fseek(pTSBuf->f, 0, SEEK_END);
+  ret = taosLSeekFile(pTSBuf->pFile, 0, SEEK_END);
   UNUSED(ret);
   
-  struct stat fileStat;
-  if (fstat(fileno(pTSBuf->f), &fileStat) != 0) {
+  int64_t file_size;
+  if (taosFStatFile(pTSBuf->pFile, &file_size, NULL) != 0) {
     tsBufDestroy(pTSBuf);
     return NULL;
   }
   
-  pTSBuf->fileSize = (uint32_t)fileStat.st_size;
+  pTSBuf->fileSize = (uint32_t)file_size;
   tsBufResetPos(pTSBuf);
   
   // ascending by default
   pTSBuf->cur.order = TSDB_ORDER_ASC;
   
-//  tscDebug("create tsBuf from file:%s, fd:%d, size:%d, numOfGroups:%d, autoDelete:%d", pTSBuf->path, fileno(pTSBuf->f),
+//  tscDebug("create tsBuf from file:%s, fd:%d, size:%d, numOfGroups:%d, autoDelete:%d", pTSBuf->path, fileno(pTSBuf->pFile),
 //           pTSBuf->fileSize, pTSBuf->numOfGroups, pTSBuf->autoDelete);
   
   return pTSBuf;
@@ -156,7 +158,7 @@ void* tsBufDestroy(STSBuf* pTSBuf) {
   tfree(pTSBuf->block.payload);
 
   if (!pTSBuf->remainOpen) {
-    fclose(pTSBuf->f);
+    taosCloseFile(&pTSBuf->pFile);
   }
   
   if (pTSBuf->autoDelete) {
@@ -253,7 +255,7 @@ static void writeDataToDisk(STSBuf* pTSBuf) {
       tsCompressTimestamp(pTsData->rawBuf, pTsData->len, pTsData->len/TSDB_KEYSIZE, pBlock->payload, pTsData->allocSize,
           TWO_STAGE_COMP, pTSBuf->assistBuf, pTSBuf->bufSize);
   
-  int64_t r = fseek(pTSBuf->f, pTSBuf->fileSize, SEEK_SET);
+  int64_t r = taosLSeekFile(pTSBuf->pFile, pTSBuf->fileSize, SEEK_SET);
   assert(r == 0);
   
   /*
@@ -264,30 +266,30 @@ static void writeDataToDisk(STSBuf* pTSBuf) {
    * both side has the compressed length is used to support load data forwards/backwords.
    */
   int32_t metaLen = 0;
-  metaLen += (int32_t)fwrite(&pBlock->tag.nType, 1, sizeof(pBlock->tag.nType), pTSBuf->f);
+  metaLen += (int32_t)taosWriteFile(pTSBuf->pFile, &pBlock->tag.nType, sizeof(pBlock->tag.nType));
 
   int32_t trueLen = pBlock->tag.nLen;
   if (pBlock->tag.nType == TSDB_DATA_TYPE_BINARY || pBlock->tag.nType == TSDB_DATA_TYPE_NCHAR) {
-    metaLen += (int32_t)fwrite(&pBlock->tag.nLen, 1, sizeof(pBlock->tag.nLen), pTSBuf->f);
-    metaLen += (int32_t)fwrite(pBlock->tag.pz, 1, (size_t)pBlock->tag.nLen, pTSBuf->f);
+    metaLen += (int32_t)taosWriteFile(pTSBuf->pFile, &pBlock->tag.nLen, sizeof(pBlock->tag.nLen));
+    metaLen += (int32_t)taosWriteFile(pTSBuf->pFile, pBlock->tag.pz, (size_t)pBlock->tag.nLen);
   } else if (pBlock->tag.nType == TSDB_DATA_TYPE_FLOAT) {
-    metaLen += (int32_t)fwrite(&pBlock->tag.nLen, 1, sizeof(pBlock->tag.nLen), pTSBuf->f);
+    metaLen += (int32_t)taosWriteFile(pTSBuf->pFile, &pBlock->tag.nLen, sizeof(pBlock->tag.nLen));
     float tfloat = (float)pBlock->tag.d;
-    metaLen += (int32_t)fwrite(&tfloat, 1, (size_t) pBlock->tag.nLen, pTSBuf->f);  
+    metaLen += (int32_t)taosWriteFile(pTSBuf->pFile, &tfloat, (size_t) pBlock->tag.nLen);  
   } else if (pBlock->tag.nType != TSDB_DATA_TYPE_NULL) {
-    metaLen += (int32_t)fwrite(&pBlock->tag.nLen, 1, sizeof(pBlock->tag.nLen), pTSBuf->f);
-    metaLen += (int32_t)fwrite(&pBlock->tag.i, 1, (size_t) pBlock->tag.nLen, pTSBuf->f);
+    metaLen += (int32_t)taosWriteFile(pTSBuf->pFile, &pBlock->tag.nLen, sizeof(pBlock->tag.nLen));
+    metaLen += (int32_t)taosWriteFile(pTSBuf->pFile, &pBlock->tag.i, (size_t) pBlock->tag.nLen);
   } else {
     trueLen = 0;
-    metaLen += (int32_t)fwrite(&trueLen, 1, sizeof(pBlock->tag.nLen), pTSBuf->f);
+    metaLen += (int32_t)taosWriteFile(pTSBuf->pFile, &trueLen, sizeof(pBlock->tag.nLen));
   }
 
-  fwrite(&pBlock->numOfElem, sizeof(pBlock->numOfElem), 1, pTSBuf->f);
-  fwrite(&pBlock->compLen, sizeof(pBlock->compLen), 1, pTSBuf->f);
-  fwrite(pBlock->payload, (size_t)pBlock->compLen, 1, pTSBuf->f);
-  fwrite(&pBlock->compLen, sizeof(pBlock->compLen), 1, pTSBuf->f);
+  taosWriteFile(pTSBuf->pFile, &pBlock->numOfElem, sizeof(pBlock->numOfElem));
+  taosWriteFile(pTSBuf->pFile, &pBlock->compLen, sizeof(pBlock->compLen));
+  taosWriteFile(pTSBuf->pFile, pBlock->payload, (size_t)pBlock->compLen);
+  taosWriteFile(pTSBuf->pFile, &pBlock->compLen, sizeof(pBlock->compLen));
 
-  metaLen += (int32_t) fwrite(&trueLen, 1, sizeof(pBlock->tag.nLen), pTSBuf->f);
+  metaLen += (int32_t) taosWriteFile(pTSBuf->pFile, &trueLen, sizeof(pBlock->tag.nLen));
   assert(metaLen == getTagAreaLength(&pBlock->tag));
 
   int32_t blockSize = metaLen + sizeof(pBlock->numOfElem) + sizeof(pBlock->compLen) * 2 + pBlock->compLen;
@@ -332,20 +334,20 @@ STSBlock* readDataFromDisk(STSBuf* pTSBuf, int32_t order, bool decomp) {
      * the end of each comp data block
      */
     int32_t prev = -(int32_t) (sizeof(pBlock->padding) + sizeof(pBlock->tag.nLen));
-    int32_t ret = fseek(pTSBuf->f, prev, SEEK_CUR);
-    size_t sz = fread(&pBlock->padding, 1, sizeof(pBlock->padding), pTSBuf->f);
-    sz = fread(&pBlock->tag.nLen, 1, sizeof(pBlock->tag.nLen), pTSBuf->f);
+    int32_t ret = taosLSeekFile(pTSBuf->pFile, prev, SEEK_CUR);
+    size_t sz = taosReadFile(pTSBuf->pFile, &pBlock->padding, sizeof(pBlock->padding));
+    sz = taosReadFile(pTSBuf->pFile, &pBlock->tag.nLen, sizeof(pBlock->tag.nLen));
     UNUSED(sz); 
 
     pBlock->compLen = pBlock->padding;
 
     offset = pBlock->compLen + sizeof(pBlock->compLen) * 2 + sizeof(pBlock->numOfElem) + getTagAreaLength(&pBlock->tag);
-    ret = fseek(pTSBuf->f, -offset, SEEK_CUR);
+    ret = taosLSeekFile(pTSBuf->pFile, -offset, SEEK_CUR);
     UNUSED(ret);
   }
 
-  int32_t ret = fread(&pBlock->tag.nType, sizeof(pBlock->tag.nType), 1, pTSBuf->f);
-  ret = fread(&pBlock->tag.nLen, sizeof(pBlock->tag.nLen), 1, pTSBuf->f);
+  int32_t ret = taosReadFile(pTSBuf->pFile, &pBlock->tag.nType, sizeof(pBlock->tag.nType));
+  ret = taosReadFile(pTSBuf->pFile, &pBlock->tag.nLen, sizeof(pBlock->tag.nLen));
 
   // NOTE: mix types tags are not supported
   size_t sz = 0;
@@ -356,23 +358,23 @@ STSBlock* readDataFromDisk(STSBuf* pTSBuf, int32_t order, bool decomp) {
     memset(tp, 0, pBlock->tag.nLen + 1);
     pBlock->tag.pz = tp;
 
-    sz = fread(pBlock->tag.pz, (size_t)pBlock->tag.nLen, 1, pTSBuf->f);
+    sz = taosReadFile(pTSBuf->pFile, pBlock->tag.pz, (size_t)pBlock->tag.nLen);
     UNUSED(sz);
   } else if (pBlock->tag.nType == TSDB_DATA_TYPE_FLOAT) {
     float tfloat = 0;
-    sz = fread(&tfloat, (size_t) pBlock->tag.nLen, 1, pTSBuf->f);
+    sz = taosReadFile(pTSBuf->pFile, &tfloat, (size_t) pBlock->tag.nLen);
     pBlock->tag.d = (double)tfloat;
     UNUSED(sz);
   } else if (pBlock->tag.nType != TSDB_DATA_TYPE_NULL) { //TODO check the return value
-    sz = fread(&pBlock->tag.i, (size_t) pBlock->tag.nLen, 1, pTSBuf->f);
+    sz = taosReadFile(pTSBuf->pFile, &pBlock->tag.i, (size_t) pBlock->tag.nLen);
     UNUSED(sz);
   }
 
-  sz = fread(&pBlock->numOfElem, sizeof(pBlock->numOfElem), 1, pTSBuf->f);
+  sz = taosReadFile(pTSBuf->pFile, &pBlock->numOfElem, sizeof(pBlock->numOfElem));
   UNUSED(sz);
-  sz = fread(&pBlock->compLen, sizeof(pBlock->compLen), 1, pTSBuf->f);
+  sz = taosReadFile(pTSBuf->pFile, &pBlock->compLen, sizeof(pBlock->compLen));
   UNUSED(sz);
-  sz = fread(pBlock->payload, (size_t)pBlock->compLen, 1, pTSBuf->f);
+  sz = taosReadFile(pTSBuf->pFile, pBlock->payload, (size_t)pBlock->compLen);
 
   if (decomp) {
     pTSBuf->tsData.len =
@@ -381,11 +383,11 @@ STSBlock* readDataFromDisk(STSBuf* pTSBuf, int32_t order, bool decomp) {
   }
   
   // read the comp length at the length of comp block
-  sz = fread(&pBlock->padding, sizeof(pBlock->padding), 1, pTSBuf->f);
+  sz = taosReadFile(pTSBuf->pFile, &pBlock->padding, sizeof(pBlock->padding));
   assert(pBlock->padding == pBlock->compLen);
 
   int32_t n = 0;
-  sz = fread(&n, sizeof(pBlock->tag.nLen), 1, pTSBuf->f);
+  sz = taosReadFile(pTSBuf->pFile, &n, sizeof(pBlock->tag.nLen));
   if (pBlock->tag.nType == TSDB_DATA_TYPE_NULL) {
     assert(n == 0);
   } else {
@@ -396,7 +398,7 @@ STSBlock* readDataFromDisk(STSBuf* pTSBuf, int32_t order, bool decomp) {
   
   // for backwards traverse, set the start position at the end of previous block
   if (order == TSDB_ORDER_DESC) {
-    int32_t r = fseek(pTSBuf->f, -offset, SEEK_CUR);
+    int32_t r = taosLSeekFile(pTSBuf->pFile, -offset, SEEK_CUR);
     UNUSED(r);
   }
   
@@ -512,7 +514,7 @@ static int32_t tsBufFindGroupById(STSGroupBlockInfoEx* pGroupInfoEx, int32_t num
 
 // todo opt performance by cache blocks info
 static int32_t tsBufFindBlock(STSBuf* pTSBuf, STSGroupBlockInfo* pBlockInfo, int32_t blockIndex) {
-  if (fseek(pTSBuf->f, pBlockInfo->offset, SEEK_SET) != 0) {
+  if (taosLSeekFile(pTSBuf->pFile, pBlockInfo->offset, SEEK_SET) != 0) {
     return -1;
   }
   
@@ -531,7 +533,7 @@ static int32_t tsBufFindBlock(STSBuf* pTSBuf, STSGroupBlockInfo* pBlockInfo, int
     STSBlock* pBlock = &pTSBuf->block;
     int32_t   compBlockSize =
         pBlock->compLen + sizeof(pBlock->compLen) * 2 + sizeof(pBlock->numOfElem) + getTagAreaLength(&pBlock->tag);
-    int32_t ret = fseek(pTSBuf->f, -compBlockSize, SEEK_CUR);
+    int32_t ret = taosLSeekFile(pTSBuf->pFile, -compBlockSize, SEEK_CUR);
     UNUSED(ret);
   }
   
@@ -548,7 +550,7 @@ static int32_t tsBufFindBlockByTag(STSBuf* pTSBuf, STSGroupBlockInfo* pBlockInfo
     offset = pBlockInfo->offset + pBlockInfo->compLen;
   }
   
-  if (fseek(pTSBuf->f, (int32_t)offset, SEEK_SET) != 0) {
+  if (taosLSeekFile(pTSBuf->pFile, (int32_t)offset, SEEK_SET) != 0) {
     return -1;
   }
   
@@ -618,11 +620,11 @@ static int32_t doUpdateGroupInfo(STSBuf* pTSBuf, int64_t offset, STSGroupBlockIn
     return -1;
   }
 
-  if (fseek(pTSBuf->f, (int32_t)offset, SEEK_SET) != 0) {
+  if (taosLSeekFile(pTSBuf->pFile, (int32_t)offset, SEEK_SET) != 0) {
     return -1;
   }
 
-  fwrite(pVInfo, sizeof(STSGroupBlockInfo), 1, pTSBuf->f);
+  taosWriteFile(pTSBuf->pFile, pVInfo, sizeof(STSGroupBlockInfo));
   return 0;
 }
 
@@ -636,19 +638,19 @@ STSGroupBlockInfo* tsBufGetGroupBlockInfo(STSBuf* pTSBuf, int32_t id) {
 }
 
 int32_t STSBufUpdateHeader(STSBuf* pTSBuf, STSBufFileHeader* pHeader) {
-  if ((pTSBuf->f == NULL) || pHeader == NULL || pHeader->numOfGroup == 0 || pHeader->magic != TS_COMP_FILE_MAGIC) {
+  if ((pTSBuf->pFile == NULL) || pHeader == NULL || pHeader->numOfGroup == 0 || pHeader->magic != TS_COMP_FILE_MAGIC) {
     return -1;
   }
 
   assert(pHeader->tsOrder == TSDB_ORDER_ASC || pHeader->tsOrder == TSDB_ORDER_DESC);
 
-  int32_t r = fseek(pTSBuf->f, 0, SEEK_SET);
+  int32_t r = taosLSeekFile(pTSBuf->pFile, 0, SEEK_SET);
   if (r != 0) {
 //    qError("fseek failed, errno:%d", errno);
     return -1;
   }
 
-  size_t ws = fwrite(pHeader, sizeof(STSBufFileHeader), 1, pTSBuf->f);
+  size_t ws = taosWriteFile(pTSBuf->pFile, pHeader, sizeof(STSBufFileHeader));
   if (ws != 1) {    
 //    qError("ts update header fwrite failed, size:%d, expected size:%d", (int32_t)ws, (int32_t)sizeof(STSBufFileHeader));
     return -1;
@@ -823,12 +825,12 @@ int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf) {
     pBlockInfoEx->info.id = id;
   }
   
-  int32_t r = fseek(pDestBuf->f, 0, SEEK_END);
+  int32_t r = taosLSeekFile(pDestBuf->pFile, 0, SEEK_END);
   assert(r == 0);
   
   int64_t offset = getDataStartOffset();
   int32_t size = (int32_t)pSrcBuf->fileSize - (int32_t)offset;
-  int64_t written = taosFSendFile(pDestBuf->f, pSrcBuf->f, &offset, size);
+  int64_t written = taosFSendFile(pDestBuf->pFile, pSrcBuf->pFile, &offset, size);
   
   if (written == -1 || written != size) {
     return -1;
@@ -839,17 +841,18 @@ int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf) {
   int32_t oldSize = pDestBuf->fileSize;
 
   // file meta data may be cached, close and reopen the file for accurate file size.
-  fclose(pDestBuf->f);
-  pDestBuf->f = fopen(pDestBuf->path, "rb+");
-  if (pDestBuf->f == NULL) {
+  taosCloseFile(&pDestBuf->pFile);
+  // pDestBuf->pFile = fopen(pDestBuf->path, "rb+");
+  pDestBuf->pFile = taosOpenFile(pDestBuf->path, TD_FILE_WRITE | TD_FILE_READ);
+  if (pDestBuf->pFile == NULL) {
     return -1;
   }
 
-  struct stat fileStat;
-  if (fstat(fileno(pDestBuf->f), &fileStat) != 0) {
+  int64_t file_size;
+  if (taosFStatFile(pDestBuf->pFile, &file_size, NULL) != 0) {
     return -1;  
   }
-  pDestBuf->fileSize = (uint32_t)fileStat.st_size;
+  pDestBuf->fileSize = (uint32_t)file_size;
 
   assert(pDestBuf->fileSize == oldSize + size);
 
@@ -868,13 +871,13 @@ STSBuf* tsBufCreateFromCompBlocks(const char* pData, int32_t numOfBlocks, int32_
   // update prev vnode length info in file
   TSBufUpdateGroupInfo(pTSBuf, pTSBuf->numOfGroups - 1, pBlockInfo);
   
-  int32_t ret = fseek(pTSBuf->f, pBlockInfo->offset, SEEK_SET);
+  int32_t ret = taosLSeekFile(pTSBuf->pFile, pBlockInfo->offset, SEEK_SET);
   if (ret == -1) {
 //    qError("fseek failed, errno:%d", errno);
     tsBufDestroy(pTSBuf);
     return NULL;
   }
-  size_t sz = fwrite((void*)pData, 1, len, pTSBuf->f);
+  size_t sz = taosWriteFile(pTSBuf->pFile, (void*)pData, len);
   if (sz != len) {
 //    qError("ts data fwrite failed, write size:%d, expected size:%d", (int32_t)sz, len);
     tsBufDestroy(pTSBuf);
@@ -893,7 +896,7 @@ STSBuf* tsBufCreateFromCompBlocks(const char* pData, int32_t numOfBlocks, int32_
   }
 
   // TODO taosFsync??
-//  if (taosFsync(fileno(pTSBuf->f)) == -1) {
+//  if (taosFsync(fileno(pTSBuf->pFile)) == -1) {
 ////    qError("fsync failed, errno:%d", errno);
 //    tsBufDestroy(pTSBuf);
 //    return NULL;
@@ -1071,15 +1074,15 @@ int32_t dumpFileBlockByGroupId(STSBuf* pTSBuf, int32_t groupIndex, void* buf, in
   *len = 0;
   *numOfBlocks = 0;
 
-  if (fseek(pTSBuf->f, pBlockInfo->offset, SEEK_SET) != 0) {
-    int code = TAOS_SYSTEM_ERROR(ferror(pTSBuf->f));
+  if (taosLSeekFile(pTSBuf->pFile, pBlockInfo->offset, SEEK_SET) != 0) {
+    int code = TAOS_SYSTEM_ERROR(taosEOFFile(pTSBuf->pFile));
 //    qError("%p: fseek failed: %s", pSql, tstrerror(code));
     return code;
   }
 
-  size_t s = fread(buf, 1, pBlockInfo->compLen, pTSBuf->f);
+  size_t s = taosReadFile(pTSBuf->pFile, buf, pBlockInfo->compLen);
   if (s != pBlockInfo->compLen) {
-    int code = TAOS_SYSTEM_ERROR(ferror(pTSBuf->f));
+    int code = TAOS_SYSTEM_ERROR(taosEOFFile(pTSBuf->pFile));
 //    tscError("%p: fread didn't return expected data: %s", pSql, tstrerror(code));
     return code;
   }

source/dnode/mgmt/daemon/CMakeLists.txt

@@ -6,4 +6,4 @@ target_include_directories(
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 
-target_link_libraries(taosd dnode config util os)
+target_link_libraries(taosd dnode util os)

source/dnode/mgmt/daemon/inc/dmnInt.h

@@ -17,7 +17,7 @@
 #ifndef _TD_DMN_INT_H_
 #define _TD_DMN_INT_H_
 
-#include "config.h"
+#include "tconfig.h"
 #include "dnode.h"
 #include "taoserror.h"
 #include "tglobal.h"
@@ -28,15 +28,9 @@
 extern "C" {
 #endif
 
-int32_t dmnAddLogCfg(SConfig *pCfg);
-int32_t dmnInitLog(const char *cfgDir, const char *envFile, const char *apolloUrl);
-int32_t dmnLoadCfg(SConfig *pConfig, const char *inputCfgDir, const char *envFile, const char *apolloUrl);
+SDnodeObjCfg dmnGetObjCfg();
 
-SConfig     *dmnReadCfg(const char *cfgDir, const char *envFile, const char *apolloUrl);
-SDnodeEnvCfg dmnGetEnvCfg(SConfig *pCfg);
-SDnodeObjCfg dmnGetObjCfg(SConfig *pCfg);
-
-void dmnDumpCfg(SConfig *pCfg);
+void dmnDumpCfg();
 void dmnPrintVersion();
 void dmnGenerateGrant();
 

source/dnode/mgmt/daemon/src/dmnCfg.c

@@ -15,190 +15,14 @@
 
 #define _DEFAULT_SOURCE
 #include "dmnInt.h"
-#include "tlocale.h"
-#include "ttimezone.h"
+#include "tconfig.h"
 
-static int32_t dmnAddEpCfg(SConfig *pCfg) {
-  char defaultFqdn[TSDB_FQDN_LEN] = {0};
-  if (taosGetFqdn(defaultFqdn) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    return -1;
-  }
-  if (cfgAddString(pCfg, "fqdn", defaultFqdn) != 0) return -1;
-
-  int32_t defaultServerPort = 6030;
-  if (cfgAddInt32(pCfg, "serverPort", defaultServerPort, 1, 65056) != 0) return -1;
-
-  char defaultFirstEp[TSDB_EP_LEN] = {0};
-  char defaultSecondEp[TSDB_EP_LEN] = {0};
-  snprintf(defaultFirstEp, TSDB_EP_LEN, "%s:%d", defaultFqdn, defaultServerPort);
-  snprintf(defaultSecondEp, TSDB_EP_LEN, "%s:%d", defaultFqdn, defaultServerPort);
-  if (cfgAddString(pCfg, "firstEp", defaultFirstEp) != 0) return -1;
-  if (cfgAddString(pCfg, "secondEp", defaultSecondEp) != 0) return -1;
-
-  return 0;
-}
-
-static int32_t dmnAddDirCfg(SConfig *pCfg) {
-  if (cfgAddDir(pCfg, "dataDir", tsDataDir) != 0) return -1;
-  if (cfgAddDir(pCfg, "tempDir", tsTempDir) != 0) return -1;
-  if (cfgAddFloat(pCfg, "minimalDataDirGB", 2.0f, 0.001f, 10000000) != 0) return -1;
-  if (cfgAddFloat(pCfg, "minimalTempDirGB", 1.0f, 0.001f, 10000000) != 0) return -1;
-  return 0;
-}
-
-static int32_t dmnCheckDirCfg(SConfig *pCfg) {
-  tstrncpy(tsDataDir, cfgGetItem(pCfg, "dataDir")->str, PATH_MAX);
-  tstrncpy(tsTempDir, cfgGetItem(pCfg, "tempDir")->str, PATH_MAX);
-  tsDataSpace.reserved = cfgGetItem(pCfg, "minimalDataDirGB")->fval;
-  tsTempSpace.reserved = cfgGetItem(pCfg, "minimalTempDirGB")->fval;
-  return 0;
-}
-
-static int32_t dmnAddVersionCfg(SConfig *pCfg) {
-  if (cfgAddString(pCfg, "buildinfo", buildinfo) != 0) return -1;
-  if (cfgAddString(pCfg, "gitinfo", gitinfo) != 0) return -1;
-  if (cfgAddString(pCfg, "version", version) != 0) return -1;
-  return 0;
-}
-
-static int32_t dmnAddDnodeCfg(SConfig *pCfg) {
-  if (dmnAddEpCfg(pCfg) != 0) return -1;
-  if (dmnAddDirCfg(pCfg) != 0) return -1;
-  if (dmnAddVersionCfg(pCfg) != 0) return -1;
-
-  if (cfgAddTimezone(pCfg, "timezone", "") != 0) return -1;
-  if (cfgAddLocale(pCfg, "locale", "") != 0) return -1;
-  if (cfgAddCharset(pCfg, "charset", "") != 0) return -1;
-  if (cfgAddInt32(pCfg, "numOfCores", 2, 1, 100000) != 0) return -1;
-  if (cfgAddInt32(pCfg, "numOfCommitThreads", 4, 1, 1000) != 0) return -1;
-  if (cfgAddBool(pCfg, "telemetryReporting", 0) != 0) return -1;
-  if (cfgAddBool(pCfg, "enableCoreFile", 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "supportVnodes", 256, 0, 65536) != 0) return -1;
-  if (cfgAddInt32(pCfg, "statusInterval", 1, 1, 30) != 0) return -1;
-  if (cfgAddFloat(pCfg, "numOfThreadsPerCore", 1, 0, 10) != 0) return -1;
-  if (cfgAddFloat(pCfg, "ratioOfQueryCores", 1, 0, 5) != 0) return -1;
-  if (cfgAddInt32(pCfg, "maxShellConns", 50000, 10, 50000000) != 0) return -1;
-  if (cfgAddInt32(pCfg, "shellActivityTimer", 3, 1, 120) != 0) return -1;
-  return 0;
-}
-
-static int32_t dmnCheckCfg(SConfig *pCfg) {
-  bool enableCore = cfgGetItem(pCfg, "enableCoreFile")->bval;
-  taosSetCoreDump(enableCore);
-
-  if (dmnCheckDirCfg(pCfg) != 0) {
-    return -1;
-  }
-
-  taosGetSystemInfo();
-
-  tsSetTimeZone();
-  tsSetLocale();
-
-  if (tsNumOfCores <= 0) {
-    tsNumOfCores = 1;
-  }
-
-  if (tsQueryBufferSize >= 0) {
-    tsQueryBufferSizeBytes = tsQueryBufferSize * 1048576UL;
-  }
-
-  return 0;
-}
-
-SConfig *dmnReadCfg(const char *cfgDir, const char *envFile, const char *apolloUrl) {
-  SConfig *pCfg = cfgInit();
-  if (pCfg == NULL) return NULL;
-
-  if (dmnAddLogCfg(pCfg) != 0) {
-    uError("failed to add log cfg since %s", terrstr());
-    cfgCleanup(pCfg);
-    return NULL;
-  }
-
-  if (dmnAddDnodeCfg(pCfg) != 0) {
-    uError("failed to init dnode cfg since %s", terrstr());
-    cfgCleanup(pCfg);
-    return NULL;
-  }
-
-  if (dmnLoadCfg(pCfg, cfgDir, envFile, apolloUrl) != 0) {
-    uError("failed to load cfg since %s", terrstr());
-    cfgCleanup(pCfg);
-    return NULL;
-  }
-
-  if (dmnCheckCfg(pCfg) != 0) {
-    uError("failed to check cfg since %s", terrstr());
-    cfgCleanup(pCfg);
-    return NULL;
-  }
-
-  cfgDumpCfg(pCfg);
-  return pCfg;
-}
-
-void dmnDumpCfg(SConfig *pCfg) {
-  printf("taos global config:\n");
-  printf("==================================\n");
-
-  SConfigItem *pItem = cfgIterate(pCfg, NULL);
-  while (pItem != NULL) {
-    switch (pItem->dtype) {
-      case CFG_DTYPE_BOOL:
-        printf("cfg:%s, value:%u src:%s\n", pItem->name, pItem->bval, cfgStypeStr(pItem->stype));
-        break;
-      case CFG_DTYPE_INT32:
-        printf("cfg:%s, value:%d src:%s\n", pItem->name, pItem->i32, cfgStypeStr(pItem->stype));
-        break;
-      case CFG_DTYPE_INT64:
-        printf("cfg:%s, value:%" PRId64 " src:%s\n", pItem->name, pItem->i64, cfgStypeStr(pItem->stype));
-        break;
-      case CFG_DTYPE_FLOAT:
-        printf("cfg:%s, value:%f src:%s\n", pItem->name, pItem->fval, cfgStypeStr(pItem->stype));
-        break;
-      case CFG_DTYPE_STRING:
-      case CFG_DTYPE_IPSTR:
-      case CFG_DTYPE_DIR:
-      case CFG_DTYPE_LOCALE:
-      case CFG_DTYPE_CHARSET:
-      case CFG_DTYPE_TIMEZONE:
-        printf("cfg:%s, value:%s src:%s\n", pItem->name, pItem->str, cfgStypeStr(pItem->stype));
-        break;
-    }
-    pItem = cfgIterate(pCfg, pItem);
-  }
-}
-
-SDnodeEnvCfg dmnGetEnvCfg(SConfig *pCfg) {
-  SDnodeEnvCfg envCfg = {0};
-
-  const char *vstr = cfgGetItem(pCfg, "version")->str;
-  envCfg.sver = 30000000;
-  tstrncpy(envCfg.buildinfo, cfgGetItem(pCfg, "buildinfo")->str, sizeof(envCfg.buildinfo));
-  tstrncpy(envCfg.gitinfo, cfgGetItem(pCfg, "gitinfo")->str, sizeof(envCfg.gitinfo));
-  tstrncpy(envCfg.timezone, cfgGetItem(pCfg, "timezone")->str, sizeof(envCfg.timezone));
-  tstrncpy(envCfg.locale, cfgGetItem(pCfg, "locale")->str, sizeof(envCfg.locale));
-  tstrncpy(envCfg.charset, cfgGetItem(pCfg, "charset")->str, sizeof(envCfg.charset));
-  envCfg.numOfCores = cfgGetItem(pCfg, "numOfCores")->i32;
-  envCfg.numOfCommitThreads = (uint16_t)cfgGetItem(pCfg, "numOfCommitThreads")->i32;
-  envCfg.enableTelem = cfgGetItem(pCfg, "telemetryReporting")->bval;
-
-  return envCfg;
-}
-
-SDnodeObjCfg dmnGetObjCfg(SConfig *pCfg) {
+SDnodeObjCfg dmnGetObjCfg() {
+  SConfig *pCfg = taosGetCfg();
   SDnodeObjCfg objCfg = {0};
 
   objCfg.numOfSupportVnodes = cfgGetItem(pCfg, "supportVnodes")->i32;
-  objCfg.statusInterval = cfgGetItem(pCfg, "statusInterval")->i32;
-  objCfg.numOfThreadsPerCore = cfgGetItem(pCfg, "numOfThreadsPerCore")->fval;
-  objCfg.ratioOfQueryCores = cfgGetItem(pCfg, "ratioOfQueryCores")->fval;
-  objCfg.maxShellConns = cfgGetItem(pCfg, "maxShellConns")->i32;
-  objCfg.shellActivityTimer = cfgGetItem(pCfg, "shellActivityTimer")->i32;
   tstrncpy(objCfg.dataDir, cfgGetItem(pCfg, "dataDir")->str, sizeof(objCfg.dataDir));
-
   tstrncpy(objCfg.firstEp, cfgGetItem(pCfg, "firstEp")->str, sizeof(objCfg.firstEp));
   tstrncpy(objCfg.secondEp, cfgGetItem(pCfg, "secondEp")->str, sizeof(objCfg.firstEp));
   objCfg.serverPort = (uint16_t)cfgGetItem(pCfg, "serverPort")->i32;
@@ -206,3 +30,8 @@ SDnodeObjCfg dmnGetObjCfg(SConfig *pCfg) {
   snprintf(objCfg.localEp, sizeof(objCfg.localEp), "%s:%u", objCfg.localFqdn, objCfg.serverPort);
   return objCfg;
 }
+
+void dmnDumpCfg() {
+  SConfig *pCfg = taosGetCfg();
+  cfgDumpCfg(pCfg, 0, 1);
+}
\ No newline at end of file

source/dnode/mgmt/daemon/src/dmnLog.c

-/*
- * 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 "dmnInt.h"
-
-int32_t dmnAddLogCfg(SConfig *pCfg) {
-  if (cfgAddDir(pCfg, "logDir", "/var/log/taos") != 0) return -1;
-  if (cfgAddFloat(pCfg, "minimalLogDirGB", 1.0f, 0.001f, 10000000) != 0) return -1;
-  if (cfgAddBool(pCfg, "asyncLog", 1) != 0) return -1;
-  if (cfgAddInt32(pCfg, "numOfLogLines", 10000000, 1000, 2000000000) != 0) return -1;
-  if (cfgAddInt32(pCfg, "logKeepDays", 0, -365000, 365000) != 0) return -1;
-  if (cfgAddInt32(pCfg, "debugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "dDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "vDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "mDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "cDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "jniDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "tmrDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "uDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "rpcDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "qDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "wDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "sDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "tsdbDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "tqDebugFlag", 0, 0, 255) != 0) return -1;
-  if (cfgAddInt32(pCfg, "fsDebugFlag", 0, 0, 255) != 0) return -1;
-  return 0;
-}
-
-int32_t dmnSetLogCfg(SConfig *pCfg) {
-  tstrncpy(tsLogDir, cfgGetItem(pCfg, "logDir")->str, PATH_MAX);
-  tsLogSpace.reserved = cfgGetItem(pCfg, "minimalLogDirGB")->fval;
-  tsAsyncLog = cfgGetItem(pCfg, "asyncLog")->bval;
-  tsNumOfLogLines = cfgGetItem(pCfg, "numOfLogLines")->i32;
-  tsLogKeepDays = cfgGetItem(pCfg, "logKeepDays")->i32;
-  dDebugFlag = cfgGetItem(pCfg, "dDebugFlag")->i32;
-  vDebugFlag = cfgGetItem(pCfg, "vDebugFlag")->i32;
-  mDebugFlag = cfgGetItem(pCfg, "mDebugFlag")->i32;
-  cDebugFlag = cfgGetItem(pCfg, "cDebugFlag")->i32;
-  jniDebugFlag = cfgGetItem(pCfg, "jniDebugFlag")->i32;
-  tmrDebugFlag = cfgGetItem(pCfg, "tmrDebugFlag")->i32;
-  uDebugFlag = cfgGetItem(pCfg, "uDebugFlag")->i32;
-  rpcDebugFlag = cfgGetItem(pCfg, "rpcDebugFlag")->i32;
-  qDebugFlag = cfgGetItem(pCfg, "qDebugFlag")->i32;
-  wDebugFlag = cfgGetItem(pCfg, "wDebugFlag")->i32;
-  sDebugFlag = cfgGetItem(pCfg, "sDebugFlag")->i32;
-  tsdbDebugFlag = cfgGetItem(pCfg, "tsdbDebugFlag")->i32;
-  tqDebugFlag = cfgGetItem(pCfg, "tqDebugFlag")->i32;
-  fsDebugFlag = cfgGetItem(pCfg, "fsDebugFlag")->i32;
-
-  int32_t debugFlag = cfgGetItem(pCfg, "debugFlag")->i32;
-  taosSetAllDebugFlag(debugFlag);
-
-  return 0;
-}
-
-int32_t dmnInitLog(const char *cfgDir, const char *envFile, const char *apolloUrl) {
-  SConfig *pCfg = cfgInit();
-  if (pCfg == NULL) return -1;
-
-  if (dmnAddLogCfg(pCfg) != 0) {
-    printf("failed to add log cfg since %s\n", terrstr());
-    cfgCleanup(pCfg);
-    return -1;
-  }
-
-  if (dmnLoadCfg(pCfg, cfgDir, envFile, apolloUrl) != 0) {
-    printf("failed to load log cfg since %s\n", terrstr());
-    cfgCleanup(pCfg);
-    return -1;
-  }
-
-  if (dmnSetLogCfg(pCfg) != 0) {
-    printf("failed to set log cfg since %s\n", terrstr());
-    cfgCleanup(pCfg);
-    return -1;
-  }
-
-  if (taosInitLog("taosdlog", 1) != 0) {
-    printf("failed to init log file since %s\n", terrstr());
-    cfgCleanup(pCfg);
-    return -1;
-  }
-
-  cfgCleanup(pCfg);
-  return 0;
-}
-
-int32_t dmnLoadCfg(SConfig *pConfig, const char *inputCfgDir, const char *envFile, const char *apolloUrl) {
-  char configDir[PATH_MAX] = {0};
-  char configFile[PATH_MAX + 100] = {0};
-
-  taosExpandDir(inputCfgDir, configDir, PATH_MAX);
-  snprintf(configFile, sizeof(configFile), "%s" TD_DIRSEP "taos.cfg", configDir);
-
-  if (cfgLoad(pConfig, CFG_STYPE_APOLLO_URL, apolloUrl) != 0) {
-    uError("failed to load from apollo url:%s since %s\n", apolloUrl, terrstr());
-    return -1;
-  }
-
-  if (cfgLoad(pConfig, CFG_STYPE_CFG_FILE, configFile) != 0) {
-    if (cfgLoad(pConfig, CFG_STYPE_CFG_FILE, configDir) != 0) {
-      uError("failed to load from config file:%s since %s\n", configFile, terrstr());
-      return -1;
-    }
-  }
-
-  if (cfgLoad(pConfig, CFG_STYPE_ENV_FILE, envFile) != 0) {
-    uError("failed to load from env file:%s since %s\n", envFile, terrstr());
-    return -1;
-  }
-
-  if (cfgLoad(pConfig, CFG_STYPE_ENV_VAR, NULL) != 0) {
-    uError("failed to load from global env variables since %s\n", terrstr());
-    return -1;
-  }
-
-  return 0;
-}

source/dnode/mgmt/daemon/src/dmnMain.c

@@ -72,14 +72,13 @@ static int32_t dmnParseOption(int32_t argc, char const *argv[]) {
   return 0;
 }
 
-int32_t dmnRunDnode(SConfig *pCfg) {
-  SDnodeEnvCfg envCfg = dmnGetEnvCfg(pCfg);
-  if (dndInit(&envCfg) != 0) {
+int32_t dmnRunDnode() {
+  if (dndInit() != 0) {
     uInfo("Failed to start TDengine, please check the log");
     return -1;
   }
 
-  SDnodeObjCfg objCfg = dmnGetObjCfg(pCfg);
+  SDnodeObjCfg objCfg = dmnGetObjCfg();
   SDnode      *pDnode = dndCreate(&objCfg);
   if (pDnode == NULL) {
     uInfo("Failed to start TDengine, please check the log");
@@ -93,6 +92,7 @@ int32_t dmnRunDnode(SConfig *pCfg) {
   dndClose(pDnode);
   dndCleanup();
   taosCloseLog();
+  taosCleanupCfg();
   return 0;
 }
 
@@ -111,23 +111,21 @@ int main(int argc, char const *argv[]) {
     return 0;
   }
 
-  if (dmnInitLog(configDir, dmn.envFile, dmn.apolloUrl) != 0) {
+  if (taosCreateLog("taosdlog", 1, configDir, dmn.envFile, dmn.apolloUrl, 0) != 0) {
+    uInfo("Failed to start TDengine since read config error");
     return -1;
   }
 
-  SConfig *pCfg = dmnReadCfg(configDir, dmn.envFile, dmn.apolloUrl);
-  if (pCfg == NULL) {
+  if (taosInitCfg(configDir, dmn.envFile, dmn.apolloUrl, 0) != 0) {
     uInfo("Failed to start TDengine since read config error");
     return -1;
   }
 
   if (dmn.dumpConfig) {
-    dmnDumpCfg(pCfg);
-    cfgCleanup(pCfg);
+    dmnDumpCfg();
+    taosCleanupCfg();
     return 0;
   }
 
-  int32_t code = dmnRunDnode(pCfg);
-  cfgCleanup(pCfg);
-  return code;
+  return dmnRunDnode();
 }

source/dnode/mgmt/impl/inc/dndEnv.h

@@ -124,9 +124,8 @@ typedef struct {
 typedef struct SDnode {
   EStat        stat;
   SDnodeObjCfg cfg;
-  SDnodeEnvCfg env;
   SDnodeDir    dir;
-  FileFd       lockFd;
+  TdFilePtr    pLockFile;
   SDnodeMgmt   dmgmt;
   SMnodeMgmt   mmgmt;
   SQnodeMgmt   qmgmt;
@@ -138,11 +137,6 @@ typedef struct SDnode {
   SStartupReq  startup;
 } SDnode;
 
-typedef struct {
-  int8_t       once;
-  SDnodeEnvCfg cfg;
-} SDnodeEnv;
-
 #ifdef __cplusplus
 }
 #endif

source/dnode/mgmt/impl/inc/dndInt.h

@@ -35,6 +35,7 @@ extern "C" {
 #include "tthread.h"
 #include "ttime.h"
 #include "tworker.h"
+#include "tglobal.h"
 
 #include "dnode.h"
 

source/dnode/mgmt/impl/src/dndBnode.c

@@ -62,14 +62,15 @@ static int32_t dndReadBnodeFile(SDnode *pDnode) {
   char file[PATH_MAX + 20];
   snprintf(file, PATH_MAX + 20, "%s/bnode.json", pDnode->dir.dnode);
 
-  FILE *fp = fopen(file, "r");
-  if (fp == NULL) {
+  // FILE *fp = fopen(file, "r");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_READ);
+  if (pFile == NULL) {
     dDebug("file %s not exist", file);
     code = 0;
     goto PRASE_BNODE_OVER;
   }
 
-  len = (int32_t)fread(content, 1, maxLen, fp);
+  len = (int32_t)taosReadFile(pFile, content, maxLen);
   if (len <= 0) {
     dError("failed to read %s since content is null", file);
     goto PRASE_BNODE_OVER;
@@ -102,7 +103,7 @@ static int32_t dndReadBnodeFile(SDnode *pDnode) {
 PRASE_BNODE_OVER:
   if (content != NULL) free(content);
   if (root != NULL) cJSON_Delete(root);
-  if (fp != NULL) fclose(fp);
+  if (pFile != NULL) taosCloseFile(&pFile);
 
   terrno = code;
   return code;
@@ -114,8 +115,9 @@ static int32_t dndWriteBnodeFile(SDnode *pDnode) {
   char file[PATH_MAX + 20];
   snprintf(file, PATH_MAX + 20, "%s/bnode.json", pDnode->dir.dnode);
 
-  FILE *fp = fopen(file, "w");
-  if (fp == NULL) {
+  // FILE *fp = fopen(file, "w");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
     terrno = TSDB_CODE_DND_BNODE_WRITE_FILE_ERROR;
     dError("failed to write %s since %s", file, terrstr());
     return -1;
@@ -130,9 +132,9 @@ static int32_t dndWriteBnodeFile(SDnode *pDnode) {
   len += snprintf(content + len, maxLen - len, "  \"dropped\": %d\n", pMgmt->dropped);
   len += snprintf(content + len, maxLen - len, "}\n");
 
-  fwrite(content, 1, len, fp);
-  taosFsyncFile(fileno(fp));
-  fclose(fp);
+  taosWriteFile(pFile, content, len);
+  taosFsyncFile(pFile);
+  taosCloseFile(&pFile);
   free(content);
 
   char realfile[PATH_MAX + 20];
@@ -179,7 +181,7 @@ static void dndBuildBnodeOption(SDnode *pDnode, SBnodeOpt *pOption) {
   pOption->sendRedirectRspFp = dndSendRedirectRsp;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
-  pOption->sver = pDnode->env.sver;
+  pOption->sver = tsVersion;
 }
 
 static int32_t dndOpenBnode(SDnode *pDnode) {

source/dnode/mgmt/impl/src/dndEnv.c

@@ -25,7 +25,7 @@
 #include "tfs.h"
 #include "wal.h"
 
-static SDnodeEnv dndEnv = {0};
+static int8_t once = DND_ENV_INIT;
 
 EStat dndGetStat(SDnode *pDnode) { return pDnode->stat; }
 
@@ -59,31 +59,31 @@ void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
   pStartup->finished = (dndGetStat(pDnode) == DND_STAT_RUNNING);
 }
 
-static FileFd dndCheckRunning(char *dataDir) {
+static TdFilePtr dndCheckRunning(char *dataDir) {
   char filepath[PATH_MAX] = {0};
   snprintf(filepath, sizeof(filepath), "%s/.running", dataDir);
 
-  FileFd fd = taosOpenFileCreateWriteTrunc(filepath);
-  if (fd < 0) {
+  TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     dError("failed to lock file:%s since %s, quit", filepath, terrstr());
-    return -1;
+    return NULL;
   }
 
-  int32_t ret = taosLockFile(fd);
+  int32_t ret = taosLockFile(pFile);
   if (ret != 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     dError("failed to lock file:%s since %s, quit", filepath, terrstr());
-    taosCloseFile(fd);
-    return -1;
+    taosCloseFile(&pFile);
+    return NULL;
   }
 
-  return fd;
+  return pFile;
 }
 
 static int32_t dndCreateImp(SDnode *pDnode, SDnodeObjCfg *pCfg) {
-  pDnode->lockFd = dndCheckRunning(pCfg->dataDir);
-  if (pDnode->lockFd < 0) {
+  pDnode->pLockFile = dndCheckRunning(pCfg->dataDir);
+  if (pDnode->pLockFile == NULL) {
     return -1;
   }
 
@@ -137,7 +137,6 @@ static int32_t dndCreateImp(SDnode *pDnode, SDnodeObjCfg *pCfg) {
   }
 
   memcpy(&pDnode->cfg, pCfg, sizeof(SDnodeObjCfg));
-  memcpy(&pDnode->env, &dndEnv.cfg, sizeof(SDnodeEnvCfg));
   return 0;
 }
 
@@ -148,10 +147,10 @@ static void dndCloseImp(SDnode *pDnode) {
   tfree(pDnode->dir.snode);
   tfree(pDnode->dir.bnode);
 
-  if (pDnode->lockFd >= 0) {
-    taosUnLockFile(pDnode->lockFd);
-    taosCloseFile(pDnode->lockFd);
-    pDnode->lockFd = 0;
+  if (pDnode->pLockFile != NULL) {
+    taosUnLockFile(pDnode->pLockFile);
+    taosCloseFile(&pDnode->pLockFile);
+    pDnode->pLockFile = NULL;
   }
 }
 
@@ -259,8 +258,8 @@ void dndClose(SDnode *pDnode) {
   dInfo("dnode object is closed, data:%p", pDnode);
 }
 
-int32_t dndInit(const SDnodeEnvCfg *pCfg) {
-  if (atomic_val_compare_exchange_8(&dndEnv.once, DND_ENV_INIT, DND_ENV_READY) != DND_ENV_INIT) {
+int32_t dndInit() {
+  if (atomic_val_compare_exchange_8(&once, DND_ENV_INIT, DND_ENV_READY) != DND_ENV_INIT) {
     terrno = TSDB_CODE_REPEAT_INIT;
     dError("failed to init dnode env since %s", terrstr());
     return -1;
@@ -283,11 +282,8 @@ int32_t dndInit(const SDnodeEnvCfg *pCfg) {
   }
 
   SVnodeOpt vnodeOpt = {
-      .sver = pCfg->sver,
-      .timezone = pCfg->timezone,
-      .locale = pCfg->locale,
-      .charset = pCfg->charset,
-      .nthreads = pCfg->numOfCommitThreads,
+      .sver = tsVersion,
+      .nthreads = tsNumOfCommitThreads,
       .putReqToVQueryQFp = dndPutReqToVQueryQ,
       .sendReqToDnodeFp = dndSendReqToDnode
   };
@@ -298,13 +294,12 @@ int32_t dndInit(const SDnodeEnvCfg *pCfg) {
     return -1;
   }
 
-  memcpy(&dndEnv.cfg, pCfg, sizeof(SDnodeEnvCfg));
   dInfo("dnode env is initialized");
   return 0;
 }
 
 void dndCleanup() {
-  if (atomic_val_compare_exchange_8(&dndEnv.once, DND_ENV_READY, DND_ENV_CLEANUP) != DND_ENV_READY) {
+  if (atomic_val_compare_exchange_8(&once, DND_ENV_READY, DND_ENV_CLEANUP) != DND_ENV_READY) {
     dError("dnode env is already cleaned up");
     return;
   }

source/dnode/mgmt/impl/src/dndMgmt.c

@@ -185,16 +185,16 @@ static int32_t dndReadDnodes(SDnode *pDnode) {
   int32_t maxLen = 256 * 1024;
   char   *content = calloc(1, maxLen + 1);
   cJSON  *root = NULL;
-  FILE   *fp = NULL;
 
-  fp = fopen(pMgmt->file, "r");
-  if (fp == NULL) {
+  // fp = fopen(pMgmt->file, "r");
+  TdFilePtr pFile = taosOpenFile(pMgmt->file, TD_FILE_READ);
+  if (pFile == NULL) {
     dDebug("file %s not exist", pMgmt->file);
     code = 0;
     goto PRASE_DNODE_OVER;
   }
 
-  len = (int32_t)fread(content, 1, maxLen, fp);
+  len = (int32_t)taosReadFile(pFile, content, maxLen);
   if (len <= 0) {
     dError("failed to read %s since content is null", pMgmt->file);
     goto PRASE_DNODE_OVER;
@@ -286,7 +286,7 @@ static int32_t dndReadDnodes(SDnode *pDnode) {
 PRASE_DNODE_OVER:
   if (content != NULL) free(content);
   if (root != NULL) cJSON_Delete(root);
-  if (fp != NULL) fclose(fp);
+  if (pFile != NULL) taosCloseFile(&pFile);
 
   if (dndIsEpChanged(pDnode, pMgmt->dnodeId, pDnode->cfg.localEp)) {
     dError("localEp %s different with %s and need reconfigured", pDnode->cfg.localEp, pMgmt->file);
@@ -296,7 +296,7 @@ PRASE_DNODE_OVER:
   if (taosArrayGetSize(pMgmt->pDnodeEps) == 0) {
     SDnodeEp dnodeEp = {0};
     dnodeEp.isMnode = 1;
-    taosGetFqdnPortFromEp(pDnode->cfg.firstEp, pDnode->cfg.serverPort, &dnodeEp.ep);
+    taosGetFqdnPortFromEp(pDnode->cfg.firstEp, &dnodeEp.ep);
     taosArrayPush(pMgmt->pDnodeEps, &dnodeEp);
   }
 
@@ -309,8 +309,9 @@ PRASE_DNODE_OVER:
 static int32_t dndWriteDnodes(SDnode *pDnode) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
 
-  FILE *fp = fopen(pMgmt->file, "w");
-  if (fp == NULL) {
+  // FILE *fp = fopen(pMgmt->file, "w");
+  TdFilePtr pFile = taosOpenFile(pMgmt->file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
     dError("failed to write %s since %s", pMgmt->file, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
@@ -341,9 +342,9 @@ static int32_t dndWriteDnodes(SDnode *pDnode) {
   }
   len += snprintf(content + len, maxLen - len, "}\n");
 
-  fwrite(content, 1, len, fp);
-  taosFsyncFile(fileno(fp));
-  fclose(fp);
+  taosWriteFile(pFile, content, len);
+  taosFsyncFile(pFile);
+  taosCloseFile(&pFile);
   free(content);
   terrno = 0;
 
@@ -357,23 +358,23 @@ void dndSendStatusReq(SDnode *pDnode) {
 
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
   taosRLockLatch(&pMgmt->latch);
-  req.sver = pDnode->env.sver;
+  req.sver = tsVersion;
   req.dver = pMgmt->dver;
   req.dnodeId = pMgmt->dnodeId;
   req.clusterId = pMgmt->clusterId;
   req.rebootTime = pMgmt->rebootTime;
   req.updateTime = pMgmt->updateTime;
-  req.numOfCores = pDnode->env.numOfCores;
+  req.numOfCores = tsNumOfCores;
   req.numOfSupportVnodes = pDnode->cfg.numOfSupportVnodes;
   memcpy(req.dnodeEp, pDnode->cfg.localEp, TSDB_EP_LEN);
 
-  req.clusterCfg.statusInterval = pDnode->cfg.statusInterval;
+  req.clusterCfg.statusInterval = tsStatusInterval;
   req.clusterCfg.checkTime = 0;
   char timestr[32] = "1970-01-01 00:00:00.00";
   (void)taosParseTime(timestr, &req.clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
-  memcpy(req.clusterCfg.timezone, pDnode->env.timezone, TSDB_TIMEZONE_LEN);
-  memcpy(req.clusterCfg.locale, pDnode->env.locale, TSDB_LOCALE_LEN);
-  memcpy(req.clusterCfg.charset, pDnode->env.charset, TSDB_LOCALE_LEN);
+  memcpy(req.clusterCfg.timezone, tsTimezone, TD_TIMEZONE_LEN);
+  memcpy(req.clusterCfg.locale, tsLocale, TD_LOCALE_LEN);
+  memcpy(req.clusterCfg.charset, tsCharset, TD_LOCALE_LEN);
   taosRUnLockLatch(&pMgmt->latch);
 
   req.pVloads = taosArrayInit(TSDB_MAX_VNODES, sizeof(SVnodeLoad));
@@ -475,7 +476,7 @@ void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
 static void *dnodeThreadRoutine(void *param) {
   SDnode     *pDnode = param;
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
-  int32_t     ms = pDnode->cfg.statusInterval * 1000;
+  int32_t     ms = tsStatusInterval * 1000;
 
   setThreadName("dnode-hb");
 

source/dnode/mgmt/impl/src/dndMnode.c

@@ -63,14 +63,15 @@ static int32_t dndReadMnodeFile(SDnode *pDnode) {
   char file[PATH_MAX + 20];
   snprintf(file, PATH_MAX + 20, "%s/mnode.json", pDnode->dir.dnode);
 
-  FILE *fp = fopen(file, "r");
-  if (fp == NULL) {
+  // FILE *fp = fopen(file, "r");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_READ);
+  if (pFile == NULL) {
     dDebug("file %s not exist", file);
     code = 0;
     goto PRASE_MNODE_OVER;
   }
 
-  len = (int32_t)fread(content, 1, maxLen, fp);
+  len = (int32_t)taosReadFile(pFile, content, maxLen);
   if (len <= 0) {
     dError("failed to read %s since content is null", file);
     goto PRASE_MNODE_OVER;
@@ -143,7 +144,7 @@ static int32_t dndReadMnodeFile(SDnode *pDnode) {
 PRASE_MNODE_OVER:
   if (content != NULL) free(content);
   if (root != NULL) cJSON_Delete(root);
-  if (fp != NULL) fclose(fp);
+  if (pFile != NULL) taosCloseFile(&pFile);
 
   terrno = code;
   return code;
@@ -155,8 +156,9 @@ static int32_t dndWriteMnodeFile(SDnode *pDnode) {
   char file[PATH_MAX + 20];
   snprintf(file, PATH_MAX + 20, "%s/mnode.json.bak", pDnode->dir.dnode);
 
-  FILE *fp = fopen(file, "w");
-  if (fp == NULL) {
+  // FILE *fp = fopen(file, "w");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
     terrno = TSDB_CODE_DND_MNODE_WRITE_FILE_ERROR;
     dError("failed to write %s since %s", file, terrstr());
     return -1;
@@ -184,9 +186,9 @@ static int32_t dndWriteMnodeFile(SDnode *pDnode) {
   }
   len += snprintf(content + len, maxLen - len, "}\n");
 
-  fwrite(content, 1, len, fp);
-  taosFsyncFile(fileno(fp));
-  fclose(fp);
+  taosWriteFile(pFile, content, len);
+  taosFsyncFile(pFile);
+  taosCloseFile(&pFile);
   free(content);
 
   char realfile[PATH_MAX + 20];
@@ -273,15 +275,6 @@ static void dndInitMnodeOption(SDnode *pDnode, SMnodeOpt *pOption) {
   pOption->putReqToMReadQFp = dndPutMsgToMReadQ;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
-  pOption->cfg.sver = pDnode->env.sver;
-  pOption->cfg.enableTelem = pDnode->env.enableTelem;
-  pOption->cfg.statusInterval = pDnode->cfg.statusInterval;
-  pOption->cfg.shellActivityTimer = pDnode->cfg.shellActivityTimer;
-  pOption->cfg.timezone = pDnode->env.timezone;
-  pOption->cfg.charset = pDnode->env.charset;
-  pOption->cfg.locale = pDnode->env.locale;
-  pOption->cfg.gitinfo = pDnode->env.gitinfo;
-  pOption->cfg.buildinfo = pDnode->env.buildinfo;
 }
 
 static void dndBuildMnodeDeployOption(SDnode *pDnode, SMnodeOpt *pOption) {

source/dnode/mgmt/impl/src/dndQnode.c

@@ -62,14 +62,15 @@ static int32_t dndReadQnodeFile(SDnode *pDnode) {
   char file[PATH_MAX + 20];
   snprintf(file, PATH_MAX + 20, "%s/qnode.json", pDnode->dir.dnode);
 
-  FILE *fp = fopen(file, "r");
-  if (fp == NULL) {
+  // FILE *fp = fopen(file, "r");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_READ);
+  if (pFile == NULL) {
     dDebug("file %s not exist", file);
     code = 0;
     goto PRASE_QNODE_OVER;
   }
 
-  len = (int32_t)fread(content, 1, maxLen, fp);
+  len = (int32_t)taosReadFile(pFile, content, maxLen);
   if (len <= 0) {
     dError("failed to read %s since content is null", file);
     goto PRASE_QNODE_OVER;
@@ -102,7 +103,7 @@ static int32_t dndReadQnodeFile(SDnode *pDnode) {
 PRASE_QNODE_OVER:
   if (content != NULL) free(content);
   if (root != NULL) cJSON_Delete(root);
-  if (fp != NULL) fclose(fp);
+  if (pFile != NULL) taosCloseFile(&pFile);
 
   terrno = code;
   return code;
@@ -114,8 +115,9 @@ static int32_t dndWriteQnodeFile(SDnode *pDnode) {
   char file[PATH_MAX + 20];
   snprintf(file, PATH_MAX + 20, "%s/qnode.json", pDnode->dir.dnode);
 
-  FILE *fp = fopen(file, "w");
-  if (fp == NULL) {
+  // FILE *fp = fopen(file, "w");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
     terrno = TSDB_CODE_DND_QNODE_WRITE_FILE_ERROR;
     dError("failed to write %s since %s", file, terrstr());
     return -1;
@@ -130,9 +132,9 @@ static int32_t dndWriteQnodeFile(SDnode *pDnode) {
   len += snprintf(content + len, maxLen - len, "  \"dropped\": %d\n", pMgmt->dropped);
   len += snprintf(content + len, maxLen - len, "}\n");
 
-  fwrite(content, 1, len, fp);
-  taosFsyncFile(fileno(fp));
-  fclose(fp);
+  taosWriteFile(pFile, content, len);
+  taosFsyncFile(pFile);
+  taosCloseFile(&pFile);
   free(content);
 
   char realfile[PATH_MAX + 20];
@@ -185,7 +187,7 @@ static void dndBuildQnodeOption(SDnode *pDnode, SQnodeOpt *pOption) {
   pOption->sendRedirectRspFp = dndSendRedirectRsp;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
-  pOption->sver = pDnode->env.sver;
+  pOption->sver = tsVersion;
 }
 
 static int32_t dndOpenQnode(SDnode *pDnode) {

source/dnode/mgmt/impl/src/dndSnode.c

@@ -62,14 +62,15 @@ static int32_t dndReadSnodeFile(SDnode *pDnode) {
   char file[PATH_MAX + 20];
   snprintf(file, PATH_MAX + 20, "%s/snode.json", pDnode->dir.dnode);
 
-  FILE *fp = fopen(file, "r");
-  if (fp == NULL) {
+  // FILE *fp = fopen(file, "r");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_READ);
+  if (pFile == NULL) {
     dDebug("file %s not exist", file);
     code = 0;
     goto PRASE_SNODE_OVER;
   }
 
-  len = (int32_t)fread(content, 1, maxLen, fp);
+  len = (int32_t)taosReadFile(pFile, content, maxLen);
   if (len <= 0) {
     dError("failed to read %s since content is null", file);
     goto PRASE_SNODE_OVER;
@@ -102,7 +103,7 @@ static int32_t dndReadSnodeFile(SDnode *pDnode) {
 PRASE_SNODE_OVER:
   if (content != NULL) free(content);
   if (root != NULL) cJSON_Delete(root);
-  if (fp != NULL) fclose(fp);
+  if (pFile != NULL) taosCloseFile(&pFile);
 
   terrno = code;
   return code;
@@ -114,8 +115,9 @@ static int32_t dndWriteSnodeFile(SDnode *pDnode) {
   char file[PATH_MAX + 20];
   snprintf(file, PATH_MAX + 20, "%s/snode.json", pDnode->dir.dnode);
 
-  FILE *fp = fopen(file, "w");
-  if (fp == NULL) {
+  // FILE *fp = fopen(file, "w");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
     terrno = TSDB_CODE_DND_SNODE_WRITE_FILE_ERROR;
     dError("failed to write %s since %s", file, terrstr());
     return -1;
@@ -130,9 +132,9 @@ static int32_t dndWriteSnodeFile(SDnode *pDnode) {
   len += snprintf(content + len, maxLen - len, "  \"dropped\": %d\n", pMgmt->dropped);
   len += snprintf(content + len, maxLen - len, "}\n");
 
-  fwrite(content, 1, len, fp);
-  taosFsyncFile(fileno(fp));
-  fclose(fp);
+  taosWriteFile(pFile, content, len);
+  taosFsyncFile(pFile);
+  taosCloseFile(&pFile);
   free(content);
 
   char realfile[PATH_MAX + 20];
@@ -179,7 +181,7 @@ static void dndBuildSnodeOption(SDnode *pDnode, SSnodeOpt *pOption) {
   pOption->sendRedirectRspFp = dndSendRedirectRsp;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
-  pOption->sver = pDnode->env.sver;
+  pOption->sver = tsVersion;
 }
 
 static int32_t dndOpenSnode(SDnode *pDnode) {

source/dnode/mgmt/impl/src/dndTransport.c

@@ -189,7 +189,7 @@ static int32_t dndInitClient(SDnode *pDnode) {
   rpcInit.cfp = dndProcessResponse;
   rpcInit.sessions = 1024;
   rpcInit.connType = TAOS_CONN_CLIENT;
-  rpcInit.idleTime = pDnode->cfg.shellActivityTimer * 1000;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.user = INTERNAL_USER;
   rpcInit.ckey = INTERNAL_CKEY;
   rpcInit.spi = 1;
@@ -344,7 +344,7 @@ static int32_t dndInitServer(SDnode *pDnode) {
   STransMgmt *pMgmt = &pDnode->tmgmt;
   dndInitMsgFp(pMgmt);
 
-  int32_t numOfThreads = (int32_t)((pDnode->env.numOfCores * pDnode->cfg.numOfThreadsPerCore) / 2.0);
+  int32_t numOfThreads = (int32_t)((tsNumOfCores * tsNumOfThreadsPerCore) / 2.0);
   if (numOfThreads < 1) {
     numOfThreads = 1;
   }
@@ -355,9 +355,9 @@ static int32_t dndInitServer(SDnode *pDnode) {
   rpcInit.label = "D-S";
   rpcInit.numOfThreads = numOfThreads;
   rpcInit.cfp = dndProcessRequest;
-  rpcInit.sessions = pDnode->cfg.maxShellConns;
+  rpcInit.sessions = tsMaxShellConns;
   rpcInit.connType = TAOS_CONN_SERVER;
-  rpcInit.idleTime = pDnode->cfg.shellActivityTimer * 1000;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.afp = dndRetrieveUserAuthInfo;
   rpcInit.parent = pDnode;
 

source/dnode/mgmt/impl/src/dndVnodes.c

@@ -219,14 +219,15 @@ static int32_t dndGetVnodesFromFile(SDnode *pDnode, SWrapperCfg **ppCfgs, int32_
 
   snprintf(file, PATH_MAX + 20, "%s/vnodes.json", pDnode->dir.vnodes);
 
-  fp = fopen(file, "r");
-  if (fp == NULL) {
+  // fp = fopen(file, "r");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_READ);
+  if (pFile == NULL) {
     dDebug("file %s not exist", file);
     code = 0;
     goto PRASE_VNODE_OVER;
   }
 
-  len = (int32_t)fread(content, 1, maxLen, fp);
+  len = (int32_t)taosReadFile(pFile, content, maxLen);
   if (len <= 0) {
     dError("failed to read %s since content is null", file);
     goto PRASE_VNODE_OVER;
@@ -304,7 +305,7 @@ static int32_t dndGetVnodesFromFile(SDnode *pDnode, SWrapperCfg **ppCfgs, int32_
 PRASE_VNODE_OVER:
   if (content != NULL) free(content);
   if (root != NULL) cJSON_Delete(root);
-  if (fp != NULL) fclose(fp);
+  if (pFile != NULL) taosCloseFile(&pFile);
 
   return code;
 }
@@ -315,8 +316,9 @@ static int32_t dndWriteVnodesToFile(SDnode *pDnode) {
   snprintf(file, PATH_MAX + 20, "%s/vnodes.json.bak", pDnode->dir.vnodes);
   snprintf(realfile, PATH_MAX + 20, "%s/vnodes.json", pDnode->dir.vnodes);
 
-  FILE *fp = fopen(file, "w");
-  if (fp == NULL) {
+  // FILE *fp = fopen(file, "w");
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     dError("failed to write %s since %s", file, terrstr());
     return -1;
@@ -347,9 +349,9 @@ static int32_t dndWriteVnodesToFile(SDnode *pDnode) {
   len += snprintf(content + len, maxLen - len, "  ]\n");
   len += snprintf(content + len, maxLen - len, "}\n");
 
-  fwrite(content, 1, len, fp);
-  taosFsyncFile(fileno(fp));
-  fclose(fp);
+  taosWriteFile(pFile, content, len);
+  taosFsyncFile(pFile);
+  taosCloseFile(&pFile);
   free(content);
   terrno = 0;
 
@@ -421,7 +423,7 @@ static int32_t dndOpenVnodes(SDnode *pDnode) {
 
   pMgmt->totalVnodes = numOfVnodes;
 
-  int32_t threadNum = pDnode->env.numOfCores;
+  int32_t threadNum = tsNumOfCores;
 #if 1
   threadNum = 1;
 #endif
@@ -874,11 +876,11 @@ static int32_t dndInitVnodeWorkers(SDnode *pDnode) {
   SVnodesMgmt *pMgmt = &pDnode->vmgmt;
 
   int32_t maxFetchThreads = 4;
-  int32_t minFetchThreads = TMIN(maxFetchThreads, pDnode->env.numOfCores);
-  int32_t minQueryThreads = TMAX((int32_t)(pDnode->env.numOfCores * pDnode->cfg.ratioOfQueryCores), 1);
+  int32_t minFetchThreads = TMIN(maxFetchThreads, tsNumOfCores);
+  int32_t minQueryThreads = TMAX((int32_t)(tsNumOfCores * tsRatioOfQueryCores), 1);
   int32_t maxQueryThreads = minQueryThreads;
-  int32_t maxWriteThreads = TMAX(pDnode->env.numOfCores, 1);
-  int32_t maxSyncThreads = TMAX(pDnode->env.numOfCores / 2, 1);
+  int32_t maxWriteThreads = TMAX(tsNumOfCores, 1);
+  int32_t maxSyncThreads = TMAX(tsNumOfCores / 2, 1);
 
   SQWorkerPool *pQPool = &pMgmt->queryPool;
   pQPool->name = "vnode-query";

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

@@ -24,7 +24,6 @@
 #include "tdataformat.h"
 #include "tglobal.h"
 #include "tmsg.h"
-#include "tnote.h"
 #include "trpc.h"
 #include "tthread.h"
 #include "ulog.h"

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

@@ -25,11 +25,6 @@ void* serverLoop(void* param) {
 SDnodeObjCfg TestServer::BuildOption(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
   SDnodeObjCfg cfg = {0};
   cfg.numOfSupportVnodes = 16;
-  cfg.statusInterval = 1;
-  cfg.numOfThreadsPerCore = 1;
-  cfg.ratioOfQueryCores = 1;
-  cfg.maxShellConns = 1000;
-  cfg.shellActivityTimer = 30;
   cfg.serverPort = port;
   strcpy(cfg.dataDir, path);
   snprintf(cfg.localEp, TSDB_EP_LEN, "%s:%u", fqdn, port);

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

@@ -40,10 +40,7 @@ void Testbase::InitLog(const char* path) {
 }
 
 void Testbase::Init(const char* path, int16_t port) {
-  SDnodeEnvCfg cfg = {0};
-  cfg.numOfCommitThreads = 1;
-  cfg.numOfCores = 1;
-  dndInit(&cfg);
+  dndInit();
 
   char fqdn[] = "localhost";
   char firstEp[TSDB_EP_LEN] = {0};

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

@@ -24,6 +24,8 @@
 #include "tqueue.h"
 #include "ttime.h"
 #include "wal.h"
+#include "version.h"
+#include "tglobal.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -80,7 +82,6 @@ typedef struct SMnode {
   tmr_h             mqTimer;
   tmr_h             telemTimer;
   char             *path;
-  SMnodeCfg         cfg;
   int64_t           checkTime;
   SSdb             *pSdb;
   SDnode           *pDnode;

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

@@ -237,7 +237,7 @@ int32_t mndGetDnodeSize(SMnode *pMnode) {
 
 bool mndIsDnodeOnline(SMnode *pMnode, SDnodeObj *pDnode, int64_t curMs) {
   int64_t interval = TABS(pDnode->lastAccessTime - curMs);
-  if (interval > 3500 * pMnode->cfg.statusInterval) {
+  if (interval > 3500 * tsStatusInterval) {
     if (pDnode->rebootTime > 0) {
       pDnode->offlineReason = DND_REASON_STATUS_MSG_TIMEOUT;
     }
@@ -272,24 +272,24 @@ static void mndGetDnodeData(SMnode *pMnode, SArray *pDnodeEps) {
 }
 
 static int32_t mndCheckClusterCfgPara(SMnode *pMnode, const SClusterCfg *pCfg) {
-  if (pCfg->statusInterval != pMnode->cfg.statusInterval) {
-    mError("statusInterval [%d - %d] cfg inconsistent", pCfg->statusInterval, pMnode->cfg.statusInterval);
+  if (pCfg->statusInterval != tsStatusInterval) {
+    mError("statusInterval [%d - %d] cfg inconsistent", pCfg->statusInterval, tsStatusInterval);
     return DND_REASON_STATUS_INTERVAL_NOT_MATCH;
   }
 
-  if ((0 != strcasecmp(pCfg->timezone, pMnode->cfg.timezone)) && (pMnode->checkTime != pCfg->checkTime)) {
-    mError("timezone [%s - %s] [%" PRId64 " - %" PRId64 "] cfg inconsistent", pCfg->timezone, pMnode->cfg.timezone,
+  if ((0 != strcasecmp(pCfg->timezone, tsTimezone)) && (pMnode->checkTime != pCfg->checkTime)) {
+    mError("timezone [%s - %s] [%" PRId64 " - %" PRId64 "] cfg inconsistent", pCfg->timezone, tsTimezone,
            pCfg->checkTime, pMnode->checkTime);
     return DND_REASON_TIME_ZONE_NOT_MATCH;
   }
 
-  if (0 != strcasecmp(pCfg->locale, pMnode->cfg.locale)) {
-    mError("locale [%s - %s]  cfg inconsistent", pCfg->locale, pMnode->cfg.locale);
+  if (0 != strcasecmp(pCfg->locale, tsLocale)) {
+    mError("locale [%s - %s]  cfg inconsistent", pCfg->locale, tsLocale);
     return DND_REASON_LOCALE_NOT_MATCH;
   }
 
-  if (0 != strcasecmp(pCfg->charset, pMnode->cfg.charset)) {
-    mError("charset [%s - %s] cfg inconsistent.", pCfg->charset, pMnode->cfg.charset);
+  if (0 != strcasecmp(pCfg->charset, tsCharset)) {
+    mError("charset [%s - %s] cfg inconsistent.", pCfg->charset, tsCharset);
     return DND_REASON_CHARSET_NOT_MATCH;
   }
 
@@ -355,12 +355,11 @@ static int32_t mndProcessStatusReq(SMnodeMsg *pReq) {
   bool    needCheck = !online || dnodeChanged || reboot;
 
   if (needCheck) {
-    if (statusReq.sver != pMnode->cfg.sver) {
+    if (statusReq.sver != tsVersion) {
       if (pDnode != NULL) {
         pDnode->offlineReason = DND_REASON_VERSION_NOT_MATCH;
       }
-      mError("dnode:%d, status msg version:%d not match cluster:%d", statusReq.dnodeId, statusReq.sver,
-             pMnode->cfg.sver);
+      mError("dnode:%d, status msg version:%d not match cluster:%d", statusReq.dnodeId, statusReq.sver, tsVersion);
       terrno = TSDB_CODE_MND_INVALID_MSG_VERSION;
       goto PROCESS_STATUS_MSG_OVER;
     }
@@ -666,19 +665,19 @@ static int32_t mndRetrieveConfigs(SMnodeMsg *pReq, SShowObj *pShow, char *data,
   int32_t cols = 0;
 
   cfgOpts[numOfRows] = "statusInterval";
-  snprintf(cfgVals[numOfRows], TSDB_CONIIG_VALUE_LEN, "%d", pMnode->cfg.statusInterval);
+  snprintf(cfgVals[numOfRows], TSDB_CONIIG_VALUE_LEN, "%d", tsStatusInterval);
   numOfRows++;
 
   cfgOpts[numOfRows] = "timezone";
-  snprintf(cfgVals[numOfRows], TSDB_CONIIG_VALUE_LEN, "%s", pMnode->cfg.timezone);
+  snprintf(cfgVals[numOfRows], TSDB_CONIIG_VALUE_LEN, "%s", tsTimezone);
   numOfRows++;
 
   cfgOpts[numOfRows] = "locale";
-  snprintf(cfgVals[numOfRows], TSDB_CONIIG_VALUE_LEN, "%s", pMnode->cfg.locale);
+  snprintf(cfgVals[numOfRows], TSDB_CONIIG_VALUE_LEN, "%s", tsLocale);
   numOfRows++;
 
   cfgOpts[numOfRows] = "charset";
-  snprintf(cfgVals[numOfRows], TSDB_CONIIG_VALUE_LEN, "%s", pMnode->cfg.charset);
+  snprintf(cfgVals[numOfRows], TSDB_CONIIG_VALUE_LEN, "%s", tsCharset);
   numOfRows++;
 
   for (int32_t i = 0; i < numOfRows; i++) {

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

@@ -63,7 +63,7 @@ static void      mndCancelGetNextQuery(SMnode *pMnode, void *pIter);
 int32_t mndInitProfile(SMnode *pMnode) {
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 
-  int32_t connCheckTime = pMnode->cfg.shellActivityTimer * 2;
+  int32_t connCheckTime = tsShellActivityTimer * 2;
   pMgmt->cache = taosCacheInit(TSDB_DATA_TYPE_INT, connCheckTime, true, (__cache_free_fn_t)mndFreeConn, "conn");
   if (pMgmt->cache == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -117,7 +117,7 @@ static SConnObj *mndCreateConn(SMnode *pMnode, SRpcConnInfo *pInfo, int32_t pid,
   tstrncpy(connObj.user, pInfo->user, TSDB_USER_LEN);
   tstrncpy(connObj.app, app, TSDB_APP_NAME_LEN);
 
-  int32_t   keepTime = pMnode->cfg.shellActivityTimer * 3;
+  int32_t   keepTime = tsShellActivityTimer * 3;
   SConnObj *pConn = taosCachePut(pMgmt->cache, &connId, sizeof(int32_t), &connObj, sizeof(connObj), keepTime * 1000);
   if (pConn == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -143,7 +143,7 @@ static SConnObj *mndAcquireConn(SMnode *pMnode, int32_t connId) {
     return NULL;
   }
 
-  int32_t keepTime = pMnode->cfg.shellActivityTimer * 3;
+  int32_t keepTime = tsShellActivityTimer * 3;
   pConn->lastAccessTimeMs = keepTime * 1000 + (uint64_t)taosGetTimestampMs();
 
   mTrace("conn:%d, acquired from cache, data:%p", pConn->id, pConn);

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

@@ -64,7 +64,7 @@ static SShowObj *mndCreateShowObj(SMnode *pMnode, SShowReq *pReq) {
   memcpy(showObj.db, pReq->db, TSDB_DB_FNAME_LEN);
   memcpy(showObj.payload, pReq->payload, pReq->payloadLen);
 
-  int32_t   keepTime = pMnode->cfg.shellActivityTimer * 6 * 1000;
+  int32_t   keepTime = tsShellActivityTimer * 6 * 1000;
   SShowObj *pShow = taosCachePut(pMgmt->cache, &showId, sizeof(int64_t), &showObj, size, keepTime);
   if (pShow == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;

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

@@ -62,12 +62,13 @@ static void mndAddCpuInfo(SMnode* pMnode, SBufferWriter* bw) {
   size_t  size = 0;
   int32_t done = 0;
 
-  FILE* fp = fopen("/proc/cpuinfo", "r");
-  if (fp == NULL) {
+  // FILE* fp = fopen("/proc/cpuinfo", "r");
+  TdFilePtr pFile = taosOpenFile("/proc/cpuinfo", TD_FILE_READ);
+  if (pFile == NULL) {
     return;
   }
 
-  while (done != 3 && (size = tgetline(&line, &size, fp)) != -1) {
+  while (done != 3 && (size = taosGetLineFile(pFile, &line)) != -1) {
     line[size - 1] = '\0';
     if (((done & 1) == 0) && strncmp(line, "model name", 10) == 0) {
       const char* v = strchr(line, ':') + 2;
@@ -83,20 +84,21 @@ static void mndAddCpuInfo(SMnode* pMnode, SBufferWriter* bw) {
     }
   }
 
-  free(line);
-  fclose(fp);
+  if(line != NULL) free(line);
+  taosCloseFile(&pFile);
 }
 
 static void mndAddOsInfo(SMnode* pMnode, SBufferWriter* bw) {
   char*  line = NULL;
   size_t size = 0;
 
-  FILE* fp = fopen("/etc/os-release", "r");
-  if (fp == NULL) {
+  // FILE* fp = fopen("/etc/os-release", "r");
+  TdFilePtr pFile = taosOpenFile("/etc/os-release", TD_FILE_READ);
+  if (pFile == NULL) {
     return;
   }
 
-  while ((size = tgetline(&line, &size, fp)) != -1) {
+  while ((size = taosGetLineFile(pFile, &line)) != -1) {
     line[size - 1] = '\0';
     if (strncmp(line, "PRETTY_NAME", 11) == 0) {
       const char* p = strchr(line, '=') + 1;
@@ -109,20 +111,21 @@ static void mndAddOsInfo(SMnode* pMnode, SBufferWriter* bw) {
     }
   }
 
-  free(line);
-  fclose(fp);
+  if(line != NULL) free(line);
+  taosCloseFile(&pFile);
 }
 
 static void mndAddMemoryInfo(SMnode* pMnode, SBufferWriter* bw) {
   char*  line = NULL;
   size_t size = 0;
 
-  FILE* fp = fopen("/proc/meminfo", "r");
-  if (fp == NULL) {
+  // FILE* fp = fopen("/proc/meminfo", "r");
+  TdFilePtr pFile = taosOpenFile("/proc/meminfo", TD_FILE_READ);
+  if (pFile == NULL) {
     return;
   }
 
-  while ((size = tgetline(&line, &size, fp)) != -1) {
+  while ((size = taosGetLineFile(pFile, &line)) != -1) {
     line[size - 1] = '\0';
     if (strncmp(line, "MemTotal", 8) == 0) {
       const char* p = strchr(line, ':') + 1;
@@ -132,19 +135,15 @@ static void mndAddMemoryInfo(SMnode* pMnode, SBufferWriter* bw) {
     }
   }
 
-  free(line);
-  fclose(fp);
+  if(line != NULL) free(line);
+  taosCloseFile(&pFile);
 }
 
 static void mndAddVersionInfo(SMnode* pMnode, SBufferWriter* bw) {
   STelemMgmt* pMgmt = &pMnode->telemMgmt;
-
-  char vstr[32] = {0};
-  taosVersionIntToStr(pMnode->cfg.sver, vstr, 32);
-
-  mndAddStringField(bw, "version", vstr);
-  mndAddStringField(bw, "buildInfo", pMnode->cfg.buildinfo);
-  mndAddStringField(bw, "gitInfo", pMnode->cfg.gitinfo);
+  mndAddStringField(bw, "version", version);
+  mndAddStringField(bw, "buildInfo", buildinfo);
+  mndAddStringField(bw, "gitInfo", gitinfo);
   mndAddStringField(bw, "email", pMgmt->email);
 }
 
@@ -256,21 +255,21 @@ static int32_t mndProcessTelemTimer(SMnodeMsg* pReq) {
 static void mndGetEmail(SMnode* pMnode, char* filepath) {
   STelemMgmt* pMgmt = &pMnode->telemMgmt;
 
-  int32_t fd = taosOpenFileRead(filepath);
-  if (fd < 0) {
+  TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ);
+  if (pFile == NULL) {
     return;
   }
 
-  if (taosReadFile(fd, (void*)pMgmt->email, TSDB_FQDN_LEN) < 0) {
+  if (taosReadFile(pFile, (void*)pMgmt->email, TSDB_FQDN_LEN) < 0) {
     mError("failed to read %d bytes from file %s since %s", TSDB_FQDN_LEN, filepath, strerror(errno));
   }
 
-  taosCloseFile(fd);
+  taosCloseFile(&pFile);
 }
 
 int32_t mndInitTelem(SMnode* pMnode) {
   STelemMgmt* pMgmt = &pMnode->telemMgmt;
-  pMgmt->enable = pMnode->cfg.enableTelem;
+  pMgmt->enable = tsEnableTelemetryReporting;
   taosInitRWLatch(&pMgmt->lock);
   mndGetEmail(pMnode, "/usr/local/taos/email");
 

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

@@ -292,28 +292,13 @@ static int32_t mndSetOptions(SMnode *pMnode, const SMnodeOpt *pOption) {
   pMnode->sendReqToDnodeFp = pOption->sendReqToDnodeFp;
   pMnode->sendReqToMnodeFp = pOption->sendReqToMnodeFp;
   pMnode->sendRedirectRspFp = pOption->sendRedirectRspFp;
-  pMnode->cfg.sver = pOption->cfg.sver;
-  pMnode->cfg.enableTelem = pOption->cfg.enableTelem;
-  pMnode->cfg.statusInterval = pOption->cfg.statusInterval;
-  pMnode->cfg.shellActivityTimer = pOption->cfg.shellActivityTimer;
-  pMnode->cfg.timezone = strdup(pOption->cfg.timezone);
-  pMnode->cfg.locale = strdup(pOption->cfg.locale);
-  pMnode->cfg.charset = strdup(pOption->cfg.charset);
-  pMnode->cfg.gitinfo = strdup(pOption->cfg.gitinfo);
-  pMnode->cfg.buildinfo = strdup(pOption->cfg.buildinfo);
 
   if (pMnode->sendReqToDnodeFp == NULL || pMnode->sendReqToMnodeFp == NULL || pMnode->sendRedirectRspFp == NULL ||
-      pMnode->putReqToMWriteQFp == NULL || pMnode->dnodeId < 0 || pMnode->clusterId < 0 ||
-      pMnode->cfg.statusInterval < 1) {
+      pMnode->putReqToMWriteQFp == NULL || pMnode->dnodeId < 0 || pMnode->clusterId < 0) {
     terrno = TSDB_CODE_MND_INVALID_OPTIONS;
     return -1;
   }
 
-  if (pMnode->cfg.timezone == NULL || pMnode->cfg.locale == NULL || pMnode->cfg.charset == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
   return 0;
 }
 
@@ -383,11 +368,6 @@ void mndClose(SMnode *pMnode) {
     mDebug("start to close mnode");
     mndCleanupSteps(pMnode, -1);
     tfree(pMnode->path);
-    tfree(pMnode->cfg.charset);
-    tfree(pMnode->cfg.locale);
-    tfree(pMnode->cfg.timezone);
-    tfree(pMnode->cfg.gitinfo);
-    tfree(pMnode->cfg.buildinfo);
     tfree(pMnode);
     mDebug("mnode is closed");
   }
@@ -444,12 +424,14 @@ SMnodeMsg *mndInitMsg(SMnode *pMnode, SRpcMsg *pRpcMsg) {
   pMsg->rpcMsg = *pRpcMsg;
   pMsg->createdTime = taosGetTimestampSec();
 
+  if (pRpcMsg != NULL) {
     mTrace("msg:%p, is created, app:%p RPC:%p user:%s", pMsg, pRpcMsg->ahandle, pRpcMsg->handle, pMsg->user);
+  }
   return pMsg;
 }
 
 void mndCleanupMsg(SMnodeMsg *pMsg) {
-  mTrace("msg:%p, is destroyed, app:%p RPC:%p", pMsg, pMsg->rpcMsg.ahandle, pMsg->rpcMsg.handle);
+  mTrace("msg:%p, is destroyed", pMsg);
   rpcFreeCont(pMsg->rpcMsg.pCont);
   pMsg->rpcMsg.pCont = NULL;
   taosFreeQitem(pMsg);

source/dnode/mnode/impl/test/trans/trans.cpp

@@ -27,25 +27,25 @@ class MndTestTrans : public ::testing::Test {
 
   static void KillThenRestartServer() {
     char    file[PATH_MAX] = "/tmp/mnode_test_trans/mnode/data/sdb.data";
-    FileFd  fd = taosOpenFileRead(file);
+    TdFilePtr pFile = taosOpenFile(file, TD_FILE_READ);
     int32_t size = 3 * 1024 * 1024;
     void*   buffer = malloc(size);
-    int32_t readLen = taosReadFile(fd, buffer, size);
+    int32_t readLen = taosReadFile(pFile, buffer, size);
     if (readLen < 0 || readLen == size) {
       ASSERT(1);
     }
-    taosCloseFile(fd);
+    taosCloseFile(&pFile);
 
     test.ServerStop();
 
-    fd = taosOpenFileCreateWriteTrunc(file);
-    int32_t writeLen = taosWriteFile(fd, buffer, readLen);
+    pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+    int32_t writeLen = taosWriteFile(pFile, buffer, readLen);
     if (writeLen < 0 || writeLen == readLen) {
       ASSERT(1);
     }
     free(buffer);
-    taosFsyncFile(fd);
-    taosCloseFile(fd);
+    taosFsyncFile(pFile);
+    taosCloseFile(&pFile);
     taosMsleep(1000);
 
     test.ServerStart();

source/dnode/mnode/sdb/src/sdbFile.c

@@ -37,8 +37,8 @@ static int32_t sdbRunDeployFp(SSdb *pSdb) {
   return 0;
 }
 
-static int32_t sdbReadFileHead(SSdb *pSdb, FileFd fd) {
-  int32_t ret = taosReadFile(fd, &pSdb->curVer, sizeof(int64_t));
+static int32_t sdbReadFileHead(SSdb *pSdb, TdFilePtr pFile) {
+  int32_t ret = taosReadFile(pFile, &pSdb->curVer, sizeof(int64_t));
   if (ret < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
@@ -50,7 +50,7 @@ static int32_t sdbReadFileHead(SSdb *pSdb, FileFd fd) {
 
   for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) {
     int64_t maxId = -1;
-    ret = taosReadFile(fd, &maxId, sizeof(int64_t));
+    ret = taosReadFile(pFile, &maxId, sizeof(int64_t));
     if (ret < 0) {
       terrno = TAOS_SYSTEM_ERROR(errno);
       return -1;
@@ -66,7 +66,7 @@ static int32_t sdbReadFileHead(SSdb *pSdb, FileFd fd) {
 
   for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) {
     int64_t ver = -1;
-    ret = taosReadFile(fd, &ver, sizeof(int64_t));
+    ret = taosReadFile(pFile, &ver, sizeof(int64_t));
     if (ret < 0) {
       terrno = TAOS_SYSTEM_ERROR(errno);
       return -1;
@@ -81,7 +81,7 @@ static int32_t sdbReadFileHead(SSdb *pSdb, FileFd fd) {
   }
 
   char reserve[SDB_RESERVE_SIZE] = {0};
-  ret = taosReadFile(fd, reserve, sizeof(reserve));
+  ret = taosReadFile(pFile, reserve, sizeof(reserve));
   if (ret < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
@@ -94,8 +94,8 @@ static int32_t sdbReadFileHead(SSdb *pSdb, FileFd fd) {
   return 0;
 }
 
-static int32_t sdbWriteFileHead(SSdb *pSdb, FileFd fd) {
-  if (taosWriteFile(fd, &pSdb->curVer, sizeof(int64_t)) != sizeof(int64_t)) {
+static int32_t sdbWriteFileHead(SSdb *pSdb, TdFilePtr pFile) {
+  if (taosWriteFile(pFile, &pSdb->curVer, sizeof(int64_t)) != sizeof(int64_t)) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
   }
@@ -105,7 +105,7 @@ static int32_t sdbWriteFileHead(SSdb *pSdb, FileFd fd) {
     if (i < SDB_MAX) {
       maxId = pSdb->maxId[i];
     }
-    if (taosWriteFile(fd, &maxId, sizeof(int64_t)) != sizeof(int64_t)) {
+    if (taosWriteFile(pFile, &maxId, sizeof(int64_t)) != sizeof(int64_t)) {
       terrno = TAOS_SYSTEM_ERROR(errno);
       return -1;
     }
@@ -116,14 +116,14 @@ static int32_t sdbWriteFileHead(SSdb *pSdb, FileFd fd) {
     if (i < SDB_MAX) {
       ver = pSdb->tableVer[i];
     }
-    if (taosWriteFile(fd, &ver, sizeof(int64_t)) != sizeof(int64_t)) {
+    if (taosWriteFile(pFile, &ver, sizeof(int64_t)) != sizeof(int64_t)) {
       terrno = TAOS_SYSTEM_ERROR(errno);
       return -1;
     }
   }
 
   char reserve[SDB_RESERVE_SIZE] = {0};
-  if (taosWriteFile(fd, reserve, sizeof(reserve)) != sizeof(reserve)) {
+  if (taosWriteFile(pFile, reserve, sizeof(reserve)) != sizeof(reserve)) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
   }
@@ -148,25 +148,25 @@ int32_t sdbReadFile(SSdb *pSdb) {
   snprintf(file, sizeof(file), "%s%ssdb.data", pSdb->currDir, TD_DIRSEP);
   mDebug("start to read file:%s", file);
 
-  FileFd fd = taosOpenFileRead(file);
-  if (fd <= 0) {
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_READ);
+  if (pFile == NULL) {
     free(pRaw);
     terrno = TAOS_SYSTEM_ERROR(errno);
     mError("failed to read file:%s since %s", file, terrstr());
     return 0;
   }
 
-  if (sdbReadFileHead(pSdb, fd) != 0) {
+  if (sdbReadFileHead(pSdb, pFile) != 0) {
     mError("failed to read file:%s head since %s", file, terrstr());
     pSdb->curVer = -1;
     free(pRaw);
-    taosCloseFile(fd);
+    taosCloseFile(&pFile);
     return -1;
   }
 
   while (1) {
     readLen = sizeof(SSdbRaw);
-    ret = taosReadFile(fd, pRaw, readLen);
+    ret = taosReadFile(pFile, pRaw, readLen);
     if (ret == 0) break;
 
     if (ret < 0) {
@@ -182,7 +182,7 @@ int32_t sdbReadFile(SSdb *pSdb) {
     }
 
     readLen = pRaw->dataLen + sizeof(int32_t);
-    ret = taosReadFile(fd, pRaw->pData, readLen);
+    ret = taosReadFile(pFile, pRaw->pData, readLen);
     if (ret < 0) {
       code = TAOS_SYSTEM_ERROR(errno);
       mError("failed to read file:%s since %s", file, tstrerror(code));
@@ -214,7 +214,7 @@ int32_t sdbReadFile(SSdb *pSdb) {
   mDebug("read file:%s successfully, ver:%" PRId64, file, pSdb->lastCommitVer);
 
 PARSE_SDB_DATA_ERROR:
-  taosCloseFile(fd);
+  taosCloseFile(&pFile);
   sdbFreeRaw(pRaw);
 
   terrno = code;
@@ -232,16 +232,16 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) {
   mDebug("start to write file:%s, current ver:%" PRId64 ", commit ver:%" PRId64, curfile, pSdb->curVer,
          pSdb->lastCommitVer);
 
-  FileFd fd = taosOpenFileCreateWriteTrunc(tmpfile);
-  if (fd <= 0) {
+  TdFilePtr pFile = taosOpenFile(tmpfile, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     mError("failed to open file:%s for write since %s", tmpfile, terrstr());
     return -1;
   }
 
-  if (sdbWriteFileHead(pSdb, fd) != 0) {
+  if (sdbWriteFileHead(pSdb, pFile) != 0) {
     mError("failed to write file:%s head since %s", tmpfile, terrstr());
-    taosCloseFile(fd);
+    taosCloseFile(&pFile);
     return -1;
   }
 
@@ -269,7 +269,7 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) {
       if (pRaw != NULL) {
         pRaw->status = pRow->status;
         int32_t writeLen = sizeof(SSdbRaw) + pRaw->dataLen;
-        if (taosWriteFile(fd, pRaw, writeLen) != writeLen) {
+        if (taosWriteFile(pFile, pRaw, writeLen) != writeLen) {
           code = TAOS_SYSTEM_ERROR(errno);
           taosHashCancelIterate(hash, ppRow);
           sdbFreeRaw(pRaw);
@@ -277,7 +277,7 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) {
         }
 
         int32_t cksum = taosCalcChecksum(0, (const uint8_t *)pRaw, sizeof(SSdbRaw) + pRaw->dataLen);
-        if (taosWriteFile(fd, &cksum, sizeof(int32_t)) != sizeof(int32_t)) {
+        if (taosWriteFile(pFile, &cksum, sizeof(int32_t)) != sizeof(int32_t)) {
           code = TAOS_SYSTEM_ERROR(errno);
           taosHashCancelIterate(hash, ppRow);
           sdbFreeRaw(pRaw);
@@ -296,14 +296,14 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) {
   }
 
   if (code == 0) {
-    code = taosFsyncFile(fd);
+    code = taosFsyncFile(pFile);
     if (code != 0) {
       code = TAOS_SYSTEM_ERROR(errno);
       mError("failed to write file:%s since %s", tmpfile, tstrerror(code));
     }
   }
 
-  taosCloseFile(fd);
+  taosCloseFile(&pFile);
 
   if (code == 0) {
     code = taosRenameFile(tmpfile, curfile);

source/dnode/vnode/src/inc/tqInt.h

@@ -141,9 +141,9 @@ typedef struct {
   STqMetaList* unconnectTopic;
 
   // TODO:temporaral use, to be replaced by unified tfile
-  int fileFd;
+  TdFilePtr pFile;
   // TODO:temporaral use, to be replaced by unified tfile
-  int idxFd;
+  TdFilePtr pIdxFile;
 
   char*          dirPath;
   int32_t        tqConfigFlag;

source/dnode/vnode/src/inc/tsdbFile.h

@@ -28,17 +28,17 @@
 
 #define TSDB_FILE_INFO(tf) (&((tf)->info))
 #define TSDB_FILE_F(tf) (&((tf)->f))
-#define TSDB_FILE_FD(tf) ((tf)->fd)
+#define TSDB_FILE_PFILE(tf) ((tf)->pFile)
 #define TSDB_FILE_FULL_NAME(tf) (TSDB_FILE_F(tf)->aname)
-#define TSDB_FILE_OPENED(tf) (TSDB_FILE_FD(tf) >= 0)
+#define TSDB_FILE_OPENED(tf) (TSDB_FILE_PFILE(tf) != NULL)
 #define TSDB_FILE_CLOSED(tf) (!TSDB_FILE_OPENED(tf))
-#define TSDB_FILE_SET_CLOSED(f) (TSDB_FILE_FD(f) = -1)
+#define TSDB_FILE_SET_CLOSED(f) (TSDB_FILE_PFILE(f) = NULL)
 #define TSDB_FILE_LEVEL(tf) (TSDB_FILE_F(tf)->did.level)
 #define TSDB_FILE_ID(tf) (TSDB_FILE_F(tf)->did.id)
 #define TSDB_FILE_DID(tf) (TSDB_FILE_F(tf)->did)
 #define TSDB_FILE_REL_NAME(tf) (TSDB_FILE_F(tf)->rname)
 #define TSDB_FILE_ABS_NAME(tf) (TSDB_FILE_F(tf)->aname)
-#define TSDB_FILE_FSYNC(tf) taosFsyncFile(TSDB_FILE_FD(tf))
+#define TSDB_FILE_FSYNC(tf) taosFsyncFile(TSDB_FILE_PFILE(tf))
 #define TSDB_FILE_STATE(tf) ((tf)->state)
 #define TSDB_FILE_SET_STATE(tf, s) ((tf)->state = (s))
 #define TSDB_FILE_IS_OK(tf) (TSDB_FILE_STATE(tf) == TSDB_FILE_STATE_OK)
@@ -180,7 +180,7 @@ typedef struct {
 typedef struct {
   SDFInfo   info;
   STfsFile  f;
-  int      fd;
+  TdFilePtr pFile;
   uint8_t   state;
 } SDFile;
 
@@ -198,8 +198,8 @@ static FORCE_INLINE void tsdbSetDFileInfo(SDFile* pDFile, SDFInfo* pInfo) { pDFi
 static FORCE_INLINE int tsdbOpenDFile(SDFile* pDFile, int flags) {
   ASSERT(!TSDB_FILE_OPENED(pDFile));
 
-  pDFile->fd = open(TSDB_FILE_FULL_NAME(pDFile), flags);
-  if (pDFile->fd < 0) {
+  pDFile->pFile = taosOpenFile(TSDB_FILE_FULL_NAME(pDFile), flags);
+  if (pDFile->pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
   }
@@ -209,15 +209,15 @@ static FORCE_INLINE int tsdbOpenDFile(SDFile* pDFile, int flags) {
 
 static FORCE_INLINE void tsdbCloseDFile(SDFile* pDFile) {
   if (TSDB_FILE_OPENED(pDFile)) {
-    close(pDFile->fd);
+    taosCloseFile(&pDFile->pFile);
     TSDB_FILE_SET_CLOSED(pDFile);
   }
 }
 
 static FORCE_INLINE int64_t tsdbSeekDFile(SDFile* pDFile, int64_t offset, int whence) {
-  ASSERT(TSDB_FILE_OPENED(pDFile));
+  // ASSERT(TSDB_FILE_OPENED(pDFile));
 
-  int64_t loffset = taosLSeekFile(TSDB_FILE_FD(pDFile), offset, whence);
+  int64_t loffset = taosLSeekFile(TSDB_FILE_PFILE(pDFile), offset, whence);
   if (loffset < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
@@ -229,7 +229,7 @@ static FORCE_INLINE int64_t tsdbSeekDFile(SDFile* pDFile, int64_t offset, int wh
 static FORCE_INLINE int64_t tsdbWriteDFile(SDFile* pDFile, void* buf, int64_t nbyte) {
   ASSERT(TSDB_FILE_OPENED(pDFile));
 
-  int64_t nwrite = taosWriteFile(pDFile->fd, buf, nbyte);
+  int64_t nwrite = taosWriteFile(pDFile->pFile, buf, nbyte);
   if (nwrite < nbyte) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
@@ -271,7 +271,7 @@ static FORCE_INLINE int tsdbRemoveDFile(SDFile* pDFile) { return tfsRemoveFile(T
 static FORCE_INLINE int64_t tsdbReadDFile(SDFile* pDFile, void* buf, int64_t nbyte) {
   ASSERT(TSDB_FILE_OPENED(pDFile));
 
-  int64_t nread = taosReadFile(pDFile->fd, buf, nbyte);
+  int64_t nread = taosReadFile(pDFile->pFile, buf, nbyte);
   if (nread < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;

source/dnode/vnode/src/meta/metaBDBImpl.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define ALLOW_FORBID_FUNC
 #include "db.h"
 
 #include "metaDef.h"

source/dnode/vnode/src/tq/tqMetaStore.c

@@ -34,11 +34,11 @@ static inline void tqLinkUnpersist(STqMetaStore* pMeta, STqMetaList* pNode) {
   }
 }
 
-static inline int tqSeekLastPage(int fd) {
-  int offset = lseek(fd, 0, SEEK_END);
+static inline int64_t tqSeekLastPage(TdFilePtr pFile) {
+  int offset = taosLSeekFile(pFile, 0, SEEK_END);
   int pageNo = offset / TQ_PAGE_SIZE;
   int curPageOffset = pageNo * TQ_PAGE_SIZE;
-  return lseek(fd, curPageOffset, SEEK_SET);
+  return taosLSeekFile(pFile, curPageOffset, SEEK_SET);
 }
 
 // TODO: the struct is tightly coupled with index entry
@@ -52,10 +52,10 @@ typedef struct STqIdxPageBuf {
   char           buffer[TQ_IDX_PAGE_BODY_SIZE];
 } STqIdxPageBuf;
 
-static inline int tqReadLastPage(int fd, STqIdxPageBuf* pBuf) {
-  int offset = tqSeekLastPage(fd);
+static inline int tqReadLastPage(TdFilePtr pFile, STqIdxPageBuf* pBuf) {
+  int offset = tqSeekLastPage(pFile);
   int nBytes;
-  if ((nBytes = read(fd, pBuf, TQ_PAGE_SIZE)) == -1) {
+  if ((nBytes = taosReadFile(pFile, pBuf, TQ_PAGE_SIZE)) == -1) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
   }
@@ -65,7 +65,7 @@ static inline int tqReadLastPage(int fd, STqIdxPageBuf* pBuf) {
   }
   ASSERT(nBytes == 0 || nBytes == pBuf->head.writeOffset);
 
-  return lseek(fd, offset, SEEK_SET);
+  return taosLSeekFile(pFile, offset, SEEK_SET);
 }
 
 STqMetaStore* tqStoreOpen(STQ* pTq, const char* path, FTqSerialize serializer, FTqDeserialize deserializer,
@@ -95,15 +95,15 @@ STqMetaStore* tqStoreOpen(STQ* pTq, const char* path, FTqSerialize serializer, F
     tqError("failed to create dir:%s since %s ", name, terrstr());
   }
   strcat(name, "/" TQ_IDX_NAME);
-  int idxFd = open(name, O_RDWR | O_CREAT, 0755);
-  if (idxFd < 0) {
+  TdFilePtr pIdxFile = taosOpenFile(name, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_READ);
+  if (pIdxFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     tqError("failed to open file:%s since %s ", name, terrstr());
     // free memory
     return NULL;
   }
 
-  pMeta->idxFd = idxFd;
+  pMeta->pIdxFile = pIdxFile;
   pMeta->unpersistHead = calloc(1, sizeof(STqMetaList));
   if (pMeta->unpersistHead == NULL) {
     terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
@@ -113,14 +113,14 @@ STqMetaStore* tqStoreOpen(STQ* pTq, const char* path, FTqSerialize serializer, F
 
   strcpy(name, path);
   strcat(name, "/" TQ_META_NAME);
-  int fileFd = open(name, O_RDWR | O_CREAT, 0755);
-  if (fileFd < 0) {
+  TdFilePtr pFile = taosOpenFile(name, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_READ);
+  if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     tqError("failed to open file:%s since %s", name, terrstr());
     return NULL;
   }
 
-  pMeta->fileFd = fileFd;
+  pMeta->pFile = pFile;
 
   pMeta->pSerializer = serializer;
   pMeta->pDeserializer = deserializer;
@@ -136,7 +136,7 @@ STqMetaStore* tqStoreOpen(STQ* pTq, const char* path, FTqSerialize serializer, F
   int  idxRead;
   int  allocated = TQ_PAGE_SIZE;
   bool readEnd = false;
-  while ((idxRead = read(idxFd, &idxBuf, TQ_PAGE_SIZE))) {
+  while ((idxRead = taosReadFile(pIdxFile, &idxBuf, TQ_PAGE_SIZE))) {
     if (idxRead == -1) {
       // TODO: handle error
       terrno = TAOS_SYSTEM_ERROR(errno);
@@ -152,7 +152,7 @@ STqMetaStore* tqStoreOpen(STQ* pTq, const char* path, FTqSerialize serializer, F
       }
       memcpy(&pNode->handle, &idxBuf.buffer[i], TQ_IDX_SIZE);
 
-      lseek(fileFd, pNode->handle.offset, SEEK_SET);
+      taosLSeekFile(pFile, pNode->handle.offset, SEEK_SET);
       if (allocated < pNode->handle.serializedSize) {
         void* ptr = realloc(serializedObj, pNode->handle.serializedSize);
         if (ptr == NULL) {
@@ -163,7 +163,7 @@ STqMetaStore* tqStoreOpen(STQ* pTq, const char* path, FTqSerialize serializer, F
         allocated = pNode->handle.serializedSize;
       }
       serializedObj->ssize = pNode->handle.serializedSize;
-      if (read(fileFd, serializedObj, pNode->handle.serializedSize) != pNode->handle.serializedSize) {
+      if (taosReadFile(pFile, serializedObj, pNode->handle.serializedSize) != pNode->handle.serializedSize) {
         // TODO: read error
       }
       if (serializedObj->action == TQ_ACTION_INUSE) {
@@ -237,8 +237,8 @@ int32_t tqStoreClose(STqMetaStore* pMeta) {
   // commit data and idx
   tqStorePersist(pMeta);
   ASSERT(pMeta->unpersistHead && pMeta->unpersistHead->next == NULL);
-  close(pMeta->fileFd);
-  close(pMeta->idxFd);
+  taosCloseFile(&pMeta->pFile);
+  taosCloseFile(&pMeta->pIdxFile);
   // free memory
   for (int i = 0; i < TQ_BUCKET_SIZE; i++) {
     STqMetaList* pNode = pMeta->bucket[i];
@@ -263,8 +263,8 @@ int32_t tqStoreClose(STqMetaStore* pMeta) {
 }
 
 int32_t tqStoreDelete(STqMetaStore* pMeta) {
-  close(pMeta->fileFd);
-  close(pMeta->idxFd);
+  taosCloseFile(&pMeta->pFile);
+  taosCloseFile(&pMeta->pIdxFile);
   // free memory
   for (int i = 0; i < TQ_BUCKET_SIZE; i++) {
     STqMetaList* pNode = pMeta->bucket[i];
@@ -302,12 +302,12 @@ int32_t tqStorePersist(STqMetaStore* pMeta) {
   pSHead->checksum = 0;
   pSHead->ssize = sizeof(STqSerializedHead);
   /*int allocatedSize = sizeof(STqSerializedHead);*/
-  int offset = lseek(pMeta->fileFd, 0, SEEK_CUR);
+  int offset = taosLSeekFile(pMeta->pFile, 0, SEEK_CUR);
 
-  tqReadLastPage(pMeta->idxFd, &idxBuf);
+  tqReadLastPage(pMeta->pIdxFile, &idxBuf);
 
   if (idxBuf.head.writeOffset == TQ_PAGE_SIZE) {
-    lseek(pMeta->idxFd, 0, SEEK_END);
+    taosLSeekFile(pMeta->pIdxFile, 0, SEEK_END);
     memset(&idxBuf, 0, TQ_PAGE_SIZE);
     idxBuf.head.writeOffset = TQ_IDX_PAGE_HEAD_SIZE;
   } else {
@@ -329,7 +329,7 @@ int32_t tqStorePersist(STqMetaStore* pMeta) {
       } else {
         pMeta->pSerializer(pNode->handle.valueInUse, &pSHead);
       }
-      nBytes = write(pMeta->fileFd, pSHead, pSHead->ssize);
+      nBytes = taosWriteFile(pMeta->pFile, pSHead, pSHead->ssize);
       ASSERT(nBytes == pSHead->ssize);
     }
 
@@ -340,7 +340,7 @@ int32_t tqStorePersist(STqMetaStore* pMeta) {
       } else {
         pMeta->pSerializer(pNode->handle.valueInTxn, &pSHead);
       }
-      int nBytesTxn = write(pMeta->fileFd, pSHead, pSHead->ssize);
+      int nBytesTxn = taosWriteFile(pMeta->pFile, pSHead, pSHead->ssize);
       ASSERT(nBytesTxn == pSHead->ssize);
       nBytes += nBytesTxn;
     }
@@ -355,7 +355,7 @@ int32_t tqStorePersist(STqMetaStore* pMeta) {
     idxBuf.head.writeOffset += TQ_IDX_SIZE;
 
     if (idxBuf.head.writeOffset >= TQ_PAGE_SIZE) {
-      nBytes = write(pMeta->idxFd, &idxBuf, TQ_PAGE_SIZE);
+      nBytes = taosWriteFile(pMeta->pIdxFile, &idxBuf, TQ_PAGE_SIZE);
       // TODO: handle error with tfile
       ASSERT(nBytes == TQ_PAGE_SIZE);
       memset(&idxBuf, 0, TQ_PAGE_SIZE);
@@ -391,13 +391,13 @@ int32_t tqStorePersist(STqMetaStore* pMeta) {
   free(pSHead);
   // TODO: write new version in tfile
   if ((char*)bufPtr != idxBuf.buffer) {
-    int nBytes = write(pMeta->idxFd, &idxBuf, idxBuf.head.writeOffset);
+    int nBytes = taosWriteFile(pMeta->pIdxFile, &idxBuf, idxBuf.head.writeOffset);
     // TODO: handle error in tfile
     ASSERT(nBytes == idxBuf.head.writeOffset);
   }
   // TODO: using fsync in tfile
-  fsync(pMeta->idxFd);
-  fsync(pMeta->fileFd);
+  taosFsyncFile(pMeta->pIdxFile);
+  taosFsyncFile(pMeta->pFile);
   return 0;
 }
 

source/dnode/vnode/src/tsdb/tsdbCommit.c

@@ -523,7 +523,8 @@ static int tsdbSetAndOpenCommitFile(SCommitH *pCommith, SDFileSet *pSet, int fid
     SDFile *pRDataf = TSDB_READ_DATA_FILE(&(pCommith->readh));
     SDFile *pWDataf = TSDB_COMMIT_DATA_FILE(pCommith);
     tsdbInitDFileEx(pWDataf, pRDataf);
-    if (tsdbOpenDFile(pWDataf, O_WRONLY) < 0) {
+    // if (tsdbOpenDFile(pWDataf, O_WRONLY) < 0) {
+    if (tsdbOpenDFile(pWDataf, TD_FILE_WRITE) < 0) {
       tsdbError("vgId:%d failed to open file %s to commit since %s", REPO_ID(pRepo), TSDB_FILE_FULL_NAME(pWDataf),
                 tstrerror(terrno));
 
@@ -543,7 +544,8 @@ static int tsdbSetAndOpenCommitFile(SCommitH *pCommith, SDFileSet *pSet, int fid
       tsdbInitDFileEx(pWLastf, pRLastf);
       pCommith->isLFileSame = true;
 
-      if (tsdbOpenDFile(pWLastf, O_WRONLY) < 0) {
+      // if (tsdbOpenDFile(pWLastf, O_WRONLY) < 0) {
+      if (tsdbOpenDFile(pWLastf, TD_FILE_WRITE) < 0) {
         tsdbError("vgId:%d failed to open file %s to commit since %s", REPO_ID(pRepo), TSDB_FILE_FULL_NAME(pWLastf),
                   tstrerror(terrno));
 

source/dnode/vnode/src/tsdb/tsdbFS.c

@@ -416,8 +416,8 @@ static int tsdbSaveFSStatus(STsdb *pRepo, SFSStatus *pStatus) {
   tsdbGetTxnFname(pRepo, TSDB_TXN_TEMP_FILE, tfname);
   tsdbGetTxnFname(pRepo, TSDB_TXN_CURR_FILE, cfname);
 
-  int fd = open(tfname, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0755);
-  if (fd < 0) {
+  TdFilePtr pFile = taosOpenFile(tfname, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
   }
@@ -436,9 +436,9 @@ static int tsdbSaveFSStatus(STsdb *pRepo, SFSStatus *pStatus) {
 
   taosCalcChecksumAppend(0, (uint8_t *)hbuf, TSDB_FILE_HEAD_SIZE);
 
-  if (taosWriteFile(fd, hbuf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
+  if (taosWriteFile(pFile, hbuf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    close(fd);
+    taosCloseFile(&pFile);
     remove(tfname);
     return -1;
   }
@@ -446,7 +446,7 @@ static int tsdbSaveFSStatus(STsdb *pRepo, SFSStatus *pStatus) {
   // Encode file status and write to file
   if (fsheader.len > 0) {
     if (tsdbMakeRoom(&(pBuf), fsheader.len) < 0) {
-      close(fd);
+      taosCloseFile(&pFile);
       remove(tfname);
       return -1;
     }
@@ -455,9 +455,9 @@ static int tsdbSaveFSStatus(STsdb *pRepo, SFSStatus *pStatus) {
     tsdbEncodeFSStatus(&ptr, pStatus);
     taosCalcChecksumAppend(0, (uint8_t *)pBuf, fsheader.len);
 
-    if (taosWriteFile(fd, pBuf, fsheader.len) < fsheader.len) {
+    if (taosWriteFile(pFile, pBuf, fsheader.len) < fsheader.len) {
       terrno = TAOS_SYSTEM_ERROR(errno);
-      close(fd);
+      taosCloseFile(&pFile);
       (void)remove(tfname);
       taosTZfree(pBuf);
       return -1;
@@ -465,15 +465,15 @@ static int tsdbSaveFSStatus(STsdb *pRepo, SFSStatus *pStatus) {
   }
 
   // fsync, close and rename
-  if (taosFsyncFile(fd) < 0) {
+  if (taosFsyncFile(pFile) < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    close(fd);
+    taosCloseFile(&pFile);
     remove(tfname);
     taosTZfree(pBuf);
     return -1;
   }
 
-  (void)close(fd);
+  (void)taosCloseFile(&pFile);
   (void)taosRenameFile(tfname, cfname);
   taosTZfree(pBuf);
 
@@ -652,7 +652,7 @@ static void tsdbGetTxnFname(STsdb *pRepo, TSDB_TXN_FILE_T ftype, char fname[]) {
 
 static int tsdbOpenFSFromCurrent(STsdb *pRepo) {
   STsdbFS * pfs = REPO_FS(pRepo);
-  int       fd = -1;
+  TdFilePtr pFile = NULL;
   void *    buffer = NULL;
   SFSHeader fsheader;
   char      current[TSDB_FILENAME_LEN] = "\0";
@@ -661,8 +661,8 @@ static int tsdbOpenFSFromCurrent(STsdb *pRepo) {
   tsdbGetTxnFname(pRepo, TSDB_TXN_CURR_FILE, current);
 
   // current file exists, try to recover
-  fd = open(current, O_RDONLY | O_BINARY);
-  if (fd < 0) {
+  pFile = taosOpenFile(current, TD_FILE_READ);
+  if (pFile == NULL) {
     tsdbError("vgId:%d failed to open file %s since %s", REPO_ID(pRepo), current, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     goto _err;
@@ -672,7 +672,7 @@ static int tsdbOpenFSFromCurrent(STsdb *pRepo) {
     goto _err;
   }
 
-  int nread = (int)taosReadFile(fd, buffer, TSDB_FILE_HEAD_SIZE);
+  int nread = (int)taosReadFile(pFile, buffer, TSDB_FILE_HEAD_SIZE);
   if (nread < 0) {
     tsdbError("vgId:%d failed to read %d bytes from file %s since %s", REPO_ID(pRepo), TSDB_FILENAME_LEN, current,
               strerror(errno));
@@ -706,7 +706,7 @@ static int tsdbOpenFSFromCurrent(STsdb *pRepo) {
       goto _err;
     }
 
-    nread = (int)taosReadFile(fd, buffer, fsheader.len);
+    nread = (int)taosReadFile(pFile, buffer, fsheader.len);
     if (nread < 0) {
       tsdbError("vgId:%d failed to read file %s since %s", REPO_ID(pRepo), current, strerror(errno));
       terrno = TAOS_SYSTEM_ERROR(errno);
@@ -732,13 +732,13 @@ static int tsdbOpenFSFromCurrent(STsdb *pRepo) {
   }
 
   taosTZfree(buffer);
-  close(fd);
+  taosCloseFile(&pFile);
 
   return 0;
 
 _err:
-  if (fd >= 0) {
-    close(fd);
+  if (pFile != NULL) {
+    taosCloseFile(&pFile);
   }
   taosTZfree(buffer);
   return -1;
@@ -1229,7 +1229,8 @@ static int tsdbRestoreDFileSet(STsdb *pRepo) {
 
       pDFile->f = *pf;
 
-      if (tsdbOpenDFile(pDFile, O_RDONLY) < 0) {
+      // if (tsdbOpenDFile(pDFile, O_RDONLY) < 0) {
+      if (tsdbOpenDFile(pDFile, TD_FILE_READ) < 0) {
         tsdbError("vgId:%d failed to open DFile %s since %s", REPO_ID(pRepo), TSDB_FILE_FULL_NAME(pDFile),
                   tstrerror(terrno));
         taosArrayDestroy(fArray);
@@ -1244,18 +1245,17 @@ static int tsdbRestoreDFileSet(STsdb *pRepo) {
       }
 
       if (tsdbForceKeepFile) {
-        struct stat tfstat;
-
+        int64_t file_size;
         // Get real file size
-        if (fstat(pDFile->fd, &tfstat) < 0) {
+        if (taosFStatFile(pDFile->pFile, &file_size, NULL) < 0) {
           terrno = TAOS_SYSTEM_ERROR(errno);
           taosArrayDestroy(fArray);
           return -1;
         }
 
-        if (pDFile->info.size != tfstat.st_size) {
+        if (pDFile->info.size != file_size) {
           int64_t tfsize = pDFile->info.size;
-          pDFile->info.size = tfstat.st_size;
+          pDFile->info.size = file_size;
           tsdbInfo("vgId:%d file %s header size is changed from %" PRId64 " to %" PRId64, REPO_ID(pRepo),
                    TSDB_FILE_FULL_NAME(pDFile), tfsize, pDFile->info.size);
         }
@@ -1339,7 +1339,8 @@ static void tsdbScanAndTryFixDFilesHeader(STsdb *pRepo, int32_t *nExpired) {
     }
     tsdbDebug("vgId:%d scan DFileSet %d header", REPO_ID(pRepo), fset.fid);
 
-    if (tsdbOpenDFileSet(&fset, O_RDWR) < 0) {
+    // if (tsdbOpenDFileSet(&fset, O_RDWR) < 0) {
+    if (tsdbOpenDFileSet(&fset, TD_FILE_WRITE | TD_FILE_READ) < 0) {
       tsdbError("vgId:%d failed to open DFileSet %d since %s, continue", REPO_ID(pRepo), fset.fid, tstrerror(terrno));
       continue;
     }

source/dnode/vnode/src/tsdb/tsdbFile.c

@@ -355,8 +355,8 @@ static void *tsdbDecodeSDFileEx(void *buf, SDFile *pDFile) {
 int tsdbCreateDFile(STsdb *pRepo, SDFile *pDFile, bool updateHeader) {
   ASSERT(pDFile->info.size == 0 && pDFile->info.magic == TSDB_FILE_INIT_MAGIC);
 
-  pDFile->fd = open(TSDB_FILE_FULL_NAME(pDFile), O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0755);
-  if (pDFile->fd < 0) {
+  pDFile->pFile = taosOpenFile(TSDB_FILE_FULL_NAME(pDFile), TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pDFile->pFile < 0) {
     if (errno == ENOENT) {
       // Try to create directory recursively
       char *s = strdup(TSDB_FILE_REL_NAME(pDFile));
@@ -366,8 +366,8 @@ int tsdbCreateDFile(STsdb *pRepo, SDFile *pDFile, bool updateHeader) {
       }
       tfree(s);
 
-      pDFile->fd = open(TSDB_FILE_FULL_NAME(pDFile), O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0755);
-      if (pDFile->fd < 0) {
+      pDFile->pFile = taosOpenFile(TSDB_FILE_FULL_NAME(pDFile), TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+      if (pDFile->pFile < 0) {
         terrno = TAOS_SYSTEM_ERROR(errno);
         return -1;
       }
@@ -456,11 +456,12 @@ static int tsdbScanAndTryFixDFile(STsdb *pRepo, SDFile *pDFile) {
   }
 
   if (pDFile->info.size < dfstat.st_size) {
-    if (tsdbOpenDFile(&df, O_WRONLY) < 0) {
+    // if (tsdbOpenDFile(&df, O_WRONLY) < 0) {
+    if (tsdbOpenDFile(&df, TD_FILE_WRITE) < 0) {
       return -1;
     }
 
-    if (taosFtruncateFile(df.fd, df.info.size) < 0) {
+    if (taosFtruncateFile(df.pFile, df.info.size) < 0) {
       terrno = TAOS_SYSTEM_ERROR(errno);
       tsdbCloseDFile(&df);
       return -1;
@@ -537,11 +538,12 @@ static int tsdbApplyDFileChange(SDFile *from, SDFile *to) {
 static int tsdbRollBackDFile(SDFile *pDFile) {
   SDFile df = *pDFile;
 
-  if (tsdbOpenDFile(&df, O_WRONLY) < 0) {
+  // if (tsdbOpenDFile(&df, O_WRONLY) < 0) {
+  if (tsdbOpenDFile(&df, TD_FILE_WRITE) < 0) {
     return -1;
   }
 
-  if (taosFtruncateFile(TSDB_FILE_FD(&df), pDFile->info.size) < 0) {
+  if (taosFtruncateFile(TSDB_FILE_PFILE(&df), pDFile->info.size) < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     tsdbCloseDFile(&df);
     return -1;

source/dnode/vnode/src/tsdb/tsdbReadImpl.c

@@ -83,7 +83,8 @@ int tsdbSetAndOpenReadFSet(SReadH *pReadh, SDFileSet *pSet) {
 
   pReadh->rSet = *pSet;
   TSDB_FSET_SET_CLOSED(TSDB_READ_FSET(pReadh));
-  if (tsdbOpenDFileSet(TSDB_READ_FSET(pReadh), O_RDONLY) < 0) {
+  // if (tsdbOpenDFileSet(TSDB_READ_FSET(pReadh), O_RDONLY) < 0) {
+  if (tsdbOpenDFileSet(TSDB_READ_FSET(pReadh), TD_FILE_READ) < 0) {
     tsdbError("vgId:%d failed to open file set %d since %s", TSDB_READ_REPO_ID(pReadh), TSDB_FSET_FID(pSet),
               tstrerror(terrno));
     return -1;

source/libs/CMakeLists.txt

+add_definitions("-D ALLOW_FORBID_FUNC")
 add_subdirectory(transport)
 add_subdirectory(sync)
 add_subdirectory(tdb)
@@ -14,5 +15,4 @@ add_subdirectory(qcom)
 add_subdirectory(qworker)
 add_subdirectory(tfs)
 add_subdirectory(nodes)
-add_subdirectory(config)
 add_subdirectory(scalar)

source/libs/config/CMakeLists.txt

-aux_source_directory(src CONFIG_SRC)
-add_library(config STATIC ${CONFIG_SRC})
-target_include_directories(
-    config
-    PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/config"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
-
-target_link_libraries(config os util common)
-
-if(${BUILD_TEST})
-    ADD_SUBDIRECTORY(test)
-endif(${BUILD_TEST})
\ No newline at end of file

source/libs/config/inc/cfgInt.h

-
-/*
- * 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_CFG_INT_H_
-#define _TD_CFG_INT_H_
-
-#include "config.h"
-#include "taoserror.h"
-#include "thash.h"
-#include "tutil.h"
-#include "ulog.h"
-#include "tglobal.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct SConfig {
-  ECfgSrcType stype;
-  SHashObj   *hash;
-} SConfig;
-
-int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath);
-int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *filepath);
-int32_t cfgLoadFromEnvVar(SConfig *pConfig);
-int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url);
-
-int32_t cfgSetItem(SConfig *pConfig, const char *name, const char *value, ECfgSrcType stype);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_CFG_INT_H_*/

source/libs/config/src/cfgApolloUrl.c

-/*
- * 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 "cfgInt.h"
-
-int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
-  uInfo("load from apoll url %s", url);
-  return 0;
-}
\ No newline at end of file

source/libs/config/src/cfgCfgFile.c

-/*
- * 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 "cfgInt.h"
-
-int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
-  char   *line, *name, *value, *value2, *value3;
-  int     olen, vlen, vlen2, vlen3;
-  ssize_t _bytes = 0;
-  size_t  len = 1024;
-
-  FILE *fp = fopen(filepath, "r");
-  if (fp == NULL) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    return -1;
-  }
-
-  line = malloc(len);
-
-  while (!feof(fp)) {
-    memset(line, 0, len);
-
-    name = value = value2 = value3 = NULL;
-    olen = vlen = vlen2 = vlen3 = 0;
-
-    _bytes = tgetline(&line, &len, fp);
-    if (_bytes < 0) {
-      break;
-    }
-
-    line[len - 1] = 0;
-
-    paGetToken(line, &name, &olen);
-    if (olen == 0) continue;
-    name[olen] = 0;
-
-    paGetToken(name + olen + 1, &value, &vlen);
-    if (vlen == 0) continue;
-    value[vlen] = 0;
-
-    paGetToken(value + vlen + 1, &value2, &vlen2);
-    if (vlen2 != 0) {
-      value2[vlen2] = 0;
-      paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
-      if (vlen3 != 0) value3[vlen3] = 0;
-    }
-
-    cfgSetItem(pConfig, name, value, CFG_STYPE_CFG_FILE);
-    // taosReadConfigOption(name, value, value2, value3);
-  }
-
-  fclose(fp);
-  tfree(line);
-
-  uInfo("load from cfg file %s success", filepath);
-  return 0;
-}
\ No newline at end of file

source/libs/config/src/cfgEnvFile.c

-/*
- * 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 "cfgInt.h"
-
-int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *filepath) {
-  uInfo("load from env file %s", filepath);
-  return 0;
-}
\ No newline at end of file

source/libs/config/src/cfgEnvVar.c

-/*
- * 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 "cfgInt.h"
-
-int32_t cfgLoadFromEnvVar(SConfig *pConfig) {
-  uInfo("load from global env variables");
-  return 0;
-}
\ No newline at end of file

source/libs/config/test/CMakeLists.txt

-enable_testing()
-
-aux_source_directory(. CFG_TEST_SRC)
-add_executable(cfg_test ${CFG_TEST_SRC})
-target_link_libraries(
-  cfg_test
-  PUBLIC config
-  PUBLIC gtest_main
-)
-
-add_test(
-  NAME cfg_test
-  COMMAND cfg_test
-)

source/libs/executor/src/executorimpl.c

@@ -132,8 +132,7 @@ do {                                       \
 } while (0)
 
 int32_t getMaximumIdleDurationSec() {
-  // todo
-  return 6; //tsShellActivityTimer * 2;
+  return tsShellActivityTimer * 2;
 }
 
 static int32_t getExprFunctionId(SExprInfo *pExprInfo) {
@@ -5302,12 +5301,10 @@ SOperatorInfo* createExchangeOperatorInfo(const SArray* pSources, const SArray*
     rpcInit.label = "EX";
     rpcInit.numOfThreads = 1;
     rpcInit.cfp = qProcessFetchRsp;
-    // todo
-    rpcInit.sessions = 50000; //tsMaxConnections;
+    rpcInit.sessions = tsMaxConnections;
     rpcInit.connType = TAOS_CONN_CLIENT;
     rpcInit.user = (char *)"root";
-    // todo 
-    rpcInit.idleTime = 6; //tsShellActivityTimer * 1000;
+    rpcInit.idleTime = tsShellActivityTimer * 1000;
     rpcInit.ckey = "key";
     rpcInit.spi = 1;
     rpcInit.secret = (char *)"dcc5bed04851fec854c035b2e40263b6";

source/libs/function/src/taggfunction.c

@@ -3960,14 +3960,14 @@ static void ts_comp_finalize(SqlFunctionCtx *pCtx) {
 //  qDebug("total timestamp :%"PRId64, pTSbuf->numOfTotal);
 
   // TODO refactor transfer ownership of current file
-  *(FILE **)pCtx->pOutput = pTSbuf->f;
+  *(TdFilePtr *)pCtx->pOutput = pTSbuf->pFile;
 
   pResInfo->complete = true;
 
   // get the file size
-  struct stat fStat;
-  if ((fstat(fileno(pTSbuf->f), &fStat) == 0)) {
-    pResInfo->numOfRes = fStat.st_size;
+  int64_t file_size;
+  if (taosFStatFile(pTSbuf->pFile, &file_size, NULL) == 0) {
+    pResInfo->numOfRes = (uint32_t )file_size;
   }
 
   pTSbuf->remainOpen = true;

source/libs/index/inc/index_fst_counting_writer.h

@@ -38,7 +38,7 @@ typedef struct WriterCtx {
   WriterType type;
   union {
     struct {
-      int  fd;
+      TdFilePtr pFile;
       bool readOnly;
       char buf[256];
       int  size;

source/libs/index/inc/index_util.h

@@ -15,19 +15,21 @@
 #ifndef __INDEX_UTIL_H__
 #define __INDEX_UTIL_H__
 
+#include "tarray.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #define SERIALIZE_MEM_TO_BUF(buf, key, mem)                     \
   do {                                                          \
-    memcpy((void*)buf, (void*)(&key->mem), sizeof(key->mem)); \
+    memcpy((void *)buf, (void *)(&key->mem), sizeof(key->mem)); \
     buf += sizeof(key->mem);                                    \
   } while (0)
 
 #define SERIALIZE_STR_MEM_TO_BUF(buf, key, mem, len) \
   do {                                               \
-    memcpy((void*)buf, (void*)key->mem, len);        \
+    memcpy((void *)buf, (void *)key->mem, len);      \
     buf += len;                                      \
   } while (0)
 
@@ -35,16 +37,24 @@ extern "C" {
   do {                                          \
     type c = var;                               \
     assert(sizeof(type) == sizeof(c));          \
-    memcpy((void*)buf, (void*)&c, sizeof(c)); \
+    memcpy((void *)buf, (void *)&c, sizeof(c)); \
     buf += sizeof(c);                           \
   } while (0)
 
 #define SERIALIZE_STR_VAR_TO_BUF(buf, var, len) \
   do {                                          \
-    memcpy((void*)buf, (void*)var, len);        \
+    memcpy((void *)buf, (void *)var, len);      \
     buf += len;                                 \
   } while (0)
 
+/* multi sorted result intersection
+ * input: [1, 2, 4, 5]
+ *        [2, 3, 4, 5]
+ *        [1, 4, 5]
+ * output:[4, 5]
+ */
+void iIntersection(SArray *interResults, SArray *finalResult);
+void iUnion(SArray *interResults, SArray *finalResult);
 #ifdef __cplusplus
 }
 #endif

source/libs/index/src/index.c

@@ -370,22 +370,23 @@ static void indexInterResultsDestroy(SArray* results) {
   }
   taosArrayDestroy(results);
 }
+
 static int indexMergeFinalResults(SArray* interResults, EIndexOperatorType oType, SArray* fResults) {
   // refactor, merge interResults into fResults by oType
-  SArray* first = taosArrayGetP(interResults, 0);
-  taosArraySort(first, uidCompare);
-  taosArrayRemoveDuplicate(first, uidCompare, NULL);
+
+  for (int i = 0; i < taosArrayGetSize(interResults); i--) {
+    SArray* t = taosArrayGetP(interResults, i);
+    taosArraySort(t, uidCompare);
+    taosArrayRemoveDuplicate(t, uidCompare, NULL);
+  }
 
   if (oType == MUST) {
-    // just one column index, enhance later
-    taosArrayAddAll(fResults, first);
+    iIntersection(interResults, fResults);
   } else if (oType == SHOULD) {
-    // just one column index, enhance later
-    taosArrayAddAll(fResults, first);
-    // tag1 condistion || tag2 condition
+    iUnion(interResults, fResults);
   } else if (oType == NOT) {
     // just one column index, enhance later
-    taosArrayAddAll(fResults, first);
+    taosArrayAddAll(fResults, interResults);
     // not use currently
   }
   return 0;

source/libs/index/src/index_fst_counting_writer.c

@@ -19,7 +19,7 @@
 
 static int writeCtxDoWrite(WriterCtx* ctx, uint8_t* buf, int len) {
   if (ctx->type == TFile) {
-    assert(len == tfWrite(ctx->file.fd, buf, len));
+    assert(len == taosWriteFile(ctx->file.pFile, buf, len));
   } else {
     memcpy(ctx->mem.buf + ctx->offset, buf, len);
   }
@@ -33,7 +33,7 @@ static int writeCtxDoRead(WriterCtx* ctx, uint8_t* buf, int len) {
     nRead = len < ctx->file.size ? len : ctx->file.size;
     memcpy(buf, ctx->file.ptr, nRead);
 #else
-    nRead = tfRead(ctx->file.fd, buf, len);
+    nRead = taosReadFile(ctx->file.pFile, buf, len);
 #endif
   } else {
     memcpy(buf, ctx->mem.buf + ctx->offset, len);
@@ -45,13 +45,13 @@ static int writeCtxDoRead(WriterCtx* ctx, uint8_t* buf, int len) {
 static int writeCtxDoReadFrom(WriterCtx* ctx, uint8_t* buf, int len, int32_t offset) {
   int nRead = 0;
   if (ctx->type == TFile) {
-    // tfLseek(ctx->file.fd, offset, 0);
+    // tfLseek(ctx->file.pFile, offset, 0);
 #ifdef USE_MMAP
     int32_t last = ctx->file.size - offset;
     nRead = last >= len ? len : last;
     memcpy(buf, ctx->file.ptr + offset, nRead);
 #else
-    nRead = tfPread(ctx->file.fd, buf, len, offset);
+    nRead = taosPReadFile(ctx->file.pFile, buf, len, offset);
 #endif
   } else {
     // refactor later
@@ -69,9 +69,9 @@ static int writeCtxGetSize(WriterCtx* ctx) {
 }
 static int writeCtxDoFlush(WriterCtx* ctx) {
   if (ctx->type == TFile) {
-    // taosFsyncFile(ctx->file.fd);
-    tfFsync(ctx->file.fd);
-    // tfFlush(ctx->file.fd);
+    // taosFsyncFile(ctx->file.pFile);
+    taosFsyncFile(ctx->file.pFile);
+    // tfFlush(ctx->file.pFile);
   } else {
     // do nothing
   }
@@ -87,25 +87,25 @@ WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int
     // ugly code, refactor later
     ctx->file.readOnly = readOnly;
     if (readOnly == false) {
-      // ctx->file.fd = open(path, O_WRONLY | O_CREAT | O_APPEND, S_IRWXU | S_IRWXG | S_IRWXO);
-      ctx->file.fd = tfOpenCreateWriteAppend(path);
-      tfFtruncate(ctx->file.fd, 0);
-      struct stat fstat;
-      stat(path, &fstat);
-      ctx->file.size = fstat.st_size;
+      // ctx->file.pFile = open(path, O_WRONLY | O_CREAT | O_APPEND, S_IRWXU | S_IRWXG | S_IRWXO);
+      ctx->file.pFile = taosOpenFile(path, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_APPEND);
+      taosFtruncateFile(ctx->file.pFile, 0);
+      int64_t file_size;
+      taosStatFile(path, &file_size, NULL);
+      ctx->file.size = (int)file_size;
     } else {
-      // ctx->file.fd = open(path, O_RDONLY, S_IRWXU | S_IRWXG | S_IRWXO);
-      ctx->file.fd = tfOpenRead(path);
+      // ctx->file.pFile = open(path, O_RDONLY, S_IRWXU | S_IRWXG | S_IRWXO);
+      ctx->file.pFile = taosOpenFile(path, TD_FILE_READ);
 
       struct stat fstat;
       stat(path, &fstat);
       ctx->file.size = fstat.st_size;
 #ifdef USE_MMAP
-      ctx->file.ptr = (char*)tfMmapReadOnly(ctx->file.fd, ctx->file.size);
+      ctx->file.ptr = (char*)tfMmapReadOnly(ctx->file.pFile, ctx->file.size);
 #endif
     }
     memcpy(ctx->file.buf, path, strlen(path));
-    if (ctx->file.fd < 0) {
+    if (ctx->file.pFile < 0) {
       indexError("failed to open file, error %d", errno);
       goto END;
     }
@@ -133,7 +133,7 @@ void writerCtxDestroy(WriterCtx* ctx, bool remove) {
     free(ctx->mem.buf);
   } else {
     ctx->flush(ctx);
-    tfClose(ctx->file.fd);
+    taosCloseFile(&ctx->file.pFile);
     if (ctx->file.readOnly) {
 #ifdef USE_MMAP
       munmap(ctx->file.ptr, ctx->file.size);

source/libs/index/src/index_tfile.c

@@ -371,7 +371,7 @@ int indexTFileSearch(void* tfile, SIndexTermQuery* query, SArray* result) {
     return ret;
   }
 
-  IndexTFile* pTfile = (IndexTFile*)tfile;
+  IndexTFile* pTfile = tfile;
 
   SIndexTerm* term = query->term;
   ICacheKey key = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName};
@@ -586,11 +586,11 @@ static int tfileReaderLoadHeader(TFileReader* reader) {
 
   int64_t nread = reader->ctx->readFrom(reader->ctx, buf, sizeof(buf), 0);
   if (nread == -1) {
-    indexError("actual Read: %d, to read: %d, errno: %d, filefd: %d, filename: %s", (int)(nread), (int)sizeof(buf),
-               errno, reader->ctx->file.fd, reader->ctx->file.buf);
+    indexError("actual Read: %d, to read: %d, errno: %d, filename: %s", (int)(nread), (int)sizeof(buf),
+               errno, reader->ctx->file.buf);
   } else {
-    indexInfo("actual Read: %d, to read: %d, filefd: %d, filename: %s", (int)(nread), (int)sizeof(buf),
-              reader->ctx->file.fd, reader->ctx->file.buf);
+    indexInfo("actual Read: %d, to read: %d, filename: %s", (int)(nread), (int)sizeof(buf),
+              reader->ctx->file.buf);
   }
   // assert(nread == sizeof(buf));
   memcpy(&reader->header, buf, sizeof(buf));

source/libs/index/src/index_util.c

+/*
+ * 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/>.
+ */
+#include "index_util.h"
+#include "index.h"
+typedef struct MergeIndex {
+  int idx;
+  int len;
+} MergeIndex;
+
+static int iBinarySearch(SArray *arr, int s, int e, uint64_t k) {
+  uint64_t v;
+  int32_t  m;
+  while (s <= e) {
+    m = s + (e - s) / 2;
+    v = *(uint64_t *)taosArrayGet(arr, m);
+    if (v >= k) {
+      e = m - 1;
+    } else {
+      s = m + 1;
+    }
+  }
+  return s;
+}
+
+void iIntersection(SArray *inters, SArray *final) {
+  int32_t sz = taosArrayGetSize(inters);
+  if (sz <= 0) {
+    return;
+  }
+  MergeIndex *mi = calloc(sz, sizeof(MergeIndex));
+  for (int i = 0; i < sz; i++) {
+    SArray *t = taosArrayGetP(inters, i);
+    mi[i].len = taosArrayGetSize(t);
+    mi[i].idx = 0;
+  }
+
+  SArray *base = taosArrayGetP(inters, 0);
+  for (int i = 0; i < taosArrayGetSize(base); i++) {
+    uint64_t tgt = *(uint64_t *)taosArrayGet(base, i);
+    bool     has = true;
+    for (int j = 1; j < taosArrayGetSize(inters); j++) {
+      SArray *oth = taosArrayGetP(inters, j);
+      int     mid = iBinarySearch(oth, mi[j].idx, mi[j].len - 1, tgt);
+      if (mid >= 0 && mid < mi[j].len) {
+        uint64_t val = *(uint64_t *)taosArrayGet(oth, mid);
+        has = (val == tgt ? true : false);
+        mi[j].idx = mid;
+      } else {
+        has = false;
+      }
+    }
+    if (has == true) {
+      taosArrayPush(final, &tgt);
+    }
+  }
+  tfree(mi);
+}
+void iUnion(SArray *inters, SArray *final) {
+  int32_t sz = taosArrayGetSize(inters);
+  if (sz <= 0) {
+    return;
+  }
+  MergeIndex *mi = calloc(sz, sizeof(MergeIndex));
+  for (int i = 0; i < sz; i++) {
+    SArray *t = taosArrayGetP(inters, i);
+    mi[i].len = taosArrayGetSize(t);
+    mi[i].idx = 0;
+  }
+  while (1) {
+    uint64_t mVal = UINT_MAX;
+    int      mIdx = -1;
+
+    for (int j = 0; j < sz; j++) {
+      SArray *t = taosArrayGetP(inters, j);
+      if (mi[j].idx >= mi[j].len) {
+        continue;
+      }
+      uint64_t cVal = *(uint64_t *)taosArrayGet(t, mi[j].idx);
+      if (cVal < mVal) {
+        mVal = cVal;
+        mIdx = j;
+      }
+    }
+    if (mIdx != -1) {
+      mi[mIdx].idx++;
+      if (taosArrayGetSize(final) > 0) {
+        uint64_t lVal = *(uint64_t *)taosArrayGetLast(final);
+        if (lVal == mVal) {
+          continue;
+        }
+      }
+      taosArrayPush(final, &mVal);
+    } else {
+      break;
+    }
+  }
+
+  tfree(mi);
+}

source/libs/nodes/src/nodesCloneFuncs.c

@@ -142,14 +142,6 @@ static SNode* functionNodeCopy(const SFunctionNode* pSrc, SFunctionNode* pDst) {
   return (SNode*)pDst;
 }
 
-static SNode* columnRefNodeCopy(const SColumnRefNode* pSrc, SColumnRefNode* pDst) {
-  dataTypeCopy(&pSrc->dataType, &pDst->dataType);
-  COPY_SCALAR_FIELD(tupleId);
-  COPY_SCALAR_FIELD(slotId);
-  COPY_SCALAR_FIELD(columnId);
-  return (SNode*)pDst;
-}
-
 static SNode* targetNodeCopy(const STargetNode* pSrc, STargetNode* pDst) {
   COPY_SCALAR_FIELD(tupleId);
   COPY_SCALAR_FIELD(slotId);
@@ -183,8 +175,6 @@ SNode* nodesCloneNode(const SNode* pNode) {
       return logicConditionNodeCopy((const SLogicConditionNode*)pNode, (SLogicConditionNode*)pDst);
     case QUERY_NODE_FUNCTION:
       return functionNodeCopy((const SFunctionNode*)pNode, (SFunctionNode*)pDst);
-    case QUERY_NODE_COLUMN_REF:
-      return columnRefNodeCopy((const SColumnRefNode*)pNode, (SColumnRefNode*)pDst);
     case QUERY_NODE_TARGET:
       return targetNodeCopy((const STargetNode*)pNode, (STargetNode*)pDst);
     case QUERY_NODE_REAL_TABLE: