refactror: node mgmt

source/dnode/mgmt/exe/dmMain.c

@@ -163,14 +163,14 @@ static SDnodeOpt dmGetOpt() {
 
 static int32_t dmInitLog() {
   char logName[12] = {0};
-  snprintf(logName, sizeof(logName), "%slog", dmLogName(global.ntype));
+  snprintf(logName, sizeof(logName), "%slog", dmNodeLogName(global.ntype));
   return taosCreateLog(logName, 1, configDir, global.envCmd, global.envFile, global.apolloUrl, global.pArgs, 0);
 }
 
 static void dmSetProcInfo(int32_t argc, char **argv) {
   taosSetProcPath(argc, argv);
   if (global.ntype != DNODE && global.ntype != NODE_END) {
-    const char *name = dmProcName(global.ntype);
+    const char *name = dmNodeProcName(global.ntype);
     taosSetProcName(argc, argv, name);
   }
 }

source/dnode/mgmt/node_common/inc/dmDef.h

@@ -111,7 +111,7 @@ typedef struct SMgmtWrapper {
     char        *path;
     int32_t      refCount;
     SRWLatch     latch;
-    EDndNodeType ntype;
+    EDndNodeType nodeType;
     bool         deployed;
     bool         required;
     SMgmtFp      fp;

source/dnode/mgmt/node_common/inc/dmInt.h

@@ -26,12 +26,13 @@ extern "C" {
 SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType nType);
 int32_t       dmMarkWrapper(SMgmtWrapper *pWrapper);
 void          dmReleaseWrapper(SMgmtWrapper *pWrapper);
-const char   *dmStatName(EDndRunStatus stat);
-const char   *dmLogName(EDndNodeType ntype);
-const char   *dmProcName(EDndNodeType ntype);
-const char   *dmEventName(EDndEvent ev);
+const char   *dmStatStr(EDndRunStatus stype);
+const char   *dmNodeLogName(EDndNodeType ntype);
+const char   *dmNodeProcName(EDndNodeType ntype);
+const char   *dmEventStr(EDndEvent etype);
+const char   *dmProcStr(EDndProcType ptype);
 
-void   dmSetStatus(SDnode *pDnode, EDndRunStatus stat);
+void   dmSetStatus(SDnode *pDnode, EDndRunStatus stype);
 void   dmSetEvent(SDnode *pDnode, EDndEvent event);
 void   dmSetMsgHandle(SMgmtWrapper *pWrapper, tmsg_t msgType, NodeMsgFp nodeMsgFp, int8_t vgId);
 void   dmReportStartup(SDnode *pDnode, const char *pName, const char *pDesc);

source/dnode/mgmt/node_common/src/dmFile.c

@@ -173,7 +173,7 @@ int32_t dmReadShmFile(SMgmtWrapper *pWrapper) {
     }
   }
 
-  if (!tsMultiProcess || pWrapper->pDnode->ntype == DNODE || pWrapper->pDnode->ntype == NODE_END) {
+  if (!tsMultiProcess || pWrapper->nodeType == DNODE || pWrapper->nodeType == NODE_END) {
     if (pWrapper->procShm.id >= 0) {
       dDebug("node:%s, shmid:%d, is closed, size:%d", pWrapper->name, pWrapper->procShm.id, pWrapper->procShm.size);
       taosDropShm(&pWrapper->procShm);

source/dnode/mgmt/node_common/src/dmStr.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 "dmInt.h"
+
+const char *dmStatStr(EDndRunStatus stype) {
+  switch (stype) {
+    case DND_STAT_INIT:
+      return "init";
+    case DND_STAT_RUNNING:
+      return "running";
+    case DND_STAT_STOPPED:
+      return "stopped";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+const char *dmNodeLogName(EDndNodeType ntype) {
+  switch (ntype) {
+    case VNODE:
+      return "vnode";
+    case QNODE:
+      return "qnode";
+    case SNODE:
+      return "snode";
+    case MNODE:
+      return "mnode";
+    case BNODE:
+      return "bnode";
+    default:
+      return "taosd";
+  }
+}
+
+const char *dmNodeProcName(EDndNodeType ntype) {
+  switch (ntype) {
+    case VNODE:
+      return "taosv";
+    case QNODE:
+      return "taosq";
+    case SNODE:
+      return "taoss";
+    case MNODE:
+      return "taosm";
+    case BNODE:
+      return "taosb";
+    default:
+      return "taosd";
+  }
+}
+
+const char *dmEventStr(EDndEvent ev) {
+  switch (ev) {
+    case DND_EVENT_START:
+      return "start";
+    case DND_EVENT_STOP:
+      return "stop";
+    case DND_EVENT_CHILD:
+      return "child";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+const char *dmProcStr(EDndProcType etype) {
+  switch (etype) {
+    case DND_PROC_SINGLE:
+      return "start";
+    case DND_PROC_CHILD:
+      return "stop";
+    case DND_PROC_PARENT:
+      return "child";
+    case DND_PROC_TEST:
+      return "test";
+    default:
+      return "UNKNOWN";
+  }
+}

source/dnode/mgmt/node_common/src/dmInt.c → source/dnode/mgmt/node_common/src/dmUtil.c

@@ -16,69 +16,9 @@
 #define _DEFAULT_SOURCE
 #include "dmInt.h"
 
-const char *dmStatName(EDndRunStatus status) {
-  switch (status) {
-    case DND_STAT_INIT:
-      return "init";
-    case DND_STAT_RUNNING:
-      return "running";
-    case DND_STAT_STOPPED:
-      return "stopped";
-    default:
-      return "UNKNOWN";
-  }
-}
-
-const char *dmLogName(EDndNodeType ntype) {
-  switch (ntype) {
-    case VNODE:
-      return "vnode";
-    case QNODE:
-      return "qnode";
-    case SNODE:
-      return "snode";
-    case MNODE:
-      return "mnode";
-    case BNODE:
-      return "bnode";
-    default:
-      return "taosd";
-  }
-}
-
-const char *dmProcName(EDndNodeType ntype) {
-  switch (ntype) {
-    case VNODE:
-      return "taosv";
-    case QNODE:
-      return "taosq";
-    case SNODE:
-      return "taoss";
-    case MNODE:
-      return "taosm";
-    case BNODE:
-      return "taosb";
-    default:
-      return "taosd";
-  }
-}
-
-const char *dmEventName(EDndEvent ev) {
-  switch (ev) {
-    case DND_EVENT_START:
-      return "start";
-    case DND_EVENT_STOP:
-      return "stop";
-    case DND_EVENT_CHILD:
-      return "child";
-    default:
-      return "UNKNOWN";
-  }
-}
-
 void dmSetStatus(SDnode *pDnode, EDndRunStatus status) {
   if (pDnode->status != status) {
-    dDebug("dnode status set from %s to %s", dmStatName(pDnode->status), dmStatName(status));
+    dDebug("dnode status set from %s to %s", dmStatStr(pDnode->status), dmStatStr(status));
     pDnode->status = status;
   }
 }

source/dnode/mgmt/node_mgmt/src/dmExec.c

@@ -27,21 +27,21 @@ static bool dmRequireNode(SMgmtWrapper *pWrapper) {
 
 static int32_t dmInitParentProc(SMgmtWrapper *pWrapper) {
   int32_t shmsize = tsMnodeShmSize;
-  if (pWrapper->ntype == VNODE) {
+  if (pWrapper->nodeType == VNODE) {
     shmsize = tsVnodeShmSize;
-  } else if (pWrapper->ntype == QNODE) {
+  } else if (pWrapper->nodeType == QNODE) {
     shmsize = tsQnodeShmSize;
-  } else if (pWrapper->ntype == SNODE) {
+  } else if (pWrapper->nodeType == SNODE) {
     shmsize = tsSnodeShmSize;
-  } else if (pWrapper->ntype == MNODE) {
+  } else if (pWrapper->nodeType == MNODE) {
     shmsize = tsMnodeShmSize;
-  } else if (pWrapper->ntype == BNODE) {
+  } else if (pWrapper->nodeType == BNODE) {
     shmsize = tsBnodeShmSize;
   } else {
     return -1;
   }
 
-  if (taosCreateShm(&pWrapper->procShm, pWrapper->ntype, shmsize) != 0) {
+  if (taosCreateShm(&pWrapper->procShm, pWrapper->nodeType, shmsize) != 0) {
     terrno = TAOS_SYSTEM_ERROR(terrno);
     dError("node:%s, failed to create shm size:%d since %s", pWrapper->name, shmsize, terrstr());
     return -1;
@@ -86,7 +86,7 @@ static int32_t dmRunParentProc(SMgmtWrapper *pWrapper) {
   if (pWrapper->pDnode->ntype == NODE_END) {
     dInfo("node:%s, should be started manually in child process", pWrapper->name);
   } else {
-    if (dmNewNodeProc(pWrapper, pWrapper->ntype) != 0) {
+    if (dmNewNodeProc(pWrapper, pWrapper->nodeType) != 0) {
       return -1;
     }
   }
@@ -149,7 +149,7 @@ int32_t dmStartNode(SMgmtWrapper *pWrapper) {
     dInfo("node:%s, not start in parent process", pWrapper->name);
   } else if (pWrapper->procType == DND_PROC_CHILD) {
     dInfo("node:%s, start in child process", pWrapper->name);
-    if (pWrapper->ntype != DNODE) {
+    if (pWrapper->nodeType != DNODE) {
       if (pWrapper->fp.startFp != NULL && (*pWrapper->fp.startFp)(pWrapper) != 0) {
         dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
         return -1;

source/dnode/mgmt/node_mgmt/src/dmObj.c

@@ -104,7 +104,7 @@ SDnode *dmCreate(const SDnodeOpt *pOption) {
     pWrapper->path = strdup(path);
     pWrapper->procShm.id = -1;
     pWrapper->pDnode = pDnode;
-    pWrapper->ntype = n;
+    pWrapper->nodeType = n;
     pWrapper->procType = DND_PROC_SINGLE;
     taosInitRWLatch(&pWrapper->latch);