Merge pull request #14156 from taosdata/fix/dnode

feat: make config dnode work

include/common/tmsg.h

@@ -1346,11 +1346,19 @@ typedef struct {
   int32_t dnodeId;
   char    config[TSDB_DNODE_CONFIG_LEN];
   char    value[TSDB_DNODE_VALUE_LEN];
-} SMCfgDnodeReq, SDCfgDnodeReq;
+} SMCfgDnodeReq;
 
 int32_t tSerializeSMCfgDnodeReq(void* buf, int32_t bufLen, SMCfgDnodeReq* pReq);
 int32_t tDeserializeSMCfgDnodeReq(void* buf, int32_t bufLen, SMCfgDnodeReq* pReq);
 
+typedef struct {
+  char config[TSDB_DNODE_CONFIG_LEN];
+  char value[TSDB_DNODE_VALUE_LEN];
+} SDCfgDnodeReq;
+
+int32_t tSerializeSDCfgDnodeReq(void* buf, int32_t bufLen, SDCfgDnodeReq* pReq);
+int32_t tDeserializeSDCfgDnodeReq(void* buf, int32_t bufLen, SDCfgDnodeReq* pReq);
+
 typedef struct {
   int32_t dnodeId;
 } SMCreateMnodeReq, SMDropMnodeReq, SDDropMnodeReq, SMCreateQnodeReq, SMDropQnodeReq, SDCreateQnodeReq, SDDropQnodeReq,

source/common/src/tglobal.c

@@ -760,9 +760,9 @@ void taosCleanupCfg() {
 }
 
 void taosCfgDynamicOptions(const char *option, const char *value) {
-  if (strcasecmp(option, "debugFlag") == 0) {
-    int32_t debugFlag = atoi(value);
-    taosSetAllDebugFlag(debugFlag);
+  if (strncasecmp(option, "debugFlag", 9) == 0) {
+    int32_t flag = atoi(value);
+    taosSetAllDebugFlag(flag);
   }
 
   if (strcasecmp(option, "resetlog") == 0) {

source/common/src/tmsg.c

@@ -1500,6 +1500,33 @@ int32_t tDeserializeSMCfgDnodeReq(void *buf, int32_t bufLen, SMCfgDnodeReq *pReq
   return 0;
 }
 
+int32_t tSerializeSDCfgDnodeReq(void *buf, int32_t bufLen, SDCfgDnodeReq *pReq) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->config) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->value) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSDCfgDnodeReq(void *buf, int32_t bufLen, SDCfgDnodeReq *pReq) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->config) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->value) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tDecoderClear(&decoder);
+  return 0;
+}
+
 int32_t tSerializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *pReq) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);

source/dnode/mgmt/mgmt_dnode/src/dmHandle.c

@@ -123,8 +123,15 @@ int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
 }
 
 int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  dError("config req is received, but not supported yet");
-  return TSDB_CODE_OPS_NOT_SUPPORT;
+  SDCfgDnodeReq cfgReq = {0};
+  if (tDeserializeSDCfgDnodeReq(pMsg->pCont, pMsg->contLen, &cfgReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    return -1;
+  }
+
+  dInfo("start to config, option:%s, value:%s", cfgReq.config, cfgReq.value);
+  taosCfgDynamicOptions(cfgReq.config, cfgReq.value);
+  return 0;
 }
 
 static void dmGetServerRunStatus(SDnodeMgmt *pMgmt, SServerStatusRsp *pStatus) {

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

@@ -127,14 +127,24 @@ TdFilePtr dmCheckRunning(const char *dataDir) {
     return NULL;
   }
 
-  int32_t ret = taosLockFile(pFile);
-  if (ret != 0) {
+  int32_t retryTimes = 0;
+  int32_t ret = 0;
+  do {
+    ret = taosLockFile(pFile);
+    if (ret == 0) break;
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    taosMsleep(100);
+    retryTimes++;
+    dError("failed to lock file:%s since %s, retryTimes:%d", filepath, terrstr(), retryTimes);
+  } while (retryTimes < 120);
+
+  if (ret < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to lock file:%s since %s", filepath, terrstr());
     taosCloseFile(&pFile);
     return NULL;
   }
 
+  terrno = 0;
   dDebug("lock file:%s to prevent repeated starts", filepath);
   return pFile;
 }

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

@@ -502,20 +502,20 @@ _OVER:
 }
 
 static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) {
-  SMnode *pMnode = pReq->info.node;
-  SSdb   *pSdb = pMnode->pSdb;
-  SDnodeObj *pObj = NULL;
-  void *pIter = NULL;
+  SMnode       *pMnode = pReq->info.node;
+  SSdb         *pSdb = pMnode->pSdb;
+  SDnodeObj    *pObj = NULL;
+  void         *pIter = NULL;
   SDnodeListRsp rsp = {0};
-  int32_t code = -1;
-  
+  int32_t       code = -1;
+
   rsp.dnodeList = taosArrayInit(5, sizeof(SEpSet));
   if (NULL == rsp.dnodeList) {
     mError("failed to alloc epSet while process dnode list req");
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;
   }
-  
+
   while (1) {
     pIter = sdbFetch(pSdb, SDB_DNODE, pIter, (void **)&pObj);
     if (pIter == NULL) break;
@@ -554,7 +554,6 @@ _OVER:
   return code;
 }
 
-
 static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
   SMnode         *pMnode = pReq->info.node;
   int32_t         code = -1;
@@ -732,15 +731,37 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
     mError("dnode:%d, failed to config since %s ", cfgReq.dnodeId, terrstr());
     return -1;
   }
-
   SEpSet epSet = mndGetDnodeEpset(pDnode);
   mndReleaseDnode(pMnode, pDnode);
 
-  int32_t bufLen = tSerializeSMCfgDnodeReq(NULL, 0, &cfgReq);
+  SDCfgDnodeReq dcfgReq = {0};
+  if (strncasecmp(cfgReq.config, "debugFlag", 9) == 0) {
+    const char *value = cfgReq.value;
+    int32_t     flag = atoi(value);
+    if (flag <= 0) {
+      flag = atoi(cfgReq.config + 10);
+    }
+    if (flag <= 0 || flag > 255) {
+      mError("dnode:%d, failed to config debugFlag since value:%d", cfgReq.dnodeId, flag);
+      terrno = TSDB_CODE_INVALID_CFG;
+      return -1;
+    }
+
+    strcpy(dcfgReq.config, "debugFlag");
+    snprintf(dcfgReq.value, TSDB_DNODE_VALUE_LEN, "%d", flag);
+  } else if (strcasecmp(cfgReq.config, "resetlog") == 0) {
+    strcpy(dcfgReq.config, "resetlog");
+  } else {
+    terrno = TSDB_CODE_INVALID_CFG;
+    mError("dnode:%d, failed to config since %s", cfgReq.dnodeId, terrstr());
+    return -1;
+  }
+
+  int32_t bufLen = tSerializeSDCfgDnodeReq(NULL, 0, &dcfgReq);
   void   *pBuf = rpcMallocCont(bufLen);
 
   if (pBuf == NULL) return -1;
-  tSerializeSMCfgDnodeReq(pBuf, bufLen, &cfgReq);
+  tSerializeSDCfgDnodeReq(pBuf, bufLen, &dcfgReq);
 
   mDebug("dnode:%d, send config req to dnode, app:%p", cfgReq.dnodeId, pReq->info.ahandle);
   SRpcMsg rpcMsg = {.msgType = TDMT_DND_CONFIG_DNODE, .pCont = pBuf, .contLen = bufLen};

source/util/src/tlog.c

@@ -743,7 +743,7 @@ cmp_end:
 }
 
 void taosSetAllDebugFlag(int32_t flag) {
-  if (!(flag & DEBUG_TRACE || flag & DEBUG_DEBUG || flag & DEBUG_DUMP)) return;
+  if (flag <= 0) return;
 
   dDebugFlag = flag;
   vDebugFlag = flag;

tests/script/tsim/mnode/basic5.sim

@@ -233,7 +233,6 @@ if $data(1)[3] != dropping then
 endi
 
 print =============== step9: start mnode1 and wait it dropped
-sleep 3000
 system sh/exec.sh -n dnode1 -s start
 
 $x = 0