refactor

src/common/src/tglobal.c

@@ -220,6 +220,7 @@ int32_t sDebugFlag = 135;
 int32_t wDebugFlag = 135;
 int32_t tsdbDebugFlag = 131;
 int32_t cqDebugFlag = 135;
+int32_t fsDebugFlag = 135;
 
 int32_t (*monitorStartSystemFp)() = NULL;
 void (*monitorStopSystemFp)() = NULL;

src/inc/tfs.h

@@ -36,6 +36,8 @@ typedef struct {
 int  tfsInit(SDiskCfg *pDiskCfg, int ndisk);
 void tfsDestroy();
 void tfsUpdateInfo();
+void tfsIncDiskFile(int level, int id, int num);
+void tfsDecDiskFile(int level, int id, int num);
 
 const char *TFS_PRIMARY_PATH();
 const char *TFS_DISK_PATH(int level, int id);
@@ -52,7 +54,10 @@ typedef struct {
 #define TFILE_ID(pf) ((pf)->id)
 #define TFILE_NAME(pf) ((pf)->aname)
 
-int tfsInitFile(TFILE *pf, int level, int id, const char *bname);
+void tfsInitFile(TFILE *pf, int level, int id, const char *bname);
+int  tfsopen(TFILE *pf, int flags);
+int  tfsclose(int fd);
+int  tfsremove(TFILE *pf);
 
 // DIR APIs ====================================
 int tfsMkdir(const char *rname);

src/tfs/src/tfs.c

@@ -54,6 +54,8 @@ typedef struct {
 #define TFS_IS_VALID_ID(level, id) (((id) >= 0) && ((id) < TIER_NDISKS(TFS_TIER_AT(level))))
 #define TFS_IS_VALID_DISK(level, id) (TFS_IS_VALID_LEVEL(level) && TFS_IS_VALID_ID(level, id))
 
+#define TFS_MIN_DISK_FREE_SIZE 50*1024*1024
+
 static SFS  tfs = {0};
 static SFS *pfs = &tfs;
 
@@ -69,6 +71,7 @@ static int    tfsUnLock();
 static int    tfsOpendirImpl(TDIR *tdir);
 static void   tfsInitDiskIter(SDiskIter *pIter);
 static SDisk *tfsNextDisk(SDiskIter *pIter);
+static int    tfsAssignDisk(int level);
 
 // FS APIs ====================================
 int tfsInit(SDiskCfg *pDiskCfg, int ndisk) {
@@ -136,23 +139,82 @@ void tfsUpdateInfo() {
   tfsUnLock();
 }
 
+void tfsIncDiskFile(int level, int id, int num) {
+  tfsLock();
+  TFS_DISK_AT(level, id)->dmeta.nfiles += num;
+  tfsUnLock();
+}
+
+void tfsDecDiskFile(int level, int id, int num) {
+  tfsLock();
+  TFS_DISK_AT(level, id)->dmeta.nfiles -= num;
+  ASSERT(TFS_DISK_AT(level, id)->dmeta.nfiles >= 0);
+  tfsUnLock();
+}
+
 const char *TFS_PRIMARY_PATH() { return DISK_DIR(TFS_PRIMARY_DISK()); }
 const char *TFS_DISK_PATH(int level, int id) { return DISK_DIR(TFS_DISK_AT(level, id)); }
 
 // TFILE APIs ====================================
-int tfsInitFile(TFILE *pf, int level, int id, const char *bname) {
-  if (!TFS_IS_VALID_DISK(level, id)) return -1;
-
+void tfsInitFile(TFILE *pf, int level, int id, const char *bname) {
   SDisk *pDisk = TFS_DISK_AT(level, id);
 
   pf->level = level;
   pf->id = id;
   strncpy(pf->rname, bname, TSDB_FILENAME_LEN);
   snprintf(pf->aname, TSDB_FILENAME_LEN, "%s/%s", DISK_DIR(pDisk), pf->rname);
+}
+
+int tfsopen(TFILE *pf, int flags) {
+  int fd = -1;
+
+  if (flags & O_CREAT) {
+    if (pf->level > TFS_NLEVEL()) {
+      pf->level = TFS_NLEVEL();
+    }
+
+    if (pf->id == TFS_UNDECIDED_ID) {
+      pf->id = tfsAssignDisk(pf->level);
+      if (pf->id < 0) {
+        fError("failed to assign disk at level %d", pf->level);
+        return -1;
+      }
+    }
+
+    tfsIncDiskFile(pf->level, pf->id, 1);
+  }
+
+  fd = open(pf->aname, flags);
+  if (fd < 0) {
+    fError("failed to open file %s since %s", pf->aname, strerror(errno));
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    return -1;
+  }
+
+  return fd;
+}
+
+int tfsclose(int fd) {
+  int code = close(fd);
+  if (code != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    return -1;
+  }
 
   return 0;
 }
 
+int tfsremove(TFILE *pf) { 
+  int code = remove(pf->aname);
+  if (code != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    return -1;
+  }
+
+  tfsDecDiskFile(pf->level, pf->id, 1);
+  return 0; 
+}
+
 // DIR APIs ====================================
 int tfsMkdir(const char *rname) {
   char aname[TSDB_FILENAME_LEN] = "\0";
@@ -482,4 +544,32 @@ static SDisk *tfsNextDisk(SDiskIter *pIter) {
   return pDisk;
 }
 
+static int tfsAssignDisk(int level) {
+  if (!TFS_IS_VALID_LEVEL(level)) return -1;
+
+  STier *pTier = TFS_TIER_AT(level);
+  int    id = -1;
+
+  tfsLock();
+
+  for (int tid = 0; tid < TIER_NDISKS(pTier); tid++) {
+    SDisk *pDisk = DISK_AT_TIER(pTier, tid);
+
+    if (DISK_FREE_SIZE(pDisk) < TFS_MIN_DISK_FREE_SIZE) continue;
+
+    if (id == -1) {
+      id = tid;
+      continue;
+    }
+
+    if (DISK_NFILES(DISK_AT_TIER(pTier, id)) > DISK_NFILES(DISK_AT_TIER(pTier, tid))) {
+      id = tid;
+    }
+  }
+
+  tfsUnLock();
+
+  return id;
+}
+
 #pragma GCC diagnostic pop
\ No newline at end of file

src/tsdb/inc/tsdbMain.h

@@ -520,6 +520,7 @@ int         tsdbOpenFile(SFile* pFile, int oflag);
 void        tsdbCloseFile(SFile* pFile);
 int         tsdbCreateFile(SFile* pFile, STsdbRepo* pRepo, int fid, int type);
 SFileGroup* tsdbSearchFGroup(STsdbFileH* pFileH, int fid, int flags);
+int         tsdbGetFidLevel(int fid, SFidGroup fidg);
 void        tsdbRemoveFilesBeyondRetention(STsdbRepo* pRepo, SFidGroup* pFidGroup);
 int         tsdbUpdateFileHeader(SFile* pFile);
 int         tsdbEncodeSFileInfo(void** buf, const STsdbFileInfo* pInfo);
@@ -593,7 +594,7 @@ static FORCE_INLINE int compTSKEY(const void* key1, const void* key2) {
 #define TSDB_SUBMIT_MSG_HEAD_SIZE sizeof(SSubmitMsg)
 
 char*       tsdbGetMetaFileName(char* rootDir);
-void        tsdbGetDataFileName(char* rootDir, int vid, int fid, int type, const char* fname);
+void        tsdbGetDataFileName(char* rootDir, int vid, int fid, int type, char* fname);
 int         tsdbLockRepo(STsdbRepo* pRepo);
 int         tsdbUnlockRepo(STsdbRepo* pRepo);
 char*       tsdbGetDataDirName(char* rootDir);

src/tsdb/src/tsdbCommit.c

@@ -191,7 +191,7 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitH *pch) {
   }
 
   if ((pGroup = tsdbSearchFGroup(pFileH, fid, TD_EQ)) == NULL) {
-    pGroup = tsdbCreateFGroup(pRepo, fid);
+    pGroup = tsdbCreateFGroup(pRepo, fid, tsdbGetFidLevel(fid, pch->fidg));
     if (pGroup == NULL) {
       tsdbError("vgId:%d failed to create file group %d since %s", REPO_ID(pRepo), fid, tstrerror(terrno));
       return -1;

src/tsdb/src/tsdbFile.c

@@ -24,6 +24,9 @@
 
 const char *tsdbFileSuffix[] = {".head", ".data", ".last", ".stat", ".h", ".d", ".l", ".s"};
 
+static int compFGroup(const void *arg1, const void *arg2);
+static int keyFGroupCompFunc(const void *key, const void *fgroup);
+
 // STsdbFileH ===========================================
 STsdbFileH *tsdbNewFileH(STsdbCfg *pCfg) {
   STsdbFileH *pFileH = (STsdbFileH *)calloc(1, sizeof(*pFileH));
@@ -85,51 +88,47 @@ void tsdbCloseFileH(STsdbRepo *pRepo) {
 // SFileGroup ===========================================
 SFileGroup *tsdbCreateFGroup(STsdbRepo *pRepo, int fid, int level) {
   STsdbFileH *pFileH = pRepo->tsdbFileH;
-  char        fname[TSDB_FILENAME_LEN] = "\0";
   SFileGroup  fg = {0};
-  SFileGroup *pfg = &fg;
-  SFile *     pFile = NULL;
   int         id = TFS_UNDECIDED_ID;
+  char        fname[TSDB_FILENAME_LEN] = "\0";
+
+  ASSERT(tsdbSearchFGroup(pFileH, fid, TD_EQ) == NULL);
+  ASSERT(pFileH->nFGroups < pFileH->maxFGroups);
 
-  ASSERT(tsdbSearchFGroup(pFileH, fid, TD_EQ) == NULL && pFileH->nFGroups < pFileH->maxFGroups);
+  // SET FILE GROUP
+  fg.fileId = fid;
 
-  // 1. Create each files
+  // CREATE FILES
   for (int type = 0; type < TSDB_FILE_TYPE_MAX; type++) {
-    pFile = &(pfg->files[type]);
+    SFile *pFile = &(fg.files[type]);
 
-    tsdbGetDataFileName(pRepo->rootDir, REPO_ID(pRepo), fid, type, pFile->file.rname);
-    pFile->file.level = level;
-    pFile->file.id = id;
+    pFile->fd = -1;
+    pFile->info.size = TSDB_FILE_HEAD_SIZE;
+    pFile->info.magic = TSDB_FILE_INIT_MAGIC;
 
-    if (tsdbOpenFile(pFile, O_WRONLY|O_CREAT) < 0); {
-      tsdbError("vgId:%d failed to create file group %d since %s", REPO_ID(pRepo), fid, tstrerror(terrno));
-      return NULL;
-    }
+    tsdbGetDataFileName(pRepo->rootDir, REPO_ID(pRepo), fid, type, fname);
+    tfsInitFile(&pFile->file, level, id, fname);
+
+    if (tsdbOpenFile(pFile, O_WRONLY|O_CREAT) < 0) return NULL;
 
     if (tsdbUpdateFileHeader(pFile) < 0) {
-      tsdbError("vgId:%d failed to update file %s header since %s", REPO_ID(pRepo), TSDB_FILE_NAME(pFile),
-                tstrerror(terrno));
       tsdbCloseFile(pFile);
       return NULL;
     }
 
     tsdbCloseFile(pFile);
 
-    level = pFile->file.level;
-    id = pFile->file.id;
+    level = TFILE_LEVEL(&(pFile->file));
+    id = TFILE_ID(&(pFile->file));
   }
 
-  // Set fg
-  pfg->fileId = fid;
-  pfg->state = 0;
-
-  // Register fg to the repo
+  // PUT GROUP INTO FILE HANDLE
   pthread_rwlock_wrlock(&pFileH->fhlock);
-  pFileH->pFGroup[pFileH->nFGroups++] = fGroup;
+  pFileH->pFGroup[pFileH->nFGroups++] = fg;
   qsort((void *)(pFileH->pFGroup), pFileH->nFGroups, sizeof(SFileGroup), compFGroup);
   pthread_rwlock_unlock(&pFileH->fhlock);
 
-  pfg = tsdbSearchFGroup(pFileH, fid, TD_EQ);
+  SFileGroup *pfg = tsdbSearchFGroup(pFileH, fid, TD_EQ);
   ASSERT(pfg != NULL);
   return pfg;
 }
@@ -138,7 +137,7 @@ void tsdbRemoveFileGroup(STsdbRepo *pRepo, SFileGroup *pFGroup) {
   ASSERT(pFGroup != NULL);
   STsdbFileH *pFileH = pRepo->tsdbFileH;
 
-  SFileGroup fileGroup = *pFGroup;
+  SFileGroup fg = *pFGroup;
 
   int nFilesLeft = pFileH->nFGroups - (int)(POINTER_DISTANCE(pFGroup, pFileH->pFGroup) / sizeof(SFileGroup) + 1);
   if (nFilesLeft > 0) {
@@ -149,7 +148,7 @@ void tsdbRemoveFileGroup(STsdbRepo *pRepo, SFileGroup *pFGroup) {
   ASSERT(pFileH->nFGroups >= 0);
 
   for (int type = 0; type < TSDB_FILE_TYPE_MAX; type++) {
-    SFile *pFile = &(pFGroup->files[type]);
+    SFile *pFile = &(fg.files[type]);
     tfsremove(&(pFile->file));
   }
 }
@@ -161,6 +160,18 @@ SFileGroup *tsdbSearchFGroup(STsdbFileH *pFileH, int fid, int flags) {
   return (SFileGroup *)ptr;
 }
 
+int tsdbGetFidLevel(int fid, SFidGroup fidg) {
+  if (fid >= fidg.maxFid) {
+    return 0;
+  } else if (fid >= fidg.midFid) {
+    return 1;
+  } else if (fid >= fidg.minFid) {
+    return 2;
+  } else {
+    return -1;
+  }
+}
+
 static int compFGroup(const void *arg1, const void *arg2) {
   int val1 = ((SFileGroup *)arg1)->fileId;
   int val2 = ((SFileGroup *)arg2)->fileId;
@@ -271,7 +282,7 @@ int tsdbOpenFile(SFile *pFile, int oflag) {
 void tsdbCloseFile(SFile *pFile) {
   if (TSDB_IS_FILE_OPENED(pFile)) {
     tsdbTrace("close file %s, fd %d", TSDB_FILE_NAME(pFile), pFile->fd);
-    close(pFile->fd);
+    tfsclose(pFile->fd);
     pFile->fd = -1;
   }
 }
@@ -406,55 +417,58 @@ void tsdbGetFidGroup(STsdbCfg *pCfg, SFidGroup *pFidGroup) {
 }
 
 int tsdbApplyRetention(STsdbRepo *pRepo, SFidGroup *pFidGroup) {
-  STsdbFileH *pFileH = pRepo->tsdbFileH;
-  SFileGroup *pGroup = NULL;
-  SFileGroup  nFileGroup = {0};
-  SFileGroup  oFileGroup = {0};
-  int         level = 0;
-
-  if (tsDnodeTier->nTiers == 1 || (pFidGroup->minFid == pFidGroup->midFid && pFidGroup->midFid == pFidGroup->maxFid)) {
-    return 0;
-  }
-
-  for (int gidx = pFileH->nFGroups - 1; gidx >= 0; gidx--) {
-    pGroup = pFileH->pFGroup + gidx;
-
-    level = tsdbGetFidLevel(pGroup->fileId, pFidGroup);
-
-    if (level == pGroup->level) continue;
-    if (level > pGroup->level && level < tsDnodeTier->nTiers) {
-      SDisk *pODisk = tdGetDisk(tsDnodeTier, pGroup->level, pGroup->did);
-      SDisk *pDisk = tdAssignDisk(tsDnodeTier, level);
-      tsdbCreateVnodeDataDir(pDisk->dir, REPO_ID(pRepo));
-      oFileGroup = *pGroup;
-      nFileGroup = *pGroup;
-      nFileGroup.level = level;
-      nFileGroup.did = pDisk->did;
-
-      char tsdbRootDir[TSDB_FILENAME_LEN];
-      tdGetTsdbRootDir(pDisk->dir, REPO_ID(pRepo), tsdbRootDir);
-      for (int type = 0; type < TSDB_FILE_TYPE_MAX; type++) {
-        tsdbGetDataFileName(tsdbRootDir, REPO_ID(pRepo), pGroup->fileId, type, nFileGroup.files[type].fname);
-      }
-
-      for (int type = 0; type < TSDB_FILE_TYPE_MAX; type++) {
-        if (taosCopy(oFileGroup.files[type].fname, nFileGroup.files[type].fname) < 0) return -1;
-      }
-
-      pthread_rwlock_wrlock(&(pFileH->fhlock)); 
-      *pGroup = nFileGroup;
-      pthread_rwlock_unlock(&(pFileH->fhlock));
-
-      for (int type = 0; type < TSDB_FILE_TYPE_MAX; type++) {
-        (void)remove(oFileGroup.files[type].fname);
-      }
-
-      tdLockTiers(tsDnodeTier);
-      tdDecDiskFiles(tsDnodeTier, pODisk, false);
-      tdIncDiskFiles(tsDnodeTier, pDisk, false);
-      tdUnLockTiers(tsDnodeTier);
-    }
-  }
-
+  // TODO
   return 0;
+
+  // STsdbFileH *pFileH = pRepo->tsdbFileH;
+  // SFileGroup *pGroup = NULL;
+  // SFileGroup  nFileGroup = {0};
+  // SFileGroup  oFileGroup = {0};
+  // int         level = 0;
+
+  // if (tsDnodeTier->nTiers == 1 || (pFidGroup->minFid == pFidGroup->midFid && pFidGroup->midFid == pFidGroup->maxFid)) {
+  //   return 0;
+  // }
+
+  // for (int gidx = pFileH->nFGroups - 1; gidx >= 0; gidx--) {
+  //   pGroup = pFileH->pFGroup + gidx;
+
+  //   level = tsdbGetFidLevel(pGroup->fileId, pFidGroup);
+
+  //   if (level == pGroup->level) continue;
+  //   if (level > pGroup->level && level < tsDnodeTier->nTiers) {
+  //     SDisk *pODisk = tdGetDisk(tsDnodeTier, pGroup->level, pGroup->did);
+  //     SDisk *pDisk = tdAssignDisk(tsDnodeTier, level);
+  //     tsdbCreateVnodeDataDir(pDisk->dir, REPO_ID(pRepo));
+  //     oFileGroup = *pGroup;
+  //     nFileGroup = *pGroup;
+  //     nFileGroup.level = level;
+  //     nFileGroup.did = pDisk->did;
+
+  //     char tsdbRootDir[TSDB_FILENAME_LEN];
+  //     tdGetTsdbRootDir(pDisk->dir, REPO_ID(pRepo), tsdbRootDir);
+  //     for (int type = 0; type < TSDB_FILE_TYPE_MAX; type++) {
+  //       tsdbGetDataFileName(tsdbRootDir, REPO_ID(pRepo), pGroup->fileId, type, nFileGroup.files[type].fname);
+  //     }
+
+  //     for (int type = 0; type < TSDB_FILE_TYPE_MAX; type++) {
+  //       if (taosCopy(oFileGroup.files[type].fname, nFileGroup.files[type].fname) < 0) return -1;
+  //     }
+
+  //     pthread_rwlock_wrlock(&(pFileH->fhlock)); 
+  //     *pGroup = nFileGroup;
+  //     pthread_rwlock_unlock(&(pFileH->fhlock));
+
+  //     for (int type = 0; type < TSDB_FILE_TYPE_MAX; type++) {
+  //       (void)remove(oFileGroup.files[type].fname);
+  //     }
+
+  //     tdLockTiers(tsDnodeTier);
+  //     tdDecDiskFiles(tsDnodeTier, pODisk, false);
+  //     tdIncDiskFiles(tsDnodeTier, pDisk, false);
+  //     tdUnLockTiers(tsDnodeTier);
+  //   }
+  // }
+
+  // return 0;
 }
\ No newline at end of file

src/tsdb/src/tsdbMain.c

@@ -54,8 +54,8 @@ static void        tsdbStopStream(STsdbRepo *pRepo);
 int32_t tsdbCreateRepo(char *rootDir, STsdbCfg *pCfg) {
   char tsdbDir[TSDB_FILENAME_LEN] = "\0";
 
-  snprintf(tsdbDir, TSDB_FILENAME_LEN, "%s/%s", tfsPrimaryPath(), rootDir);
-  DIR *dir = tfs(tsdbDir);
+  snprintf(tsdbDir, TSDB_FILENAME_LEN, "%s/%s", TFS_PRIMARY_PATH(), rootDir);
+  DIR *dir = opendir(tsdbDir);
   if (dir) {
     tsdbDebug("repository %s already exists", rootDir);
     closedir(dir);
@@ -196,13 +196,15 @@ uint32_t tsdbGetFileInfo(TSDB_REPO_T *repo, char *name, uint32_t *index, uint32_
       SFileGroup *pFGroup =
           taosbsearch(&fid, pFileH->pFGroup, pFileH->nFGroups, sizeof(SFileGroup), keyFGroupCompFunc, TD_GE);
       if (pFGroup->fileId == fid) {
-        fname = strdup(pFGroup->files[(*index) % TSDB_FILE_TYPE_MAX].fname);
-        magic = pFGroup->files[(*index) % TSDB_FILE_TYPE_MAX].info.magic;
+        SFile *pFile = &pFGroup->files[(*index) % TSDB_FILE_TYPE_MAX];
+        fname = strdup(TSDB_FILE_NAME(pFile));
+        magic = pFile->info.magic;
       } else {
         if ((pFGroup->fileId + 1) * TSDB_FILE_TYPE_MAX - 1 < (int)eindex) {
-          fname = strdup(pFGroup->files[0].fname);
+          SFile *pFile = &pFGroup->files[0];
+          fname = strdup(TSDB_FILE_NAME(pFile));
           *index = pFGroup->fileId * TSDB_FILE_TYPE_MAX;
-          magic = pFGroup->files[0].info.magic;
+          magic = pFile->info.magic;
         } else {
           return 0;
         }
@@ -303,18 +305,18 @@ int tsdbGetState(TSDB_REPO_T *repo) {
 
 // ----------------- INTERNAL FUNCTIONS -----------------
 char *tsdbGetMetaFileName(char *rootDir) {
-  int   tlen = (int)(strlen(tfsPrimaryPath()) + strlen(rootDir) + strlen(TSDB_META_FILE_NAME) + 2);
+  int   tlen = (int)(strlen(TFS_PRIMARY_PATH()) + strlen(rootDir) + strlen(TSDB_META_FILE_NAME) + 2);
   char *fname = calloc(1, tlen);
   if (fname == NULL) {
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
     return NULL;
   }
 
-  snprintf(fname, tlen, "%s/%s/%s", tfsPrimaryPath(), rootDir, TSDB_META_FILE_NAME);
+  snprintf(fname, tlen, "%s/%s/%s", TFS_PRIMARY_PATH(), rootDir, TSDB_META_FILE_NAME);
   return fname;
 }
 
-void tsdbGetDataFileName(char *rootDir, int vid, int fid, int type, const char *fname) {
+void tsdbGetDataFileName(char *rootDir, int vid, int fid, int type, char *fname) {
   snprintf(fname, TSDB_FILENAME_LEN, "%s/%s/v%df%d%s", rootDir, TSDB_DATA_DIR_NAME, vid, fid, tsdbFileSuffix[type]);
 }
 
@@ -480,7 +482,7 @@ _err:
 }
 
 static int32_t tsdbSetRepoEnv(char *rootDir, STsdbCfg *pCfg) {
-  if (tfsCreateDir(rootDir) < 0) {
+  if (tfsMkdir(rootDir) < 0) {
     tsdbError("vgId:%d failed to create rootDir %s since %s", pCfg->tsdbId, rootDir, tstrerror(terrno));
     return -1;
   }
@@ -493,7 +495,7 @@ static int32_t tsdbSetRepoEnv(char *rootDir, STsdbCfg *pCfg) {
   char *dirName = tsdbGetDataDirName(rootDir);
   if (dirName == NULL) return -1;
 
-  if (tfsCreateDir(dirName) < 0) {
+  if (tfsMkdir(dirName) < 0) {
     tsdbError("vgId:%d failed to create directory %s since %s", pCfg->tsdbId, dirName, strerror(errno));
     free(dirName);
     return -1;
@@ -514,7 +516,7 @@ static int32_t tsdbSetRepoEnv(char *rootDir, STsdbCfg *pCfg) {
 }
 
 static int32_t tsdbUnsetRepoEnv(char *rootDir) {
-  tfsRemoveDir(rootDir);
+  tfsRmdir(rootDir);
   tsdbDebug("repository %s is removed", rootDir);
   return 0;
 }
@@ -610,14 +612,14 @@ _err:
 }
 
 static char *tsdbGetCfgFname(char *rootDir) {
-  int   tlen = (int)(strlen(tfsPrimaryPath()) + strlen(rootDir) + strlen(TSDB_CFG_FILE_NAME) + 3);
+  int   tlen = (int)(strlen(TFS_PRIMARY_PATH()) + strlen(rootDir) + strlen(TSDB_CFG_FILE_NAME) + 3);
   char *fname = calloc(1, tlen);
   if (fname == NULL) {
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
     return NULL;
   }
 
-  snprintf(fname, tlen, "%s/%s/%s", tfsPrimaryPath(), rootDir, TSDB_CFG_FILE_NAME);
+  snprintf(fname, tlen, "%s/%s/%s", TFS_PRIMARY_PATH(), rootDir, TSDB_CFG_FILE_NAME);
   return fname;
 }
 

src/tsdb/src/tsdbRWHelper.c

@@ -105,6 +105,9 @@ int tsdbSetAndOpenHelperFile(SRWHelper *pHelper, SFileGroup *pGroup) {
   ASSERT(pHelper != NULL && pGroup != NULL);
   SFile *    pFile = NULL;
   STsdbRepo *pRepo = pHelper->pRepo;
+  char       fname[TSDB_FILENAME_LEN] = "\0";
+  int        level = pGroup->files[0].file.level;
+  int        id = pGroup->files[0].file.id;
 
   // Clear the helper object
   tsdbResetHelper(pHelper);
@@ -113,17 +116,16 @@ int tsdbSetAndOpenHelperFile(SRWHelper *pHelper, SFileGroup *pGroup) {
 
   // Set the files
   pHelper->files.fGroup = *pGroup;
-  if (helperType(pHelper) == TSDB_WRITE_HELPER) {
-    tsdbGetDataFileName(tsdbRootDir, REPO_ID(pRepo), pGroup->fileId, TSDB_FILE_TYPE_NHEAD,
-                        helperNewHeadF(pHelper)->file.rname);
-    helperNewHeadF(pHelper)->file.level = pGroup->files[0].file.level;
-    helperNewHeadF(pHelper)->file.id = pGroup->files[0].file.id;
+  // if (helperType(pHelper) == TSDB_WRITE_HELPER) {
+  //   tsdbGetDataFileName(pRepo->rootDir, REPO_ID(pRepo), pGroup->fileId, TSDB_FILE_TYPE_NHEAD, fname);
+  //   helperNewHeadF(pHelper)->file.level = pGroup->files[0].file.level;
+  //   helperNewHeadF(pHelper)->file.id = pGroup->files[0].file.id;
 
-    tsdbGetDataFileName(tsdbRootDir, REPO_ID(pRepo), pGroup->fileId, TSDB_FILE_TYPE_NLAST,
-                        helperNewLastF(pHelper)->file.rname);
-    helperNewLastF(pHelper)->file.level = pGroup->files[0].file.level;
-    helperNewLastF(pHelper)->file.id = pGroup->files[0].file.id;
-  }
+  //   tsdbGetDataFileName(tsdbRootDir, REPO_ID(pRepo), pGroup->fileId, TSDB_FILE_TYPE_NLAST,
+  //                       helperNewLastF(pHelper)->file.rname);
+  //   helperNewLastF(pHelper)->file.level = pGroup->files[0].file.level;
+  //   helperNewLastF(pHelper)->file.id = pGroup->files[0].file.id;
+  // }
 
   // Open the files
   if (tsdbOpenFile(helperHeadF(pHelper), O_RDONLY) < 0) return -1;
@@ -133,18 +135,25 @@ int tsdbSetAndOpenHelperFile(SRWHelper *pHelper, SFileGroup *pGroup) {
 
     // Create and open .h
     pFile = helperNewHeadF(pHelper);
-    if (tsdbOpenFile(pFile, O_WRONLY | O_CREAT) < 0) return -1;
+    pFile->fd = -1;
     pFile->info.size = TSDB_FILE_HEAD_SIZE;
     pFile->info.magic = TSDB_FILE_INIT_MAGIC;
+    tsdbGetDataFileName(pRepo->rootDir, REPO_ID(pRepo), pGroup->fileId, TSDB_FILE_TYPE_NHEAD, fname);
+    tfsInitFile(&(pFile->file), level, id, fname);
+    // TODO: not allow it the increase 1
+    if (tsdbOpenFile(pFile, O_WRONLY | O_CREAT) < 0) return -1;
     if (tsdbUpdateFileHeader(pFile) < 0) return -1;
 
     // Create and open .l file if should
     if (tsdbShouldCreateNewLast(pHelper)) {
       pFile = helperNewLastF(pHelper);
-      if (tsdbOpenFile(pFile, O_WRONLY | O_CREAT) < 0) return -1;
+      pFile->fd = -1;
       pFile->info.size = TSDB_FILE_HEAD_SIZE;
       pFile->info.magic = TSDB_FILE_INIT_MAGIC;
-      pFile->info.len = 0;
+      tsdbGetDataFileName(pRepo->rootDir, REPO_ID(pRepo), pGroup->fileId, TSDB_FILE_TYPE_NHEAD, fname);
+      tfsInitFile(&(pFile->file), level, id, fname);
+      // TODO: not allow it the increase 1
+      if (tsdbOpenFile(pFile, O_WRONLY | O_CREAT) < 0) return -1;
       if (tsdbUpdateFileHeader(pFile) < 0) return -1;
     }
   } else {