#4944

Committed 30 Jan 2026 06:19AM UTC coverage: 66.849% (+0.1%) from 66.718%

Build # #4944

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

merge: from main to 3.0 #34453

Run Details

1124 of 2018 new or added lines in 72 files covered. (55.7%)

13677 existing lines in 155 files now uncovered.

205211 of 306978 relevant lines covered (66.85%)

125657591.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.14

/source/dnode/mgmt/mgmt_mnode/src/mmInt.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 "mmInt.h"
#include "wal.h"

static bool mmDeployRequired(const SMgmtInputOpt *pInput) {
  if (pInput->pData->dnodeId > 0) return false;
  if (pInput->pData->clusterId > 0) return false;
  if (strcmp(tsLocalEp, tsFirst) != 0) return false;
  return true;
}

static int32_t mmRequire(const SMgmtInputOpt *pInput, bool *required) {
  int32_t   code = 0;
  SMnodeOpt option = {0};
  if ((code = mmReadFile(pInput->path, &option)) != 0) {
    return code;
  }

  if (!option.deploy) {
    *required = mmDeployRequired(pInput);
    if (*required) {
      dInfo("deploy mnode required. dnodeId:%d<=0, clusterId:0x%" PRIx64 "<=0, localEp:%s==firstEp",
            pInput->pData->dnodeId, pInput->pData->clusterId, tsLocalEp);
    }
  } else {
    *required = true;
    dInfo("deploy mnode required. option deploy:%d", option.deploy);
  }

  return code;
}

static void mmBuildOptionForDeploy(SMnodeMgmt *pMgmt, const SMgmtInputOpt *pInput, SMnodeOpt *pOption) {
  pOption->deploy = true;
  pOption->msgCb = pMgmt->msgCb;
  pOption->dnodeId = pMgmt->pData->dnodeId;
  pOption->selfIndex = 0;
  pOption->numOfReplicas = 1;
  pOption->numOfTotalReplicas = 1;
  pOption->replicas[0].id = 1;
  pOption->replicas[0].port = tsServerPort;
  tstrncpy(pOption->replicas[0].fqdn, tsLocalFqdn, TSDB_FQDN_LEN);
  pOption->lastIndex = SYNC_INDEX_INVALID;
}

static void mmBuildOptionForOpen(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
  pOption->deploy = false;
  pOption->msgCb = pMgmt->msgCb;
  pOption->dnodeId = pMgmt->pData->dnodeId;
}

static void mmClose(SMnodeMgmt *pMgmt) {
  if (pMgmt->pMnode != NULL) {
    mmStopWorker(pMgmt);
    mndClose(pMgmt->pMnode);
    (void)taosThreadRwlockDestroy(&pMgmt->lock);
    pMgmt->pMnode = NULL;
  }

  taosMemoryFree(pMgmt);
}
static int32_t mndOpenWrapper(const char *path, SMnodeOpt *opt, SMnode **pMnode) {
  int32_t code = 0;
  *pMnode = mndOpen(path, opt);
  if (*pMnode == NULL) {
    code = terrno;
  }
  ///*pMnode = pNode;
  return code;
}
static int32_t mmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
  int32_t code = 0;
  if ((code = walInit(pInput->stopDnodeFp)) != 0) {
    dError("failed to init wal since %s", tstrerror(code));
    return code;
  }

  if ((code = syncInit()) != 0) {
    dError("failed to init sync since %s", tstrerror(code));
    return code;
  }

  SMnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SMnodeMgmt));
  if (pMgmt == NULL) {
    code = terrno;
    return code;
  }

  pMgmt->pData = pInput->pData;
  pMgmt->path = pInput->path;
  pMgmt->name = pInput->name;
  pMgmt->msgCb = pInput->msgCb;
  pMgmt->msgCb.putToQueueFp = (PutToQueueFp)mmPutMsgToQueue;
  pMgmt->msgCb.mgmt = pMgmt;
  (void)taosThreadRwlockInit(&pMgmt->lock, NULL);

  SMnodeOpt option = {0};
  if ((code = mmReadFile(pMgmt->path, &option)) != 0) {
    dError("failed to read file since %s", tstrerror(code));
    mmClose(pMgmt);
    return code;
  }

  if (!option.deploy) {
    dInfo("mnode start to deploy");
    pMgmt->pData->dnodeId = 1;
    mmBuildOptionForDeploy(pMgmt, pInput, &option);
  } else {
    dInfo("mnode start to open");
    mmBuildOptionForOpen(pMgmt, &option);
  }

  dInfo("mnode open with options: deploy:%d, dnodeId:%d, selfIndex:%d, numOfReplicas:%d, numOfTotalReplicas:%d",
        option.deploy, option.dnodeId, option.selfIndex, option.numOfReplicas, option.numOfTotalReplicas);
  code = mndOpenWrapper(pMgmt->path, &option, &pMgmt->pMnode);
  if (code != 0) {
    dError("failed to open mnode since %s", tstrerror(code));
    mmClose(pMgmt);
    return code;
  }
  tmsgReportStartup("mnode-impl", "initialized");

  if ((code = mmStartWorker(pMgmt)) != 0) {
    dError("failed to start mnode worker since %s", tstrerror(code));
    mmClose(pMgmt);
    return code;
  }
  tmsgReportStartup("mnode-worker", "initialized");

  if (option.numOfTotalReplicas > 0) {
    option.deploy = true;
    option.numOfReplicas = 0;
    option.numOfTotalReplicas = 0;
    if ((code = mmWriteFile(pMgmt->path, &option)) != 0) {
      dError("failed to write mnode file since %s", tstrerror(code));
      return code;
    }
  }

  pInput->pData->dnodeId = pMgmt->pData->dnodeId;
  pOutput->pMgmt = pMgmt;
  return 0;
}

static int32_t mmStart(SMnodeMgmt *pMgmt) {
  int32_t code = 0;
  dDebug("mnode-mgmt start to run");
  SMnodeOpt option = {0};
  if ((code = mmReadFile(pMgmt->path, &option)) != 0) {
    dError("failed to read file since %s", tstrerror(code));
    mmClose(pMgmt);
    return code;
  }
  if ((code = mndStart(pMgmt->pMnode)) != 0) {
    return code;
  }
  if (mndNeedUpgrade(pMgmt->pMnode, option.version)) {
    option.version = mndGetVersion(pMgmt->pMnode);
    option.encrypted = mndGetEncryptedFlag(pMgmt->pMnode);
    if ((code = mmWriteFile(pMgmt->path, &option)) != 0) {
      dError("failed to write mnode file since %s", tstrerror(code));
      return code;
  }
  }
  return code;
}

static void mmStop(SMnodeMgmt *pMgmt) {
  dDebug("mnode-mgmt start to stop");
  mndPreClose(pMgmt->pMnode);
  (void)taosThreadRwlockWrlock(&pMgmt->lock);
  pMgmt->stopped = 1;
  (void)taosThreadRwlockUnlock(&pMgmt->lock);

  mndStop(pMgmt->pMnode);
}

static int32_t mmSyncIsCatchUp(SMnodeMgmt *pMgmt) { return mndIsCatchUp(pMgmt->pMnode); }

static ESyncRole mmSyncGetRole(SMnodeMgmt *pMgmt) { return mndGetRole(pMgmt->pMnode); }

SMgmtFunc mmGetMgmtFunc() {
  SMgmtFunc mgmtFunc = {0};
  mgmtFunc.openFp = mmOpen;
  mgmtFunc.closeFp = (NodeCloseFp)mmClose;
  mgmtFunc.startFp = (NodeStartFp)mmStart;
  mgmtFunc.stopFp = (NodeStopFp)mmStop;
  mgmtFunc.createFp = (NodeCreateFp)mmProcessCreateReq;
  mgmtFunc.dropFp = (NodeDropFp)mmProcessDropReq;
  mgmtFunc.requiredFp = mmRequire;
  mgmtFunc.getHandlesFp = mmGetMsgHandles;
  mgmtFunc.isCatchUpFp = (NodeIsCatchUpFp)mmSyncIsCatchUp;
  mgmtFunc.nodeRoleFp = (NodeRole)mmSyncGetRole;

  return mgmtFunc;
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http:www.gnu.org/licenses/>.
14	*/
15
16	#define _DEFAULT_SOURCE
17	#include "mmInt.h"
18	#include "wal.h"
19
20	static bool mmDeployRequired(const SMgmtInputOpt *pInput) {	493,518✔
21	if (pInput->pData->dnodeId > 0) return false;	493,518✔
22	if (pInput->pData->clusterId > 0) return false;	447,133✔
23	if (strcmp(tsLocalEp, tsFirst) != 0) return false;	447,133✔
24	return true;	296,014✔
25	}
26
27	static int32_t mmRequire(const SMgmtInputOpt pInput, bool required) {	583,106✔
28	int32_t code = 0;	583,106✔
29	SMnodeOpt option = {0};	583,106✔
30	if ((code = mmReadFile(pInput->path, &option)) != 0) {	583,106✔
31	return code;	×
32	}
33
34	if (!option.deploy) {	583,106✔
35	*required = mmDeployRequired(pInput);	493,518✔
36	if (*required) {	493,518✔
37	dInfo("deploy mnode required. dnodeId:%d<=0, clusterId:0x%" PRIx64 "<=0, localEp:%s==firstEp",	296,014✔
38	pInput->pData->dnodeId, pInput->pData->clusterId, tsLocalEp);
39	}
40	} else {
41	*required = true;	89,588✔
42	dInfo("deploy mnode required. option deploy:%d", option.deploy);	89,588✔
43	}
44
45	return code;	583,106✔
46	}
47
48	static void mmBuildOptionForDeploy(SMnodeMgmt pMgmt, const SMgmtInputOpt pInput, SMnodeOpt *pOption) {	296,000✔
49	pOption->deploy = true;	296,000✔
50	pOption->msgCb = pMgmt->msgCb;	296,000✔
51	pOption->dnodeId = pMgmt->pData->dnodeId;	296,000✔
52	pOption->selfIndex = 0;	296,000✔
53	pOption->numOfReplicas = 1;	296,000✔
54	pOption->numOfTotalReplicas = 1;	296,000✔
55	pOption->replicas[0].id = 1;	296,000✔
56	pOption->replicas[0].port = tsServerPort;	296,000✔
57	tstrncpy(pOption->replicas[0].fqdn, tsLocalFqdn, TSDB_FQDN_LEN);	296,000✔
58	pOption->lastIndex = SYNC_INDEX_INVALID;	296,000✔
59	}	296,000✔
60
61	static void mmBuildOptionForOpen(SMnodeMgmt pMgmt, SMnodeOpt pOption) {	120,796✔
62	pOption->deploy = false;	120,796✔
63	pOption->msgCb = pMgmt->msgCb;	120,796✔
64	pOption->dnodeId = pMgmt->pData->dnodeId;	120,796✔
65	}	120,796✔
66
67	static void mmClose(SMnodeMgmt *pMgmt) {	416,796✔
68	if (pMgmt->pMnode != NULL) {	416,796✔
69	mmStopWorker(pMgmt);	416,796✔
70	mndClose(pMgmt->pMnode);	416,796✔
71	(void)taosThreadRwlockDestroy(&pMgmt->lock);	416,796✔
72	pMgmt->pMnode = NULL;	416,796✔
73	}
74
75	taosMemoryFree(pMgmt);	416,796✔
76	}	416,796✔
77	static int32_t mndOpenWrapper(const char path, SMnodeOpt opt, SMnode **pMnode) {	416,796✔
78	int32_t code = 0;	416,796✔
79	*pMnode = mndOpen(path, opt);	416,796✔
80	if (*pMnode == NULL) {	416,796✔
81	code = terrno;	×
82	}
83	///*pMnode = pNode;
84	return code;	416,796✔
85	}
86	static int32_t mmOpen(SMgmtInputOpt pInput, SMgmtOutputOpt pOutput) {	416,796✔
87	int32_t code = 0;	416,796✔
88	if ((code = walInit(pInput->stopDnodeFp)) != 0) {	416,796✔
89	dError("failed to init wal since %s", tstrerror(code));	×
90	return code;	×
91	}
92
93	if ((code = syncInit()) != 0) {	416,796✔
94	dError("failed to init sync since %s", tstrerror(code));	×
95	return code;	×
96	}
97
98	SMnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SMnodeMgmt));	416,796✔
99	if (pMgmt == NULL) {	416,796✔
100	code = terrno;	×
101	return code;	×
102	}
103
104	pMgmt->pData = pInput->pData;	416,796✔
105	pMgmt->path = pInput->path;	416,796✔
106	pMgmt->name = pInput->name;	416,796✔
107	pMgmt->msgCb = pInput->msgCb;	416,796✔
108	pMgmt->msgCb.putToQueueFp = (PutToQueueFp)mmPutMsgToQueue;	416,796✔
109	pMgmt->msgCb.mgmt = pMgmt;	416,796✔
110	(void)taosThreadRwlockInit(&pMgmt->lock, NULL);	416,796✔
111
112	SMnodeOpt option = {0};	416,796✔
113	if ((code = mmReadFile(pMgmt->path, &option)) != 0) {	416,796✔
114	dError("failed to read file since %s", tstrerror(code));	×
115	mmClose(pMgmt);	×
116	return code;	×
117	}
118
119	if (!option.deploy) {	416,796✔
120	dInfo("mnode start to deploy");	296,000✔
121	pMgmt->pData->dnodeId = 1;	296,000✔
122	mmBuildOptionForDeploy(pMgmt, pInput, &option);	296,000✔
123	} else {
124	dInfo("mnode start to open");	120,796✔
125	mmBuildOptionForOpen(pMgmt, &option);	120,796✔
126	}
127
128	dInfo("mnode open with options: deploy:%d, dnodeId:%d, selfIndex:%d, numOfReplicas:%d, numOfTotalReplicas:%d",	416,796✔
129	option.deploy, option.dnodeId, option.selfIndex, option.numOfReplicas, option.numOfTotalReplicas);
130	code = mndOpenWrapper(pMgmt->path, &option, &pMgmt->pMnode);	416,796✔
131	if (code != 0) {	416,796✔
132	dError("failed to open mnode since %s", tstrerror(code));	×
133	mmClose(pMgmt);	×
134	return code;	×
135	}
136	tmsgReportStartup("mnode-impl", "initialized");	416,796✔
137
138	if ((code = mmStartWorker(pMgmt)) != 0) {	416,796✔
139	dError("failed to start mnode worker since %s", tstrerror(code));	×
140	mmClose(pMgmt);	×
141	return code;	×
142	}
143	tmsgReportStartup("mnode-worker", "initialized");	416,796✔
144
145	if (option.numOfTotalReplicas > 0) {	416,796✔
146	option.deploy = true;	327,236✔
147	option.numOfReplicas = 0;	327,236✔
148	option.numOfTotalReplicas = 0;	327,236✔
149	if ((code = mmWriteFile(pMgmt->path, &option)) != 0) {	327,236✔
150	dError("failed to write mnode file since %s", tstrerror(code));	×
151	return code;	×
152	}
153	}
154
155	pInput->pData->dnodeId = pMgmt->pData->dnodeId;	416,796✔
156	pOutput->pMgmt = pMgmt;	416,796✔
157	return 0;	416,796✔
158	}
159
160	static int32_t mmStart(SMnodeMgmt *pMgmt) {	416,796✔
161	int32_t code = 0;	416,796✔
162	dDebug("mnode-mgmt start to run");	416,796✔
163	SMnodeOpt option = {0};	416,796✔
164	if ((code = mmReadFile(pMgmt->path, &option)) != 0) {	416,796✔
165	dError("failed to read file since %s", tstrerror(code));	×
166	mmClose(pMgmt);	×
167	return code;	×
168	}
169	if ((code = mndStart(pMgmt->pMnode)) != 0) {	416,796✔
170	return code;	×
171	}
172	if (mndNeedUpgrade(pMgmt->pMnode, option.version)) {	416,796✔
173	option.version = mndGetVersion(pMgmt->pMnode);	327,236✔
174	option.encrypted = mndGetEncryptedFlag(pMgmt->pMnode);	327,236✔
175	if ((code = mmWriteFile(pMgmt->path, &option)) != 0) {	327,236✔
UNCOV 176	dError("failed to write mnode file since %s", tstrerror(code));	×
177	return code;	×
178	}
179	}
180	return code;	416,796✔
181	}
182
183	static void mmStop(SMnodeMgmt *pMgmt) {	416,796✔
184	dDebug("mnode-mgmt start to stop");	416,796✔
185	mndPreClose(pMgmt->pMnode);	416,796✔
186	(void)taosThreadRwlockWrlock(&pMgmt->lock);	416,796✔
187	pMgmt->stopped = 1;	416,796✔
188	(void)taosThreadRwlockUnlock(&pMgmt->lock);	416,796✔
189
190	mndStop(pMgmt->pMnode);	416,796✔
191	}	416,796✔
192
193	static int32_t mmSyncIsCatchUp(SMnodeMgmt *pMgmt) { return mndIsCatchUp(pMgmt->pMnode); }	195,577✔
194
195	static ESyncRole mmSyncGetRole(SMnodeMgmt *pMgmt) { return mndGetRole(pMgmt->pMnode); }	195,577✔
196
197	SMgmtFunc mmGetMgmtFunc() {	583,106✔
198	SMgmtFunc mgmtFunc = {0};	583,106✔
199	mgmtFunc.openFp = mmOpen;	583,106✔
200	mgmtFunc.closeFp = (NodeCloseFp)mmClose;	583,106✔
201	mgmtFunc.startFp = (NodeStartFp)mmStart;	583,106✔
202	mgmtFunc.stopFp = (NodeStopFp)mmStop;	583,106✔
203	mgmtFunc.createFp = (NodeCreateFp)mmProcessCreateReq;	583,106✔
204	mgmtFunc.dropFp = (NodeDropFp)mmProcessDropReq;	583,106✔
205	mgmtFunc.requiredFp = mmRequire;	583,106✔
206	mgmtFunc.getHandlesFp = mmGetMsgHandles;	583,106✔
207	mgmtFunc.isCatchUpFp = (NodeIsCatchUpFp)mmSyncIsCatchUp;	583,106✔
208	mgmtFunc.nodeRoleFp = (NodeRole)mmSyncGetRole;	583,106✔
209
210	return mgmtFunc;	583,106✔
211	}

taosdata / TDengine / #4944

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous