add qnode test

include/common/tmsg.h

@@ -869,15 +869,15 @@ typedef struct {
 
 typedef struct {
   int32_t dnodeId;
-} SMCreateQnodeMsg, SMCreateQnodeMsg, SDCreateQnodeMsg, SDDropQnodeMsg;
+} SMCreateQnodeMsg, SMDropQnodeMsg, SDCreateQnodeMsg, SDDropQnodeMsg;
 
 typedef struct {
   int32_t dnodeId;
-} SMCreateSnodeMsg, SMCreateSnodeMsg, SDCreateSnodeMsg, SDDropSnodeMsg;
+} SMCreateSnodeMsg, SMDropSnodeMsg, SDCreateSnodeMsg, SDDropSnodeMsg;
 
 typedef struct {
   int32_t dnodeId;
-} SMCreateBnodeMsg, SMCreateBnodeMsg, SDCreateBnodeMsg, SDDropBnodeMsg;
+} SMCreateBnodeMsg, SMDropBnodeMsg, SDCreateBnodeMsg, SDDropBnodeMsg;
 
 typedef struct {
   int32_t dnodeId;

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

@@ -15,9 +15,12 @@
 
 #define _DEFAULT_SOURCE
 #include "dndDnode.h"
+#include "dndBnode.h"
+#include "dndMnode.h"
+#include "dndQnode.h"
+#include "dndSnode.h"
 #include "dndTransport.h"
 #include "dndVnodes.h"
-#include "dndMnode.h"
 
 static int32_t dndInitMgmtWorker(SDnode *pDnode);
 static void    dndCleanupMgmtWorker(SDnode *pDnode);
@@ -648,6 +651,24 @@ static void dndProcessMgmtQueue(SDnode *pDnode, SRpcMsg *pMsg) {
     case TDMT_DND_DROP_MNODE:
       code = dndProcessDropMnodeReq(pDnode, pMsg);
       break;
+    case TDMT_DND_CREATE_QNODE:
+      code = dndProcessCreateQnodeReq(pDnode, pMsg);
+      break;
+    case TDMT_DND_DROP_QNODE:
+      code = dndProcessDropQnodeReq(pDnode, pMsg);
+      break;
+    case TDMT_DND_CREATE_SNODE:
+      code = dndProcessCreateSnodeReq(pDnode, pMsg);
+      break;
+    case TDMT_DND_DROP_SNODE:
+      code = dndProcessDropSnodeReq(pDnode, pMsg);
+      break;
+    case TDMT_DND_CREATE_BNODE:
+      code = dndProcessCreateBnodeReq(pDnode, pMsg);
+      break;
+    case TDMT_DND_DROP_BNODE:
+      code = dndProcessDropBnodeReq(pDnode, pMsg);
+      break;
     case TDMT_DND_CONFIG_DNODE:
       code = dndProcessConfigDnodeReq(pDnode, pMsg);
       break;

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

@@ -37,6 +37,18 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TMSG_INDEX(TDMT_DND_ALTER_MNODE_RSP)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_DND_DROP_MNODE)] = dndProcessMgmtMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_DND_DROP_MNODE_RSP)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_CREATE_QNODE)] = dndProcessMgmtMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_CREATE_QNODE_RSP)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_DROP_QNODE)] = dndProcessMgmtMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_DROP_QNODE_RSP)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_CREATE_SNODE)] = dndProcessMgmtMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_CREATE_SNODE_RSP)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_DROP_SNODE)] = dndProcessMgmtMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_DROP_SNODE_RSP)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_CREATE_BNODE)] = dndProcessMgmtMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_CREATE_BNODE_RSP)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_DROP_BNODE)] = dndProcessMgmtMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_DND_DROP_BNODE_RSP)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_DND_CREATE_VNODE)] = dndProcessMgmtMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_DND_CREATE_VNODE_RSP)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_DND_ALTER_VNODE)] = dndProcessMgmtMsg;
@@ -66,6 +78,12 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_DNODE)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_CREATE_MNODE)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_MNODE)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_CREATE_QNODE)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_QNODE)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_CREATE_SNODE)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_SNODE)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_CREATE_BNODE)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_BNODE)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_CREATE_DB)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_DB)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_USE_DB)] = dndProcessMnodeWriteMsg;

source/dnode/mgmt/impl/test/CMakeLists.txt

@@ -8,6 +8,9 @@ add_subdirectory(db)
 add_subdirectory(dnode)
 # add_subdirectory(func)
 add_subdirectory(mnode)
+add_subdirectory(qnode)
+#add_subdirectory(mnode)
+#add_subdirectory(mnode)
 add_subdirectory(profile)
 add_subdirectory(show)
 add_subdirectory(stb)

source/dnode/mgmt/impl/test/qnode/CMakeLists.txt

+aux_source_directory(. QTEST_SRC)
+add_executable(dnode_test_qnode ${QTEST_SRC})
+target_link_libraries(
+    dnode_test_qnode
+    PUBLIC sut
+)
+
+add_test(
+    NAME dnode_test_qnode
+    COMMAND dnode_test_qnode
+)

source/dnode/mgmt/impl/test/qnode/qnode.cpp

+/**
+ * @file dnode.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module dnode-msg tests
+ * @version 0.1
+ * @date 2021-12-15
+ *
+ * @copyright Copyright (c) 2021
+ *
+ */
+
+#include "base.h"
+
+class DndTestQnode : public ::testing::Test {
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+
+ public:
+  static void SetUpTestSuite() {
+    test.Init("/tmp/dnode_test_qnode1", 9071);
+    const char* fqdn = "localhost";
+    const char* firstEp = "localhost:9071";
+
+    server2.Start("/tmp/dnode_test_qnode2", fqdn, 9072, firstEp);
+    server3.Start("/tmp/dnode_test_qnode3", fqdn, 9073, firstEp);
+    server4.Start("/tmp/dnode_test_qnode4", fqdn, 9074, firstEp);
+    server5.Start("/tmp/dnode_test_qnode5", fqdn, 9075, firstEp);
+    taosMsleep(300);
+  }
+
+  static void TearDownTestSuite() {
+    server2.Stop();
+    server3.Stop();
+    server4.Stop();
+    server5.Stop();
+    test.Cleanup();
+  }
+
+  static Testbase   test;
+  static TestServer server2;
+  static TestServer server3;
+  static TestServer server4;
+  static TestServer server5;
+};
+
+Testbase   DndTestQnode::test;
+TestServer DndTestQnode::server2;
+TestServer DndTestQnode::server3;
+TestServer DndTestQnode::server4;
+TestServer DndTestQnode::server5;
+
+// TEST_F(DndTestQnode, 01_ShowQnode) {
+//   test.SendShowMetaMsg(TSDB_MGMT_TABLE_QNODE, "");
+//   CHECK_META("show qnodes", 3);
+
+//   CHECK_SCHEMA(0, TSDB_DATA_TYPE_SMALLINT, 2, "id");
+//   CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "endpoint");
+//   CHECK_SCHEMA(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+
+//   test.SendShowRetrieveMsg();
+//   EXPECT_EQ(test.GetShowRows(), 1);
+
+//   CheckInt16(1);
+//   CheckBinary("localhost:9071", TSDB_EP_LEN);
+//   CheckTimestamp();
+// }
+
+TEST_F(DndTestQnode, 02_Create_Qnode_Invalid_Id) {
+  {
+    int32_t contLen = sizeof(SMCreateQnodeMsg);
+
+    SMCreateQnodeMsg* pReq = (SMCreateQnodeMsg*)rpcMallocCont(contLen);
+    pReq->dnodeId = htonl(1);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_QNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+
+    test.SendShowMetaMsg(TSDB_MGMT_TABLE_QNODE, "");
+    CHECK_META("show qnodes", 3);
+
+    CHECK_SCHEMA(0, TSDB_DATA_TYPE_SMALLINT, 2, "id");
+    CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "endpoint");
+    CHECK_SCHEMA(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+
+    test.SendShowRetrieveMsg();
+    EXPECT_EQ(test.GetShowRows(), 1);
+
+    CheckInt16(1);
+    CheckBinary("localhost:9071", TSDB_EP_LEN);
+    CheckTimestamp();
+  }
+}
+
+// TEST_F(DndTestQnode, 03_Create_Qnode_Invalid_Id) {
+//   {
+//     int32_t contLen = sizeof(SMCreateQnodeMsg);
+
+//     SMCreateQnodeMsg* pReq = (SMCreateQnodeMsg*)rpcMallocCont(contLen);
+//     pReq->dnodeId = htonl(2);
+
+//     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_QNODE, pReq, contLen);
+//     ASSERT_NE(pMsg, nullptr);
+//     ASSERT_EQ(pMsg->code, TSDB_CODE_MND_DNODE_NOT_EXIST);
+//   }
+// }
+
+// TEST_F(DndTestQnode, 04_Create_Qnode) {
+//   {
+//     // create dnode
+//     int32_t contLen = sizeof(SCreateDnodeMsg);
+
+//     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
+//     strcpy(pReq->fqdn, "localhost");
+//     pReq->port = htonl(9072);
+
+//     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
+//     ASSERT_NE(pMsg, nullptr);
+//     ASSERT_EQ(pMsg->code, 0);
+
+//     taosMsleep(1300);
+//     test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "");
+//     test.SendShowRetrieveMsg();
+//     EXPECT_EQ(test.GetShowRows(), 2);
+//   }
+
+//   {
+//     // create qnode
+//     int32_t contLen = sizeof(SMCreateQnodeMsg);
+
+//     SMCreateQnodeMsg* pReq = (SMCreateQnodeMsg*)rpcMallocCont(contLen);
+//     pReq->dnodeId = htonl(2);
+
+//     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_QNODE, pReq, contLen);
+//     ASSERT_NE(pMsg, nullptr);
+//     ASSERT_EQ(pMsg->code, 0);
+
+//     test.SendShowMetaMsg(TSDB_MGMT_TABLE_QNODE, "");
+//     test.SendShowRetrieveMsg();
+//     EXPECT_EQ(test.GetShowRows(), 2);
+
+//     CheckInt16(1);
+//     CheckInt16(2);
+//     CheckBinary("localhost:9071", TSDB_EP_LEN);
+//     CheckBinary("localhost:9072", TSDB_EP_LEN);
+//     CheckTimestamp();
+//     CheckTimestamp();
+//   }
+
+//   {
+//     // drop qnode
+//     int32_t contLen = sizeof(SMDropQnodeMsg);
+
+//     SMDropQnodeMsg* pReq = (SMDropQnodeMsg*)rpcMallocCont(contLen);
+//     pReq->dnodeId = htonl(2);
+
+//     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_QNODE, pReq, contLen);
+//     ASSERT_NE(pMsg, nullptr);
+//     ASSERT_EQ(pMsg->code, 0);
+
+//     test.SendShowMetaMsg(TSDB_MGMT_TABLE_QNODE, "");
+//     test.SendShowRetrieveMsg();
+//     EXPECT_EQ(test.GetShowRows(), 1);
+
+//     CheckInt16(1);
+//     CheckBinary("localhost:9071", TSDB_EP_LEN);
+//     CheckTimestamp();
+//   }
+// }
\ No newline at end of file

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

@@ -324,8 +324,8 @@ DROP_BNODE_OVER:
 }
 
 static int32_t mndProcessDropBnodeReq(SMnodeMsg *pMsg) {
-  SMnode           *pMnode = pMsg->pMnode;
-  SMCreateBnodeMsg *pDrop = pMsg->rpcMsg.pCont;
+  SMnode         *pMnode = pMsg->pMnode;
+  SMDropBnodeMsg *pDrop = pMsg->rpcMsg.pCont;
   pDrop->dnodeId = htonl(pDrop->dnodeId);
 
   mDebug("snode:%d, start to drop", pDrop->dnodeId);

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

@@ -324,8 +324,8 @@ DROP_QNODE_OVER:
 }
 
 static int32_t mndProcessDropQnodeReq(SMnodeMsg *pMsg) {
-  SMnode           *pMnode = pMsg->pMnode;
-  SMCreateQnodeMsg *pDrop = pMsg->rpcMsg.pCont;
+  SMnode         *pMnode = pMsg->pMnode;
+  SMDropQnodeMsg *pDrop = pMsg->rpcMsg.pCont;
   pDrop->dnodeId = htonl(pDrop->dnodeId);
 
   mDebug("qnode:%d, start to drop", pDrop->dnodeId);

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

@@ -262,6 +262,12 @@ char *mndShowStr(int32_t showType) {
       return "show dnodes";
     case TSDB_MGMT_TABLE_MNODE:
       return "show mnodes";
+    case TSDB_MGMT_TABLE_QNODE:
+      return "show qnodes";
+    case TSDB_MGMT_TABLE_SNODE:
+      return "show snodes";
+    case TSDB_MGMT_TABLE_BNODE:
+      return "show bnodes";
     case TSDB_MGMT_TABLE_VGROUP:
       return "show vgroups";
     case TSDB_MGMT_TABLE_STB:

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

@@ -324,8 +324,8 @@ DROP_SNODE_OVER:
 }
 
 static int32_t mndProcessDropSnodeReq(SMnodeMsg *pMsg) {
-  SMnode           *pMnode = pMsg->pMnode;
-  SMCreateSnodeMsg *pDrop = pMsg->rpcMsg.pCont;
+  SMnode         *pMnode = pMsg->pMnode;
+  SMDropSnodeMsg *pDrop = pMsg->rpcMsg.pCont;
   pDrop->dnodeId = htonl(pDrop->dnodeId);
 
   mDebug("snode:%d, start to drop", pDrop->dnodeId);

source/dnode/qnode/src/qnode.c

@@ -24,12 +24,8 @@ void qndClose(SQnode *pQnode) { free(pQnode); }
 
 int32_t qndGetLoad(SQnode *pQnode, SQnodeLoad *pLoad) { return 0; }
 
-int32_t qndProcessQueryReq(SQnode *pQnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
+int32_t qndProcessMsg(SQnode *pQnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   *pRsp = NULL;
   return 0;
 }
 
-int32_t qndProcessFetchReq(SQnode *pQnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
-  *pRsp = NULL;
-  return 0;
-}

source/dnode/snode/src/snode.c

@@ -24,7 +24,7 @@ void sndClose(SSnode *pSnode) { free(pSnode); }
 
 int32_t sndGetLoad(SSnode *pSnode, SSnodeLoad *pLoad) { return 0; }
 
-int32_t sndProcessWriteMsg(SSnode *pSnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
+int32_t sndProcessMsg(SSnode *pSnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   *pRsp = NULL;
   return 0;
 }