tcs: unified interface of cs

include/libs/tcs/tcs.h

@@ -0,0 +1,58 @@
+/*
+ * 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_TCS_H_
+#define _TD_TCS_H_
+
+#include "os.h"
+#include "tarray.h"
+#include "tdef.h"
+#include "tlog.h"
+#include "tmsg.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int8_t tsS3Enabled;
+extern int8_t tsS3EnabledCfg;
+
+extern int32_t tsS3UploadDelaySec;
+extern int32_t tsS3BlockSize;
+extern int32_t tsS3BlockCacheSize;
+extern int32_t tsS3PageCacheSize;
+
+extern int8_t tsS3StreamEnabled;
+
+int32_t tcsInit();
+void    tcsUninit();
+
+int32_t tcsCheckCfg();
+
+int32_t tcsPutObjectFromFileOffset(const char *file, const char *object_name, int64_t offset, int64_t size);
+int32_t tcsGetObjectBlock(const char *object_name, int64_t offset, int64_t size, bool check, uint8_t **ppBlock);
+
+void tcsDeleteObjectsByPrefix(const char *prefix);
+
+int32_t tcsPutObjectFromFile2(const char *file, const char *object, int8_t withcp);
+int32_t tcsGetObjectsByPrefix(const char *prefix, const char *path);
+int32_t tcsDeleteObjects(const char *object_name[], int nobject);
+int32_t tcsGetObjectToFile(const char *object_name, const char *fileName);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // _TD_TCS_H_

source/libs/CMakeLists.txt

@@ -22,4 +22,6 @@ add_subdirectory(stream)
 add_subdirectory(planner)
 add_subdirectory(qworker)
 add_subdirectory(geometry)
-add_subdirectory(command)
+add_subdirectory(command)
+#add_subdirectory(azure)
+add_subdirectory(tcs)

source/libs/tcs/CMakeLists.txt

@@ -0,0 +1,22 @@
+aux_source_directory(src TOS_SRC)
+
+add_library(tcs STATIC ${TOS_SRC})
+target_include_directories(
+    tcs
+    PUBLIC "${TD_SOURCE_DIR}/include/libs/tcs"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+
+target_link_libraries(
+    tcs
+    PUBLIC az
+    PUBLIC common
+    # PUBLIC cjson
+    # PUBLIC os
+    # PUBLIC util
+    # PUBLIC crypt
+)
+
+if(${BUILD_TEST})
+    add_subdirectory(test)
+endif(${BUILD_TEST})

source/libs/tcs/src/tcs.c

@@ -0,0 +1,149 @@
+/*
+ * 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 "tcs.h"
+
+#include "os.h"
+#include "taoserror.h"
+#include "tglobal.h"
+
+//#include "az.h"
+#include "cos.h"
+
+extern int8_t tsS3Ablob;
+
+typedef enum {
+  TOS_PROTO_NIL,
+  TOS_PROTO_S3,
+  TOS_PROTO_ABLOB,
+} STosProto;
+
+typedef struct {
+  int32_t (*Begin)();
+  void (*End)();
+  int32_t (*CheckCfg)();
+
+  int32_t (*PutObjectFromFileOffset)(const char* file, const char* object_name, int64_t offset, int64_t size);
+  int32_t (*GetObjectBlock)(const char* object_name, int64_t offset, int64_t size, bool check, uint8_t** ppBlock);
+
+  void (*DeleteObjectsByPrefix)(const char* prefix);
+
+  int32_t (*PutObjectFromFile2)(const char* file, const char* object, int8_t withcp);
+  int32_t (*GetObjectsByPrefix)(const char* prefix, const char* path);
+  int32_t (*DeleteObjects)(const char* object_name[], int nobject);
+  int32_t (*GetObjectToFile)(const char* object_name, const char* fileName);
+} STcs;
+
+static STcs tcs;
+
+int32_t tcsInit() {
+  int32_t code = 0;
+
+  STosProto proto = tsS3Ablob ? TOS_PROTO_ABLOB : TOS_PROTO_S3;
+
+  if (TOS_PROTO_S3 == proto) {
+    tcs.Begin = s3Begin;
+    tcs.End = s3End;
+    tcs.CheckCfg = s3CheckCfg;
+
+    tcs.PutObjectFromFileOffset = s3PutObjectFromFileOffset;
+    tcs.GetObjectBlock = s3GetObjectBlock;
+
+    tcs.DeleteObjectsByPrefix = s3DeleteObjectsByPrefix;
+
+    tcs.PutObjectFromFile2 = s3PutObjectFromFile2;
+    tcs.GetObjectsByPrefix = s3GetObjectsByPrefix;
+    tcs.DeleteObjects = s3DeleteObjects;
+    tcs.GetObjectToFile = s3GetObjectToFile;
+  } else if (TOS_PROTO_ABLOB == proto) {
+    /*
+    tcs.Begin = azBegin;
+    tcs.End = azEnd;
+    tcs.CheckCfg = azCheckCfg;
+
+    tcs.PutObjectFromFileOffset = azPutObjectFromFileOffset;
+    tcs.GetObjectBlock = azGetObjectBlock;
+
+    tcs.DeleteObjectsByPrefix = azDeleteObjectsByPrefix;
+
+    tcs.PutObjectFromFile2 = azPutObjectFromFile2;
+    tcs.GetObjectsByPrefix = azGetObjectsByPrefix;
+    tcs.DeleteObjects = azDeleteObjects;
+    tcs.GetObjectToFile = azGetObjectToFile;
+    */
+  } else {
+    code = TSDB_CODE_INVALID_PARA;
+    return code;
+  }
+
+  code = tcs.Begin();
+
+  return code;
+}
+
+void tcsUninit() { tcs.End(); }
+
+int32_t tcsCheckCfg() {
+  int32_t code = 0;
+
+  if (!tsS3Enabled) {
+    (void)fprintf(stderr, "s3 not configured.\n");
+    TAOS_RETURN(code);
+  }
+
+  code = tcsInit();
+  if (code != 0) {
+    (void)fprintf(stderr, "failed to initialize s3.\n");
+    TAOS_RETURN(code);
+  }
+
+  code = s3Begin();
+  if (code != 0) {
+    (void)fprintf(stderr, "failed to begin s3.\n");
+    TAOS_RETURN(code);
+  }
+
+  code = tcs.CheckCfg();
+  if (code != 0) {
+    (void)fprintf(stderr, "failed to check s3.\n");
+    TAOS_RETURN(code);
+  }
+
+  tcsUninit();
+
+  return code;
+}
+
+int32_t tcsPutObjectFromFileOffset(const char* file, const char* object_name, int64_t offset, int64_t size) {
+  return tcs.PutObjectFromFileOffset(file, object_name, offset, size);
+}
+
+int32_t tcsGetObjectBlock(const char* object_name, int64_t offset, int64_t size, bool check, uint8_t** ppBlock) {
+  return tcs.GetObjectBlock(object_name, offset, size, check, ppBlock);
+}
+
+void tcsDeleteObjectsByPrefix(const char* prefix) { return tcs.DeleteObjectsByPrefix(prefix); }
+
+int32_t tcsPutObjectFromFile2(const char* file, const char* object, int8_t withcp) {
+  return tcs.PutObjectFromFile2(file, object, withcp);
+}
+
+int32_t tcsGetObjectsByPrefix(const char* prefix, const char* path) { return tcs.GetObjectsByPrefix(prefix, path); }
+
+int32_t tcsDeleteObjects(const char* object_name[], int nobject) { return tcs.DeleteObjects(object_name, nobject); }
+
+int32_t tcsGetObjectToFile(const char* object_name, const char* fileName) {
+  return tcs.GetObjectToFile(object_name, fileName);
+}

source/libs/tcs/test/CMakeLists.txt

@@ -0,0 +1,18 @@
+aux_source_directory(. TOS_TEST_SRC)
+
+add_executable(tosTest ${TOS_TEST_SRC})
+target_include_directories(tosTest
+    PUBLIC
+    "${TD_SOURCE_DIR}/include/libs/tosure"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
+)
+
+target_link_libraries(tosTest
+    tcs
+    gtest_main
+)
+enable_testing()
+add_test(
+    NAME tos_test
+    COMMAND tosTest
+)

source/libs/tcs/test/tcsTest.c

@@ -0,0 +1,395 @@
+#include <gtest/gtest.h>
+#include <cstring>
+#include <iostream>
+#include <queue>
+/*
+#include "walInt.h"
+const char*  ranStr = "tvapq02tcp";
+const int    ranStrLen = strlen(ranStr);
+SWalSyncInfo syncMeta = {0};
+class WalCleanEnv : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    int code = walInit(NULL);
+    ASSERT(code == 0);
+  }
+  static void TearDownTestCase() { walCleanUp(); }
+  void SetUp() override {
+    taosRemoveDir(pathName);
+    SWalCfg* pCfg = (SWalCfg*)taosMemoryMalloc(sizeof(SWalCfg));
+    memset(pCfg, 0, sizeof(SWalCfg));
+    pCfg->rollPeriod = -1;
+    pCfg->segSize = -1;
+    pCfg->retentionPeriod = 0;
+    pCfg->retentionSize = 0;
+    pCfg->level = TAOS_WAL_FSYNC;
+    pWal = walOpen(pathName, pCfg);
+    taosMemoryFree(pCfg);
+    ASSERT(pWal != NULL);
+  }
+  void TearDown() override {
+    walClose(pWal);
+    pWal = NULL;
+  }
+  SWal*       pWal = NULL;
+  const char* pathName = TD_TMP_DIR_PATH "wal_test";
+};
+class WalCleanDeleteEnv : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    int code = walInit(NULL);
+    ASSERT(code == 0);
+  }
+  static void TearDownTestCase() { walCleanUp(); }
+  void SetUp() override {
+    taosRemoveDir(pathName);
+    SWalCfg* pCfg = (SWalCfg*)taosMemoryMalloc(sizeof(SWalCfg));
+    memset(pCfg, 0, sizeof(SWalCfg));
+    pCfg->retentionPeriod = 0;
+    pCfg->retentionSize = 0;
+    pCfg->level = TAOS_WAL_FSYNC;
+    pWal = walOpen(pathName, pCfg);
+    taosMemoryFree(pCfg);
+    ASSERT(pWal != NULL);
+  }
+  void TearDown() override {
+    walClose(pWal);
+    pWal = NULL;
+  }
+  SWal*       pWal = NULL;
+  const char* pathName = TD_TMP_DIR_PATH "wal_test";
+};
+class WalKeepEnv : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    int code = walInit(NULL);
+    ASSERT(code == 0);
+  }
+  static void TearDownTestCase() { walCleanUp(); }
+  void walResetEnv() {
+    TearDown();
+    taosRemoveDir(pathName);
+    SetUp();
+  }
+  void SetUp() override {
+    SWalCfg* pCfg = (SWalCfg*)taosMemoryMalloc(sizeof(SWalCfg));
+    memset(pCfg, 0, sizeof(SWalCfg));
+    pCfg->rollPeriod = -1;
+    pCfg->segSize = -1;
+    pCfg->retentionPeriod = 0;
+    pCfg->retentionSize = 0;
+    pCfg->level = TAOS_WAL_FSYNC;
+    pWal = walOpen(pathName, pCfg);
+    taosMemoryFree(pCfg);
+    ASSERT(pWal != NULL);
+  }
+  void TearDown() override {
+    walClose(pWal);
+    pWal = NULL;
+  }
+  SWal*       pWal = NULL;
+  const char* pathName = TD_TMP_DIR_PATH "wal_test";
+};
+class WalRetentionEnv : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    int code = walInit(NULL);
+    ASSERT(code == 0);
+  }
+  static void TearDownTestCase() { walCleanUp(); }
+  void walResetEnv() {
+    TearDown();
+    taosRemoveDir(pathName);
+    SetUp();
+  }
+  void SetUp() override {
+    SWalCfg cfg;
+    cfg.rollPeriod = -1;
+    cfg.segSize = -1;
+    cfg.retentionPeriod = -1;
+    cfg.retentionSize = 0;
+    cfg.rollPeriod = 0;
+    cfg.vgId = 0;
+    cfg.level = TAOS_WAL_FSYNC;
+    pWal = walOpen(pathName, &cfg);
+    ASSERT(pWal != NULL);
+  }
+  void TearDown() override {
+    walClose(pWal);
+    pWal = NULL;
+  }
+  SWal*       pWal = NULL;
+  const char* pathName = TD_TMP_DIR_PATH "wal_test";
+};
+TEST_F(WalCleanEnv, createNew) {
+  walRollFileInfo(pWal);
+  ASSERT(pWal->fileInfoSet != NULL);
+  ASSERT_EQ(pWal->fileInfoSet->size, 1);
+  SWalFileInfo* pInfo = (SWalFileInfo*)taosArrayGetLast(pWal->fileInfoSet);
+  ASSERT_EQ(pInfo->firstVer, 0);
+  ASSERT_EQ(pInfo->lastVer, -1);
+  ASSERT_EQ(pInfo->closeTs, -1);
+  ASSERT_EQ(pInfo->fileSize, 0);
+}
+TEST_F(WalCleanEnv, serialize) {
+  int code = walRollFileInfo(pWal);
+  ASSERT(code == 0);
+  ASSERT(pWal->fileInfoSet != NULL);
+  code = walRollFileInfo(pWal);
+  ASSERT(code == 0);
+  code = walRollFileInfo(pWal);
+  ASSERT(code == 0);
+  code = walRollFileInfo(pWal);
+  ASSERT(code == 0);
+  code = walRollFileInfo(pWal);
+  ASSERT(code == 0);
+  code = walRollFileInfo(pWal);
+  ASSERT(code == 0);
+  char* ss = NULL;
+  code = walMetaSerialize(pWal, &ss);
+  ASSERT(code == 0);
+  printf("%s\n", ss);
+  taosMemoryFree(ss);
+  code = walSaveMeta(pWal);
+  ASSERT(code == 0);
+}
+TEST_F(WalCleanEnv, removeOldMeta) {
+  int code = walRollFileInfo(pWal);
+  ASSERT(code == 0);
+  ASSERT(pWal->fileInfoSet != NULL);
+  code = walSaveMeta(pWal);
+  ASSERT(code == 0);
+  code = walRollFileInfo(pWal);
+  ASSERT(code == 0);
+  code = walSaveMeta(pWal);
+  ASSERT(code == 0);
+}
+TEST_F(WalKeepEnv, readOldMeta) {
+  walResetEnv();
+  int code;
+  syncMeta.isWeek = -1;
+  syncMeta.seqNum = UINT64_MAX;
+  syncMeta.term = UINT64_MAX;
+  for (int i = 0; i < 10; i++) {
+    code = walAppendLog(pWal, i, i + 1, syncMeta, (void*)ranStr, ranStrLen);
+    ASSERT_EQ(code, 0);
+    ASSERT_EQ(pWal->vers.lastVer, i);
+    code = walAppendLog(pWal, i + 2, i, syncMeta, (void*)ranStr, ranStrLen);
+    ASSERT_EQ(code, TSDB_CODE_WAL_INVALID_VER);
+    ASSERT_EQ(pWal->vers.lastVer, i);
+  }
+  char* oldss = NULL;
+  code = walMetaSerialize(pWal, &oldss);
+  ASSERT(code == 0);
+  TearDown();
+  SetUp();
+  ASSERT_EQ(pWal->vers.firstVer, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 9);
+  char* newss = NULL;
+  code = walMetaSerialize(pWal, &newss);
+  ASSERT(code == 0);
+  int len = strlen(oldss);
+  ASSERT_EQ(len, strlen(newss));
+  for (int i = 0; i < len; i++) {
+    EXPECT_EQ(oldss[i], newss[i]);
+  }
+  taosMemoryFree(oldss);
+  taosMemoryFree(newss);
+}
+TEST_F(WalCleanEnv, write) {
+  int code;
+  for (int i = 0; i < 10; i++) {
+    code = walAppendLog(pWal, i, i + 1, syncMeta, (void*)ranStr, ranStrLen);
+    ASSERT_EQ(code, 0);
+    ASSERT_EQ(pWal->vers.lastVer, i);
+    code = walAppendLog(pWal, i + 2, i, syncMeta, (void*)ranStr, ranStrLen);
+    ASSERT_EQ(code, TSDB_CODE_WAL_INVALID_VER);
+    ASSERT_EQ(pWal->vers.lastVer, i);
+  }
+  code = walSaveMeta(pWal);
+  ASSERT_EQ(code, 0);
+}
+TEST_F(WalCleanEnv, rollback) {
+  int code;
+  for (int i = 0; i < 10; i++) {
+    code = walAppendLog(pWal, i, i + 1, syncMeta, (void*)ranStr, ranStrLen);
+    ASSERT_EQ(code, 0);
+    ASSERT_EQ(pWal->vers.lastVer, i);
+  }
+  code = walRollback(pWal, 12);
+  ASSERT_NE(code, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 9);
+  code = walRollback(pWal, 9);
+  ASSERT_EQ(code, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 8);
+  code = walRollback(pWal, 5);
+  ASSERT_EQ(code, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 4);
+  code = walRollback(pWal, 3);
+  ASSERT_EQ(code, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 2);
+  code = walSaveMeta(pWal);
+  ASSERT_EQ(code, 0);
+}
+TEST_F(WalCleanEnv, rollbackMultiFile) {
+  int code;
+  for (int i = 0; i < 10; i++) {
+    code = walAppendLog(pWal, i, i + 1, syncMeta, (void*)ranStr, ranStrLen);
+    ASSERT_EQ(code, 0);
+    ASSERT_EQ(pWal->vers.lastVer, i);
+    if (i == 5) {
+      walBeginSnapshot(pWal, i, 0);
+      walEndSnapshot(pWal);
+    }
+  }
+  code = walRollback(pWal, 12);
+  ASSERT_NE(code, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 9);
+  code = walRollback(pWal, 9);
+  ASSERT_EQ(code, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 8);
+  code = walRollback(pWal, 6);
+  ASSERT_EQ(code, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 5);
+  code = walRollback(pWal, 5);
+  ASSERT_NE(code, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 5);
+  code = walAppendLog(pWal, 6, 6, syncMeta, (void*)ranStr, ranStrLen);
+  ASSERT_EQ(code, 0);
+  ASSERT_EQ(pWal->vers.lastVer, 6);
+  code = walSaveMeta(pWal);
+  ASSERT_EQ(code, 0);
+}
+TEST_F(WalCleanDeleteEnv, roll) {
+  int code;
+  int i;
+  for (i = 0; i < 100; i++) {
+    code = walAppendLog(pWal, i, 0, syncMeta, (void*)ranStr, ranStrLen);
+    ASSERT_EQ(code, 0);
+    ASSERT_EQ(pWal->vers.lastVer, i);
+    code = walCommit(pWal, i);
+    ASSERT_EQ(pWal->vers.commitVer, i);
+  }
+  walBeginSnapshot(pWal, i - 1, 0);
+  ASSERT_EQ(pWal->vers.verInSnapshotting, i - 1);
+  walEndSnapshot(pWal);
+  ASSERT_EQ(pWal->vers.snapshotVer, i - 1);
+  ASSERT_EQ(pWal->vers.verInSnapshotting, -1);
+  code = walAppendLog(pWal, 5, 0, syncMeta, (void*)ranStr, ranStrLen);
+  ASSERT_NE(code, 0);
+  for (; i < 200; i++) {
+    code = walAppendLog(pWal, i, 0, syncMeta, (void*)ranStr, ranStrLen);
+    ASSERT_EQ(code, 0);
+    code = walCommit(pWal, i);
+    ASSERT_EQ(pWal->vers.commitVer, i);
+  }
+  code = walBeginSnapshot(pWal, i - 1, 0);
+  ASSERT_EQ(code, 0);
+  code = walEndSnapshot(pWal);
+  ASSERT_EQ(code, 0);
+}
+TEST_F(WalKeepEnv, readHandleRead) {
+  walResetEnv();
+  int         code;
+  SWalReader* pRead = walOpenReader(pWal, NULL, 0);
+  ASSERT(pRead != NULL);
+  int i;
+  for (i = 0; i < 100; i++) {
+    char newStr[100];
+    sprintf(newStr, "%s-%d", ranStr, i);
+    int len = strlen(newStr);
+    code = walAppendLog(pWal, i, 0, syncMeta, newStr, len);
+    ASSERT_EQ(code, 0);
+  }
+  for (int i = 0; i < 1000; i++) {
+    int ver = taosRand() % 100;
+    code = walReadVer(pRead, ver);
+    ASSERT_EQ(code, 0);
+    // printf("rrbody: \n");
+    // for(int i = 0; i < pRead->pHead->head.len; i++) {
+    // printf("%d ", pRead->pHead->head.body[i]);
+    //}
+    // printf("\n");
+    ASSERT_EQ(pRead->pHead->head.version, ver);
+    ASSERT_EQ(pRead->curVersion, ver + 1);
+    char newStr[100];
+    sprintf(newStr, "%s-%d", ranStr, ver);
+    int len = strlen(newStr);
+    ASSERT_EQ(pRead->pHead->head.bodyLen, len);
+    for (int j = 0; j < len; j++) {
+      EXPECT_EQ(newStr[j], pRead->pHead->head.body[j]);
+    }
+  }
+  walCloseReader(pRead);
+}
+TEST_F(WalRetentionEnv, repairMeta1) {
+  walResetEnv();
+  int code;
+  int i;
+  for (i = 0; i < 100; i++) {
+    char newStr[100];
+    sprintf(newStr, "%s-%d", ranStr, i);
+    int len = strlen(newStr);
+    code = walAppendLog(pWal, i, 0, syncMeta, newStr, len);
+    ASSERT_EQ(code, 0);
+  }
+  TearDown();
+  // getchar();
+  char buf[100];
+  sprintf(buf, "%s/meta-ver%d", pathName, 0);
+  taosRemoveFile(buf);
+  sprintf(buf, "%s/meta-ver%d", pathName, 1);
+  taosRemoveFile(buf);
+  SetUp();
+  // getchar();
+  ASSERT_EQ(pWal->vers.lastVer, 99);
+  SWalReader* pRead = walOpenReader(pWal, NULL, 0);
+  ASSERT(pRead != NULL);
+  for (int i = 0; i < 1000; i++) {
+    int ver = taosRand() % 100;
+    code = walReadVer(pRead, ver);
+    ASSERT_EQ(code, 0);
+    // printf("rrbody: \n");
+    // for(int i = 0; i < pRead->pHead->head.len; i++) {
+    // printf("%d ", pRead->pHead->head.body[i]);
+    //}
+    // printf("\n");
+    ASSERT_EQ(pRead->pHead->head.version, ver);
+    ASSERT_EQ(pRead->curVersion, ver + 1);
+    char newStr[100];
+    sprintf(newStr, "%s-%d", ranStr, ver);
+    int len = strlen(newStr);
+    ASSERT_EQ(pRead->pHead->head.bodyLen, len);
+    for (int j = 0; j < len; j++) {
+      EXPECT_EQ(newStr[j], pRead->pHead->head.body[j]);
+    }
+  }
+  for (i = 100; i < 200; i++) {
+    char newStr[100];
+    sprintf(newStr, "%s-%d", ranStr, i);
+    int len = strlen(newStr);
+    code = walAppendLog(pWal, i, 0, syncMeta, newStr, len);
+    ASSERT_EQ(code, 0);
+  }
+  for (int i = 0; i < 1000; i++) {
+    int ver = taosRand() % 200;
+    code = walReadVer(pRead, ver);
+    ASSERT_EQ(code, 0);
+    // printf("rrbody: \n");
+    // for(int i = 0; i < pRead->pHead->head.len; i++) {
+    // printf("%d ", pRead->pHead->head.body[i]);
+    //}
+    // printf("\n");
+    ASSERT_EQ(pRead->pHead->head.version, ver);
+    ASSERT_EQ(pRead->curVersion, ver + 1);
+    char newStr[100];
+    sprintf(newStr, "%s-%d", ranStr, ver);
+    int len = strlen(newStr);
+    ASSERT_EQ(pRead->pHead->head.bodyLen, len);
+    for (int j = 0; j < len; j++) {
+      EXPECT_EQ(newStr[j], pRead->pHead->head.body[j]);
+    }
+  }
+  walCloseReader(pRead);
+}
+*/