#3558

Committed 17 Dec 2024 06:05AM UTC coverage: 59.778% (+1.6%) from 58.204%

Build # #3558

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #29179 from taosdata/merge/mainto3.0

merge: form main to 3.0 branch

Run Details

132787 of 287595 branches covered (46.17%)

Branch coverage included in aggregate %.

104 of 191 new or added lines in 5 files covered. (54.45%)

6085 existing lines in 168 files now uncovered.

209348 of 284746 relevant lines covered (73.52%)

8164844.48 hits per line

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

45.71

/source/libs/sync/src/syncIndexMgr.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 "syncIndexMgr.h"
#include "syncUtil.h"

SSyncIndexMgr *syncIndexMgrCreate(SSyncNode *pNode) {
  SSyncIndexMgr *pIndexMgr = taosMemoryCalloc(1, sizeof(SSyncIndexMgr));
  if (pIndexMgr == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }

  pIndexMgr->replicas = &pNode->replicasId;
  pIndexMgr->replicaNum = pNode->replicaNum;
  pIndexMgr->totalReplicaNum = pNode->totalReplicaNum;
  pIndexMgr->pNode = pNode;
  syncIndexMgrClear(pIndexMgr);

  return pIndexMgr;
}

void syncIndexMgrUpdate(SSyncIndexMgr *pIndexMgr, SSyncNode *pNode) {
  pIndexMgr->replicas = &pNode->replicasId;
  pIndexMgr->replicaNum = pNode->replicaNum;
  pIndexMgr->totalReplicaNum = pNode->totalReplicaNum;
  pIndexMgr->pNode = pNode;
  syncIndexMgrClear(pIndexMgr);
}

void syncIndexMgrDestroy(SSyncIndexMgr *pIndexMgr) {
  if (pIndexMgr != NULL) {
    taosMemoryFree(pIndexMgr);
  }
}

void syncIndexMgrClear(SSyncIndexMgr *pIndexMgr) {
  memset(pIndexMgr->index, 0, sizeof(pIndexMgr->index));
  memset(pIndexMgr->privateTerm, 0, sizeof(pIndexMgr->privateTerm));

  int64_t timeNow = taosGetTimestampMs();
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    pIndexMgr->startTimeArr[i] = 0;
    pIndexMgr->recvTimeArr[i] = timeNow;
  }
}

void syncIndexMgrSetIndex(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, SyncIndex index) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      (pIndexMgr->index)[i] = index;
      return;
    }
  }

  sError("vgId:%d, indexmgr set index:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, index,
         DID(pRaftId), CID(pRaftId));
}

void syncIndexMgrCopyIfExist(SSyncIndexMgr * pNewIndex, SSyncIndexMgr * pOldIndex, SRaftId *oldReplicasId){
  for(int j = 0; j < pOldIndex->totalReplicaNum; ++j){
    sDebug("old Index j:%d, index:%"PRId64, j, pOldIndex->index[j]);
  }
  
  for (int i = 0; i < pNewIndex->totalReplicaNum; ++i) {
    for(int j = 0; j < pOldIndex->totalReplicaNum; ++j){
      if (syncUtilSameId(/*(const SRaftId*)*/&((oldReplicasId[j])), &((*(pNewIndex->replicas))[i]))) {
        pNewIndex->index[i] = pOldIndex->index[j];
        pNewIndex->privateTerm[i] = pOldIndex->privateTerm[j];
        pNewIndex->startTimeArr[i] = pOldIndex->startTimeArr[j];
        pNewIndex->recvTimeArr[i] = pOldIndex->recvTimeArr[j];   
      }
    }
  }

  for (int i = 0; i < pNewIndex->totalReplicaNum; ++i){
    sDebug("new index i:%d, index:%"PRId64, i, pNewIndex->index[i]);
  }
}

SSyncLogReplMgr *syncNodeGetLogReplMgr(SSyncNode *pNode, SRaftId *pRaftId) {
  for (int i = 0; i < pNode->totalReplicaNum; i++) {
    if (syncUtilSameId(&pNode->replicasId[i], pRaftId)) {
      return pNode->logReplMgrs[i];
    }
  }

  terrno = TSDB_CODE_SYN_INVALID_ID;
  sError("vgId:%d, indexmgr get replmgr from dnode:%d cluster:%d failed", pNode->vgId, DID(pRaftId), CID(pRaftId));
  return NULL;
}

SyncIndex syncIndexMgrGetIndex(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      SyncIndex idx = (pIndexMgr->index)[i];
      return idx;
    }
  }

  terrno = TSDB_CODE_SYN_INVALID_ID;
  sError("vgId:%d, indexmgr get index from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),
         CID(pRaftId));
  return SYNC_INDEX_INVALID;
}

void syncIndexMgrSetStartTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, int64_t startTime) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      (pIndexMgr->startTimeArr)[i] = startTime;
      return;
    }
  }

  sError("vgId:%d, indexmgr set start-time:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId,
         startTime, DID(pRaftId), CID(pRaftId));
}

int64_t syncIndexMgrGetStartTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      int64_t startTime = (pIndexMgr->startTimeArr)[i];
      return startTime;
    }
  }

  sError("vgId:%d, indexmgr get start-time from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),
         CID(pRaftId));
  return TSDB_CODE_SYN_INVALID_ID;
  ;
}

void syncIndexMgrSetRecvTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, int64_t recvTime) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      (pIndexMgr->recvTimeArr)[i] = recvTime;
      return;
    }
  }

  sError("vgId:%d, indexmgr set recv-time:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, recvTime,
         DID(pRaftId), CID(pRaftId));
}

void syncIndexMgrSetSentTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, int64_t sentTime) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      (pIndexMgr->sentTimeArr)[i] = sentTime;
      return;
    }
  }

  sError("vgId:%d, indexmgr set sent-time:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, sentTime,
         DID(pRaftId), CID(pRaftId));
}

int64_t syncIndexMgrGetRecvTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      int64_t recvTime = (pIndexMgr->recvTimeArr)[i];
      return recvTime;
    }
  }

  sError("vgId:%d, indexmgr get recv-time from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),
         CID(pRaftId));
  return TSDB_CODE_SYN_INVALID_ID;
}

int64_t syncIndexMgrGetSentTime(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      int64_t recvTime = (pIndexMgr->sentTimeArr)[i];
      return recvTime;
    }
  }

  sError("vgId:%d, indexmgr get sent-time from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),
         CID(pRaftId));
  return TSDB_CODE_SYN_INVALID_ID;
}

void syncIndexMgrSetTerm(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId, SyncTerm term) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      (pIndexMgr->privateTerm)[i] = term;
      return;
    }
  }

  sError("vgId:%d, indexmgr set term:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, term,
         DID(pRaftId), CID(pRaftId));
}

SyncTerm syncIndexMgrGetTerm(SSyncIndexMgr *pIndexMgr, const SRaftId *pRaftId) {
  for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {
    if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {
      SyncTerm term = (pIndexMgr->privateTerm)[i];
      return term;
    }
  }

  sError("vgId:%d, indexmgr get term from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),
         CID(pRaftId));
  return TSDB_CODE_SYN_INVALID_ID;
}

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 "syncIndexMgr.h"
18	#include "syncUtil.h"
19
20	SSyncIndexMgr syncIndexMgrCreate(SSyncNode pNode) {	23,318✔
21	SSyncIndexMgr *pIndexMgr = taosMemoryCalloc(1, sizeof(SSyncIndexMgr));	23,318!
22	if (pIndexMgr == NULL) {	23,324!
23	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
24	return NULL;	×
25	}
26
27	pIndexMgr->replicas = &pNode->replicasId;	23,324✔
28	pIndexMgr->replicaNum = pNode->replicaNum;	23,324✔
29	pIndexMgr->totalReplicaNum = pNode->totalReplicaNum;	23,324✔
30	pIndexMgr->pNode = pNode;	23,324✔
31	syncIndexMgrClear(pIndexMgr);	23,324✔
32
33	return pIndexMgr;	23,324✔
34	}
35
36	void syncIndexMgrUpdate(SSyncIndexMgr pIndexMgr, SSyncNode pNode) {	446✔
37	pIndexMgr->replicas = &pNode->replicasId;	446✔
38	pIndexMgr->replicaNum = pNode->replicaNum;	446✔
39	pIndexMgr->totalReplicaNum = pNode->totalReplicaNum;	446✔
40	pIndexMgr->pNode = pNode;	446✔
41	syncIndexMgrClear(pIndexMgr);	446✔
42	}	446✔
43
44	void syncIndexMgrDestroy(SSyncIndexMgr *pIndexMgr) {	23,320✔
45	if (pIndexMgr != NULL) {	23,320!
46	taosMemoryFree(pIndexMgr);	23,320!
47	}
48	}	23,319✔
49
50	void syncIndexMgrClear(SSyncIndexMgr *pIndexMgr) {	23,770✔
51	memset(pIndexMgr->index, 0, sizeof(pIndexMgr->index));	23,770✔
52	memset(pIndexMgr->privateTerm, 0, sizeof(pIndexMgr->privateTerm));	23,770✔
53
54	int64_t timeNow = taosGetTimestampMs();	23,770✔
55	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	59,252✔
56	pIndexMgr->startTimeArr[i] = 0;	35,482✔
57	pIndexMgr->recvTimeArr[i] = timeNow;	35,482✔
58	}
59	}	23,770✔
60
61	void syncIndexMgrSetIndex(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId, SyncIndex index) {	15,023,766✔
62	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	20,508,646!
63	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	20,508,834✔
64	(pIndexMgr->index)[i] = index;	15,024,075✔
65	return;	15,024,075✔
66	}
67	}
68
69	sError("vgId:%d, indexmgr set index:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, index,	×
70	DID(pRaftId), CID(pRaftId));
71	}
72
73	void syncIndexMgrCopyIfExist(SSyncIndexMgr * pNewIndex, SSyncIndexMgr * pOldIndex, SRaftId *oldReplicasId){	×
74	for(int j = 0; j < pOldIndex->totalReplicaNum; ++j){	×
75	sDebug("old Index j:%d, index:%"PRId64, j, pOldIndex->index[j]);	×
76	}
77
78	for (int i = 0; i < pNewIndex->totalReplicaNum; ++i) {	×
79	for(int j = 0; j < pOldIndex->totalReplicaNum; ++j){	×
80	if (syncUtilSameId(/(const SRaftId)/&((oldReplicasId[j])), &(((pNewIndex->replicas))[i]))) {	×
81	pNewIndex->index[i] = pOldIndex->index[j];	×
82	pNewIndex->privateTerm[i] = pOldIndex->privateTerm[j];	×
83	pNewIndex->startTimeArr[i] = pOldIndex->startTimeArr[j];	×
84	pNewIndex->recvTimeArr[i] = pOldIndex->recvTimeArr[j];	×
85	}
86	}
87	}
88
89	for (int i = 0; i < pNewIndex->totalReplicaNum; ++i){	×
90	sDebug("new index i:%d, index:%"PRId64, i, pNewIndex->index[i]);	×
91	}
92	}	×
93
94	SSyncLogReplMgr syncNodeGetLogReplMgr(SSyncNode pNode, SRaftId *pRaftId) {	5,730,000✔
95	for (int i = 0; i < pNode->totalReplicaNum; i++) {	11,540,409✔
96	if (syncUtilSameId(&pNode->replicasId[i], pRaftId)) {	11,540,404✔
97	return pNode->logReplMgrs[i];	5,729,991✔
98	}
99	}
100
101	terrno = TSDB_CODE_SYN_INVALID_ID;	5✔
102	sError("vgId:%d, indexmgr get replmgr from dnode:%d cluster:%d failed", pNode->vgId, DID(pRaftId), CID(pRaftId));	2!
103	return NULL;	2✔
104	}
105
106	SyncIndex syncIndexMgrGetIndex(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId) {	2,724,154✔
107	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	5,486,240!
108	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	5,486,240✔
109	SyncIndex idx = (pIndexMgr->index)[i];	2,724,154✔
110	return idx;	2,724,154✔
111	}
112	}
113
114	terrno = TSDB_CODE_SYN_INVALID_ID;	×
115	sError("vgId:%d, indexmgr get index from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),	×
116	CID(pRaftId));
117	return SYNC_INDEX_INVALID;	×
118	}
119
120	void syncIndexMgrSetStartTime(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId, int64_t startTime) {	×
121	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	×
122	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	×
123	(pIndexMgr->startTimeArr)[i] = startTime;	×
124	return;	×
125	}
126	}
127
128	sError("vgId:%d, indexmgr set start-time:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId,	×
129	startTime, DID(pRaftId), CID(pRaftId));
130	}
131
132	int64_t syncIndexMgrGetStartTime(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId) {	×
133	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	×
134	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	×
135	int64_t startTime = (pIndexMgr->startTimeArr)[i];	×
136	return startTime;	×
137	}
138	}
139
140	sError("vgId:%d, indexmgr get start-time from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),	×
141	CID(pRaftId));
142	return TSDB_CODE_SYN_INVALID_ID;	×
143	;
144	}
145
146	void syncIndexMgrSetRecvTime(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId, int64_t recvTime) {	61,159✔
147	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	118,048!
148	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	118,048✔
149	(pIndexMgr->recvTimeArr)[i] = recvTime;	61,159✔
150	return;	61,159✔
151	}
152	}
153
154	sError("vgId:%d, indexmgr set recv-time:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, recvTime,	×
155	DID(pRaftId), CID(pRaftId));
156	}
157
158	void syncIndexMgrSetSentTime(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId, int64_t sentTime) {	33,420✔
159	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	70,521!
160	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	70,521✔
161	(pIndexMgr->sentTimeArr)[i] = sentTime;	33,420✔
162	return;	33,420✔
163	}
164	}
165
166	sError("vgId:%d, indexmgr set sent-time:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, sentTime,	×
167	DID(pRaftId), CID(pRaftId));
168	}
169
170	int64_t syncIndexMgrGetRecvTime(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId) {	695,520✔
171	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	1,123,049!
172	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	1,123,059✔
173	int64_t recvTime = (pIndexMgr->recvTimeArr)[i];	695,524✔
174	return recvTime;	695,524✔
175	}
176	}
177
178	sError("vgId:%d, indexmgr get recv-time from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),	×
179	CID(pRaftId));
180	return TSDB_CODE_SYN_INVALID_ID;	×
181	}
182
183	int64_t syncIndexMgrGetSentTime(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId) {	208,690✔
184	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	280,732!
185	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	280,734✔
186	int64_t recvTime = (pIndexMgr->sentTimeArr)[i];	208,693✔
187	return recvTime;	208,693✔
188	}
189	}
190
UNCOV 191	sError("vgId:%d, indexmgr get sent-time from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),	×
192	CID(pRaftId));
193	return TSDB_CODE_SYN_INVALID_ID;	×
194	}
195
196	void syncIndexMgrSetTerm(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId, SyncTerm term) {	×
197	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	×
198	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	×
199	(pIndexMgr->privateTerm)[i] = term;	×
200	return;	×
201	}
202	}
203
204	sError("vgId:%d, indexmgr set term:%" PRId64 " for dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, term,	×
205	DID(pRaftId), CID(pRaftId));
206	}
207
208	SyncTerm syncIndexMgrGetTerm(SSyncIndexMgr pIndexMgr, const SRaftId pRaftId) {	×
209	for (int i = 0; i < pIndexMgr->totalReplicaNum; ++i) {	×
210	if (syncUtilSameId(&((*(pIndexMgr->replicas))[i]), pRaftId)) {	×
211	SyncTerm term = (pIndexMgr->privateTerm)[i];	×
212	return term;	×
213	}
214	}
215
216	sError("vgId:%d, indexmgr get term from dnode:%d cluster:%d failed", pIndexMgr->pNode->vgId, DID(pRaftId),	×
217	CID(pRaftId));
218	return TSDB_CODE_SYN_INVALID_ID;	×
219	}

taosdata / TDengine / #3558

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