serailze db req

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

@@ -15,6 +15,7 @@
 
 #define _DEFAULT_SOURCE
 #include "mndDb.h"
+#include "mndAuth.h"
 #include "mndDnode.h"
 #include "mndShow.h"
 #include "mndTrans.h"
@@ -452,53 +453,53 @@ CREATE_DB_OVER:
 
 static int32_t mndProcessCreateDbReq(SMnodeMsg *pReq) {
   SMnode      *pMnode = pReq->pMnode;
-  SCreateDbReq *pCreate = pReq->rpcMsg.pCont;
-
-  pCreate->numOfVgroups = htonl(pCreate->numOfVgroups);
-  pCreate->cacheBlockSize = htonl(pCreate->cacheBlockSize);
-  pCreate->totalBlocks = htonl(pCreate->totalBlocks);
-  pCreate->daysPerFile = htonl(pCreate->daysPerFile);
-  pCreate->daysToKeep0 = htonl(pCreate->daysToKeep0);
-  pCreate->daysToKeep1 = htonl(pCreate->daysToKeep1);
-  pCreate->daysToKeep2 = htonl(pCreate->daysToKeep2);
-  pCreate->minRows = htonl(pCreate->minRows);
-  pCreate->maxRows = htonl(pCreate->maxRows);
-  pCreate->commitTime = htonl(pCreate->commitTime);
-  pCreate->fsyncPeriod = htonl(pCreate->fsyncPeriod);
-
-  mDebug("db:%s, start to create, vgroups:%d", pCreate->db, pCreate->numOfVgroups);
-
-  SDbObj *pDb = mndAcquireDb(pMnode, pCreate->db);
+  int32_t      code = -1;
+  SDbObj      *pDb = NULL;
+  SUserObj    *pUser = NULL;
+  SCreateDbReq createReq = {0};
+
+  if (tDeserializeSCreateDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto CREATE_DB_OVER;
+  }
+
+  mDebug("db:%s, start to create, vgroups:%d", createReq.db, createReq.numOfVgroups);
+
+  pDb = mndAcquireDb(pMnode, createReq.db);
   if (pDb != NULL) {
-    mndReleaseDb(pMnode, pDb);
-    if (pCreate->ignoreExist) {
-      mDebug("db:%s, already exist, ignore exist is set", pCreate->db);
-      return 0;
+    if (createReq.ignoreExist) {
+      mDebug("db:%s, already exist, ignore exist is set", createReq.db);
+      code = 0;
+      goto CREATE_DB_OVER;
     } else {
       terrno = TSDB_CODE_MND_DB_ALREADY_EXIST;
-      mError("db:%s, failed to create since %s", pCreate->db, terrstr());
-      return -1;
+      goto CREATE_DB_OVER;
     }
   } else if (terrno != TSDB_CODE_MND_DB_NOT_EXIST) {
-    mError("db:%s, failed to create since %s", pCreate->db, terrstr());
-    return -1;
+    goto CREATE_DB_OVER;
   }
 
-  SUserObj *pOperUser = mndAcquireUser(pMnode, pReq->user);
-  if (pOperUser == NULL) {
-    mError("db:%s, failed to create since %s", pCreate->db, terrstr());
-    return -1;
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    goto CREATE_DB_OVER;
   }
 
-  int32_t code = mndCreateDb(pMnode, pReq, pCreate, pOperUser);
-  mndReleaseUser(pMnode, pOperUser);
+  if (mndCheckCreateDbAuth(pUser) != 0) {
+    goto CREATE_DB_OVER;
+  }
 
-  if (code != 0) {
-    mError("db:%s, failed to create since %s", pCreate->db, terrstr());
-    return -1;
+  code = mndCreateDb(pMnode, pReq, &createReq, pUser);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+CREATE_DB_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("db:%s, failed to create since %s", createReq.db, terrstr());
   }
 
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  mndReleaseDb(pMnode, pDb);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {
@@ -834,7 +835,7 @@ static void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SVgroupInfo *vgLis
       pInfo->epset.numOfEps = pVgroup->replica;
       for (int32_t gid = 0; gid < pVgroup->replica; ++gid) {
         SVnodeGid *pVgid = &pVgroup->vnodeGid[gid];
-        SEp *       pEp = &pInfo->epset.eps[gid];
+        SEp       *pEp = &pInfo->epset.eps[gid];
         SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
         if (pDnode != NULL) {
           memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);

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

@@ -53,29 +53,31 @@ TEST_F(MndTestDb, 01_ShowDb) {
 
 TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
   {
-    int32_t contLen = sizeof(SCreateDbReq);
-
-    SCreateDbReq* pReq = (SCreateDbReq*)rpcMallocCont(contLen);
-    strcpy(pReq->db, "1.d1");
-    pReq->numOfVgroups = htonl(2);
-    pReq->cacheBlockSize = htonl(16);
-    pReq->totalBlocks = htonl(10);
-    pReq->daysPerFile = htonl(10);
-    pReq->daysToKeep0 = htonl(3650);
-    pReq->daysToKeep1 = htonl(3650);
-    pReq->daysToKeep2 = htonl(3650);
-    pReq->minRows = htonl(100);
-    pReq->maxRows = htonl(4096);
-    pReq->commitTime = htonl(3600);
-    pReq->fsyncPeriod = htonl(3000);
-    pReq->walLevel = 1;
-    pReq->precision = 0;
-    pReq->compression = 2;
-    pReq->replications = 1;
-    pReq->quorum = 1;
-    pReq->update = 0;
-    pReq->cacheLastRow = 0;
-    pReq->ignoreExist = 1;
+    SCreateDbReq createReq = {0};
+    strcpy(createReq.db, "1.d1");
+    createReq.numOfVgroups = 2;
+    createReq.cacheBlockSize = 16;
+    createReq.totalBlocks = 10;
+    createReq.daysPerFile = 10;
+    createReq.daysToKeep0 = 3650;
+    createReq.daysToKeep1 = 3650;
+    createReq.daysToKeep2 = 3650;
+    createReq.minRows = 100;
+    createReq.maxRows = 4096;
+    createReq.commitTime = 3600;
+    createReq.fsyncPeriod = 3000;
+    createReq.walLevel = 1;
+    createReq.precision = 0;
+    createReq.compression = 2;
+    createReq.replications = 1;
+    createReq.quorum = 1;
+    createReq.update = 0;
+    createReq.cacheLastRow = 0;
+    createReq.ignoreExist = 1;
+
+    int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSCreateDbReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -217,29 +219,31 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
 
 TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
   {
-    int32_t contLen = sizeof(SCreateDbReq);
-
-    SCreateDbReq* pReq = (SCreateDbReq*)rpcMallocCont(contLen);
-    strcpy(pReq->db, "1.d2");
-    pReq->numOfVgroups = htonl(2);
-    pReq->cacheBlockSize = htonl(16);
-    pReq->totalBlocks = htonl(10);
-    pReq->daysPerFile = htonl(10);
-    pReq->daysToKeep0 = htonl(3650);
-    pReq->daysToKeep1 = htonl(3650);
-    pReq->daysToKeep2 = htonl(3650);
-    pReq->minRows = htonl(100);
-    pReq->maxRows = htonl(4096);
-    pReq->commitTime = htonl(3600);
-    pReq->fsyncPeriod = htonl(3000);
-    pReq->walLevel = 1;
-    pReq->precision = 0;
-    pReq->compression = 2;
-    pReq->replications = 1;
-    pReq->quorum = 1;
-    pReq->update = 0;
-    pReq->cacheLastRow = 0;
-    pReq->ignoreExist = 1;
+    SCreateDbReq createReq = {0};
+    strcpy(createReq.db, "1.d2");
+    createReq.numOfVgroups = 2;
+    createReq.cacheBlockSize = 16;
+    createReq.totalBlocks = 10;
+    createReq.daysPerFile = 10;
+    createReq.daysToKeep0 = 3650;
+    createReq.daysToKeep1 = 3650;
+    createReq.daysToKeep2 = 3650;
+    createReq.minRows = 100;
+    createReq.maxRows = 4096;
+    createReq.commitTime = 3600;
+    createReq.fsyncPeriod = 3000;
+    createReq.walLevel = 1;
+    createReq.precision = 0;
+    createReq.compression = 2;
+    createReq.replications = 1;
+    createReq.quorum = 1;
+    createReq.update = 0;
+    createReq.cacheLastRow = 0;
+    createReq.ignoreExist = 1;
+
+    int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSCreateDbReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);

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

@@ -38,29 +38,31 @@ class MndTestStb : public ::testing::Test {
 Testbase MndTestStb::test;
 
 void* MndTestStb::BuildCreateDbReq(const char* dbname, int32_t* pContLen) {
-  int32_t contLen = sizeof(SCreateDbReq);
-
-  SCreateDbReq* pReq = (SCreateDbReq*)rpcMallocCont(contLen);
-  strcpy(pReq->db, dbname);
-  pReq->numOfVgroups = htonl(2);
-  pReq->cacheBlockSize = htonl(16);
-  pReq->totalBlocks = htonl(10);
-  pReq->daysPerFile = htonl(10);
-  pReq->daysToKeep0 = htonl(3650);
-  pReq->daysToKeep1 = htonl(3650);
-  pReq->daysToKeep2 = htonl(3650);
-  pReq->minRows = htonl(100);
-  pReq->maxRows = htonl(4096);
-  pReq->commitTime = htonl(3600);
-  pReq->fsyncPeriod = htonl(3000);
-  pReq->walLevel = 1;
-  pReq->precision = 0;
-  pReq->compression = 2;
-  pReq->replications = 1;
-  pReq->quorum = 1;
-  pReq->update = 0;
-  pReq->cacheLastRow = 0;
-  pReq->ignoreExist = 1;
+  SCreateDbReq createReq = {0};
+  strcpy(createReq.db, dbname);
+  createReq.numOfVgroups = 2;
+  createReq.cacheBlockSize = 16;
+  createReq.totalBlocks = 10;
+  createReq.daysPerFile = 10;
+  createReq.daysToKeep0 = 3650;
+  createReq.daysToKeep1 = 3650;
+  createReq.daysToKeep2 = 3650;
+  createReq.minRows = 100;
+  createReq.maxRows = 4096;
+  createReq.commitTime = 3600;
+  createReq.fsyncPeriod = 3000;
+  createReq.walLevel = 1;
+  createReq.precision = 0;
+  createReq.compression = 2;
+  createReq.replications = 1;
+  createReq.quorum = 1;
+  createReq.update = 0;
+  createReq.cacheLastRow = 0;
+  createReq.ignoreExist = 1;
+
+  int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);
+  void*   pReq = rpcMallocCont(contLen);
+  tSerializeSCreateDbReq(pReq, contLen, &createReq);
 
   *pContLen = contLen;
   return pReq;

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

@@ -319,29 +319,31 @@ TEST_F(MndTestUser, 03_Alter_User) {
   }
 
   {
-    int32_t contLen = sizeof(SCreateDbReq);
-
-    SCreateDbReq* pReq = (SCreateDbReq*)rpcMallocCont(contLen);
-    strcpy(pReq->db, "1.d2");
-    pReq->numOfVgroups = htonl(2);
-    pReq->cacheBlockSize = htonl(16);
-    pReq->totalBlocks = htonl(10);
-    pReq->daysPerFile = htonl(10);
-    pReq->daysToKeep0 = htonl(3650);
-    pReq->daysToKeep1 = htonl(3650);
-    pReq->daysToKeep2 = htonl(3650);
-    pReq->minRows = htonl(100);
-    pReq->maxRows = htonl(4096);
-    pReq->commitTime = htonl(3600);
-    pReq->fsyncPeriod = htonl(3000);
-    pReq->walLevel = 1;
-    pReq->precision = 0;
-    pReq->compression = 2;
-    pReq->replications = 1;
-    pReq->quorum = 1;
-    pReq->update = 0;
-    pReq->cacheLastRow = 0;
-    pReq->ignoreExist = 1;
+    SCreateDbReq createReq = {0};
+    strcpy(createReq.db, "1.d2");
+    createReq.numOfVgroups = 2;
+    createReq.cacheBlockSize = 16;
+    createReq.totalBlocks = 10;
+    createReq.daysPerFile = 10;
+    createReq.daysToKeep0 = 3650;
+    createReq.daysToKeep1 = 3650;
+    createReq.daysToKeep2 = 3650;
+    createReq.minRows = 100;
+    createReq.maxRows = 4096;
+    createReq.commitTime = 3600;
+    createReq.fsyncPeriod = 3000;
+    createReq.walLevel = 1;
+    createReq.precision = 0;
+    createReq.compression = 2;
+    createReq.replications = 1;
+    createReq.quorum = 1;
+    createReq.update = 0;
+    createReq.cacheLastRow = 0;
+    createReq.ignoreExist = 1;
+
+    int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSCreateDbReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);

source/libs/catalog/test/catalogTests.cpp

@@ -39,7 +39,7 @@ namespace {
 extern "C" int32_t ctgGetTableMetaFromCache(struct SCatalog *pCatalog, const SName *pTableName, STableMeta **pTableMeta,
                                             int32_t *exist);
 extern "C" int32_t ctgUpdateTableMetaCache(struct SCatalog *pCatalog, STableMetaOutput *output);
-extern "C" int32_t ctgDbgGetClusterCacheNum(struct SCatalog* pCatalog, int32_t type);
+extern "C" int32_t ctgDbgGetClusterCacheNum(struct SCatalog *pCatalog, int32_t type);
 
 void ctgTestSetPrepareTableMeta();
 void ctgTestSetPrepareCTableMeta();
@@ -69,31 +69,35 @@ char    *ctgTestCTablename = "ctable1";
 char    *ctgTestSTablename = "stable1";
 
 void sendCreateDbMsg(void *shandle, SEpSet *pEpSet) {
-  SCreateDbReq *pReq = (SCreateDbReq *)rpcMallocCont(sizeof(SCreateDbReq));
-  strcpy(pReq->db, "1.db1");
-  pReq->numOfVgroups = htonl(2);
-  pReq->cacheBlockSize = htonl(16);
-  pReq->totalBlocks = htonl(10);
-  pReq->daysPerFile = htonl(10);
-  pReq->daysToKeep0 = htonl(3650);
-  pReq->daysToKeep1 = htonl(3650);
-  pReq->daysToKeep2 = htonl(3650);
-  pReq->minRows = htonl(100);
-  pReq->maxRows = htonl(4096);
-  pReq->commitTime = htonl(3600);
-  pReq->fsyncPeriod = htonl(3000);
-  pReq->walLevel = 1;
-  pReq->precision = 0;
-  pReq->compression = 2;
-  pReq->replications = 1;
-  pReq->quorum = 1;
-  pReq->update = 0;
-  pReq->cacheLastRow = 0;
-  pReq->ignoreExist = 1;
+  SCreateDbReq createReq = {0};
+  strcpy(createReq.db, "1.db1");
+  createReq.numOfVgroups = 2;
+  createReq.cacheBlockSize = 16;
+  createReq.totalBlocks = 10;
+  createReq.daysPerFile = 10;
+  createReq.daysToKeep0 = 3650;
+  createReq.daysToKeep1 = 3650;
+  createReq.daysToKeep2 = 3650;
+  createReq.minRows = 100;
+  createReq.maxRows = 4096;
+  createReq.commitTime = 3600;
+  createReq.fsyncPeriod = 3000;
+  createReq.walLevel = 1;
+  createReq.precision = 0;
+  createReq.compression = 2;
+  createReq.replications = 1;
+  createReq.quorum = 1;
+  createReq.update = 0;
+  createReq.cacheLastRow = 0;
+  createReq.ignoreExist = 1;
+
+  int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);
+  void   *pReq = rpcMallocCont(contLen);
+  tSerializeSCreateDbReq(pReq, contLen, &createReq);
 
   SRpcMsg rpcMsg = {0};
   rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SCreateDbReq);
+  rpcMsg.contLen = contLen;
   rpcMsg.msgType = TDMT_MND_CREATE_DB;
 
   SRpcMsg rpcRsp = {0};
@@ -210,7 +214,6 @@ void ctgTestBuildDBVgroup(SDBVgroupInfo **pdbVgroup) {
   *pdbVgroup = dbVgroup;
 }
 
-
 void ctgTestBuildSTableMetaRsp(STableMetaRsp *rspMsg) {
   strcpy(rspMsg->dbFName, ctgTestDbname);
   sprintf(rspMsg->tbName, "%s", ctgTestSTablename);
@@ -248,7 +251,6 @@ void ctgTestBuildSTableMetaRsp(STableMetaRsp *rspMsg) {
   return;
 }
 
-
 void ctgTestPrepareDbVgroups(void *shandle, SEpSet *pEpSet, SRpcMsg *pMsg, SRpcMsg *pRsp) {
   SUseDbRsp *rspMsg = NULL;  // todo
 
@@ -656,7 +658,6 @@ void *ctgTestSetSameDbVgroupThread(void *param) {
   return NULL;
 }
 
-
 void *ctgTestSetDiffDbVgroupThread(void *param) {
   struct SCatalog *pCtg = (struct SCatalog *)param;
   int32_t          code = 0;
@@ -681,7 +682,6 @@ void *ctgTestSetDiffDbVgroupThread(void *param) {
   return NULL;
 }
 
-
 void *ctgTestGetCtableMetaThread(void *param) {
   struct SCatalog *pCtg = (struct SCatalog *)param;
   int32_t          code = 0;
@@ -741,7 +741,6 @@ void *ctgTestSetCtableMetaThread(void *param) {
   return NULL;
 }
 
-
 TEST(tableMeta, normalTable) {
   struct SCatalog *pCtg = NULL;
   void            *mockPointer = (void *)0x1;
@@ -1150,8 +1149,6 @@ TEST(tableMeta, updateStbMeta) {
   catalogDestroy();
 }
 
-
-
 TEST(tableDistVgroup, normalTable) {
   struct SCatalog *pCtg = NULL;
   void            *mockPointer = (void *)0x1;
@@ -1418,8 +1415,6 @@ TEST(multiThread, getSetRmDiffDbVgroup) {
   catalogDestroy();
 }
 
-
-
 TEST(multiThread, ctableMeta) {
   struct SCatalog *pCtg = NULL;
   void            *mockPointer = (void *)0x1;
@@ -1470,8 +1465,6 @@ TEST(multiThread, ctableMeta) {
   catalogDestroy();
 }
 
-
-
 TEST(rentTest, allRent) {
   struct SCatalog *pCtg = NULL;
   void            *mockPointer = (void *)0x1;
@@ -1530,7 +1523,8 @@ TEST(rentTest, allRent) {
     printf("%d - expired stableNum:%d\n", i, num);
     if (stable) {
       for (int32_t n = 0; n < num; ++n) {
-        printf("suid:%" PRId64 ", dbFName:%s, stbName:%s, sversion:%d, tversion:%d\n", stable[n].suid, stable[n].dbFName, stable[n].stbName, stable[n].sversion, stable[n].tversion);
+        printf("suid:%" PRId64 ", dbFName:%s, stbName:%s, sversion:%d, tversion:%d\n", stable[n].suid,
+               stable[n].dbFName, stable[n].stbName, stable[n].sversion, stable[n].tversion);
       }
       free(stable);
       stable = NULL;

source/util/src/terror.c

@@ -77,7 +77,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_PTR,                  "Invalid pointer")
 TAOS_DEFINE_ERROR(TSDB_CODE_MEMORY_CORRUPTED,             "Memory corrupted")
 TAOS_DEFINE_ERROR(TSDB_CODE_FILE_CORRUPTED,               "Data file corrupted")
 TAOS_DEFINE_ERROR(TSDB_CODE_CHECKSUM_ERROR,               "Checksum error")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG,                  "Invalid config message")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG,                  "Invalid message")
 TAOS_DEFINE_ERROR(TSDB_CODE_MSG_NOT_PROCESSED,            "Message not processed")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_PARA,                 "Invalid parameters")
 TAOS_DEFINE_ERROR(TSDB_CODE_REPEAT_INIT,                  "Repeat initialization")