#4271

Committed 10 Jun 2025 09:45AM UTC coverage: 62.985% (+0.002%) from 62.983%

Build # #4271

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #31337 from taosdata/newtest_3.0

fix TD-35057 and TD-35346

Run Details

158179 of 319671 branches covered (49.48%)

Branch coverage included in aggregate %.

243860 of 318637 relevant lines covered (76.53%)

18624660.26 hits per line

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

56.58

/source/common/src/tmisce.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 "tdatablock.h"
#include "tglobal.h"
#include "tjson.h"
#include "tmisce.h"
#include "tcompare.h"

int32_t taosGetIpv4FromEp(const char* ep, SEp* pEp) {
  pEp->port = 0;
  memset(pEp->fqdn, 0, TSDB_FQDN_LEN);
  tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);

  char* temp = strrchr(pEp->fqdn, ':');
  if (temp) {
    *temp = 0;
    pEp->port = taosStr2UInt16(temp + 1, NULL, 10);
    if (pEp->port < 0) {
      return TSDB_CODE_INVALID_PARA;
    }
  }

  if (pEp->port == 0) {
    pEp->port = tsServerPort;
  }

  if (pEp->port <= 0) {
    return TSDB_CODE_INVALID_PARA;
  }
  return 0;
}

int32_t taosGetDualIpFromEp(const char* ep, SEp* pEp) {
  int32_t code = 0;
  memset(pEp->fqdn, 0, TSDB_FQDN_LEN);

  strncpy(pEp->fqdn, ep, TSDB_FQDN_LEN - 1);

  char* temp = strrchr(pEp->fqdn, ':');
  if (temp) {
    char* ipv6Check = strchr(pEp->fqdn, ':');
    if (ipv6Check != temp) {
      pEp->port = tsServerPort;
    } else {
      *temp = 0;
      pEp->port = taosStr2UInt16(temp + 1, NULL, 10);
      if (pEp->port == 0) {
        return TSDB_CODE_INVALID_PARA;
      }
    }
  } else {
    pEp->port = tsServerPort;
  }
  return code;
}
int32_t taosGetFqdnPortFromEp(const char* ep, SEp* pEp) {
  if (tsEnableIpv6) {
    return taosGetDualIpFromEp(ep, pEp);
  } else {
    return taosGetIpv4FromEp(ep, pEp);
  }
}

int32_t addEpIntoEpSet(SEpSet* pEpSet, const char* fqdn, uint16_t port) {
  if (pEpSet == NULL || fqdn == NULL || strlen(fqdn) == 0) {
    return TSDB_CODE_INVALID_PARA;
  }

  int32_t index = pEpSet->numOfEps;
  if (index >= sizeof(pEpSet->eps) / sizeof(pEpSet->eps[0])) {
    return TSDB_CODE_OUT_OF_RANGE;
  }
  tstrncpy(pEpSet->eps[index].fqdn, fqdn, tListLen(pEpSet->eps[index].fqdn));
  pEpSet->eps[index].port = port;
  pEpSet->numOfEps += 1;
  return 0;
}

bool isEpsetEqual(const SEpSet* s1, const SEpSet* s2) {
  if (s1->numOfEps != s2->numOfEps || s1->inUse != s2->inUse) {
    return false;
  }

  for (int32_t i = 0; i < s1->numOfEps; i++) {
    if (s1->eps[i].port != s2->eps[i].port || strncmp(s1->eps[i].fqdn, s2->eps[i].fqdn, TSDB_FQDN_LEN) != 0)
      return false;
  }
  return true;
}

void epsetAssign(SEpSet* pDst, const SEpSet* pSrc) {
  if (pSrc == NULL || pDst == NULL) {
    return;
  }

  pDst->inUse = pSrc->inUse;
  pDst->numOfEps = pSrc->numOfEps;
  for (int32_t i = 0; i < pSrc->numOfEps; ++i) {
    pDst->eps[i].port = pSrc->eps[i].port;
    tstrncpy(pDst->eps[i].fqdn, pSrc->eps[i].fqdn, tListLen(pSrc->eps[i].fqdn));
  }
}

void epAssign(SEp* pDst, SEp* pSrc) {
  if (pSrc == NULL || pDst == NULL) {
    return;
  }
  memset(pDst->fqdn, 0, tListLen(pSrc->fqdn));
  tstrncpy(pDst->fqdn, pSrc->fqdn, tListLen(pSrc->fqdn));
  pDst->port = pSrc->port;
}

void epsetSort(SEpSet* pDst) {
  if (pDst->numOfEps <= 1) {
    return;
  }
  int validIdx = false;
  SEp ep = {0};
  if (pDst->inUse >= 0 && pDst->inUse < pDst->numOfEps) {
    validIdx = true;
    epAssign(&ep, &pDst->eps[pDst->inUse]);
  }

  for (int i = 0; i < pDst->numOfEps - 1; i++) {
    for (int j = 0; j < pDst->numOfEps - 1 - i; j++) {
      SEp* f = &pDst->eps[j];
      SEp* s = &pDst->eps[j + 1];
      int  cmp = strncmp(f->fqdn, s->fqdn, sizeof(f->fqdn));
      if (cmp > 0 || (cmp == 0 && f->port > s->port)) {
        SEp ep1 = {0};
        epAssign(&ep1, f);
        epAssign(f, s);
        epAssign(s, &ep1);
      }
    }
  }
  if (validIdx == true)
    for (int i = 0; i < pDst->numOfEps; i++) {
      int cmp = strncmp(ep.fqdn, pDst->eps[i].fqdn, sizeof(ep.fqdn));
      if (cmp == 0 && ep.port == pDst->eps[i].port) {
        pDst->inUse = i;
        break;
      }
    }
}

void updateEpSet_s(SCorEpSet* pEpSet, SEpSet* pNewEpSet) {
  taosCorBeginWrite(&pEpSet->version);
  pEpSet->epSet = *pNewEpSet;
  taosCorEndWrite(&pEpSet->version);
}

SEpSet getEpSet_s(SCorEpSet* pEpSet) {
  SEpSet ep = {0};
  taosCorBeginRead(&pEpSet->version);
  ep = pEpSet->epSet;
  taosCorEndRead(&pEpSet->version);

  return ep;
}

int32_t epsetToStr(const SEpSet* pEpSet, char* pBuf, int32_t cap) {
  int32_t ret = 0;
  int32_t nwrite = 0;

  nwrite = snprintf(pBuf + nwrite, cap, "epset:{");
  if (nwrite <= 0 || nwrite >= cap) {
    return TSDB_CODE_OUT_OF_BUFFER;
  }
  cap -= nwrite;

  for (int _i = 0; (_i < pEpSet->numOfEps) && (cap > 0); _i++) {
    if (_i == pEpSet->numOfEps - 1) {
      ret = snprintf(pBuf + nwrite, cap, "%d. %s:%d", _i, pEpSet->eps[_i].fqdn, pEpSet->eps[_i].port);
    } else {
      ret = snprintf(pBuf + nwrite, cap, "%d. %s:%d, ", _i, pEpSet->eps[_i].fqdn, pEpSet->eps[_i].port);
    }

    if (ret <= 0 || ret >= cap) {
      return TSDB_CODE_OUT_OF_BUFFER;
    }

    nwrite += ret;
    cap -= ret;
  }

  if (cap <= 0) {
    return TSDB_CODE_OUT_OF_BUFFER;
  }

  ret = snprintf(pBuf + nwrite, cap, "}, inUse:%d", pEpSet->inUse);
  if (ret <= 0 || ret >= cap) {
    return TSDB_CODE_OUT_OF_BUFFER;
  } else {
    return TSDB_CODE_SUCCESS;
  }
}

int32_t taosGenCrashJsonMsg(int signum, char** pMsg, int64_t clusterId, int64_t startTime) {
  int32_t code = 0;
  SJson*  pJson = tjsonCreateObject();
  if (pJson == NULL) return terrno;

  char tmp[4096] = {0};

  TAOS_CHECK_GOTO(tjsonAddDoubleToObject(pJson, "reportVersion", 1), NULL, _exit);

  TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "clusterId", clusterId), NULL, _exit);
  TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "startTime", startTime), NULL, _exit);

  // Do NOT invoke the taosGetFqdn here.
  // this function may be invoked when memory exception occurs,so we should assume that it is running in a memory locked
  // environment. The lock operation by taosGetFqdn may cause this program deadlock.
  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "fqdn", tsLocalFqdn), NULL, _exit);

  TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "pid", taosGetPId()), NULL, _exit);

  code = taosGetAppName(tmp, NULL);
  if (code != 0) {
    TAOS_CHECK_GOTO(code, NULL, _exit);
  }
  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "appName", tmp), NULL, _exit);

  if (taosGetOsReleaseName(tmp, NULL, NULL, sizeof(tmp)) == 0) {
    TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "os", tmp), NULL, _exit);
  } else {
    // do nothing
  }

  float numOfCores = 0;
  if (taosGetCpuInfo(tmp, sizeof(tmp), &numOfCores) == 0) {
    TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "cpuModel", tmp), NULL, _exit);
    TAOS_CHECK_GOTO(tjsonAddDoubleToObject(pJson, "numOfCpu", numOfCores), NULL, _exit);
  } else {
    TAOS_CHECK_GOTO(tjsonAddDoubleToObject(pJson, "numOfCpu", tsNumOfCores), NULL, _exit);
  }

  int32_t nBytes = snprintf(tmp, sizeof(tmp), "%" PRId64 " kB", tsTotalMemoryKB);
  if (nBytes <= 9 || nBytes >= sizeof(tmp)) {
    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_RANGE, NULL, _exit);
  }
  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "memory", tmp), NULL, _exit);

  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "version", td_version), NULL, _exit);
  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "buildInfo", td_buildinfo), NULL, _exit);
  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "gitInfo", td_gitinfo), NULL, _exit);

  TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "crashSig", signum), NULL, _exit);
  TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "crashTs", taosGetTimestampUs()), NULL, _exit);

#if 0
#ifdef _TD_DARWIN_64
  taosLogTraceToBuf(tmp, sizeof(tmp), 4);
#elif !defined(WINDOWS)
  taosLogTraceToBuf(tmp, sizeof(tmp), 3);
#else
  taosLogTraceToBuf(tmp, sizeof(tmp), 8);
#endif

  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "stackInfo", tmp), NULL, _exit);
#endif
  char* pCont = tjsonToString(pJson);
  if (pCont == NULL) {
    code = terrno;
    TAOS_CHECK_GOTO(code, NULL, _exit);
    goto _exit;
  }

  tjsonDelete(pJson);
  *pMsg = pCont;
  pJson = NULL;
_exit:
  tjsonDelete(pJson);
  TAOS_RETURN(code);
}

int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol, char* likePattern) {
  int32_t  code = 0;
  SConfig* pConf = taosGetCfg();
  if (pConf == NULL) {
    return TSDB_CODE_INVALID_CFG;
  }

  int32_t      numOfRows = 0;
  int32_t      col = startCol;
  SConfigItem* pItem = NULL;
  SConfigIter* pIter = NULL;

  int8_t locked = 0;

  size_t       exSize = 0;
  size_t       index = 0;
  SConfigItem* pDataDirItem = cfgGetItem(pConf, "dataDir");
  if (pDataDirItem) {
    exSize = TMAX(taosArrayGetSize(pDataDirItem->array), 1) - 1;
  }

  TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf) + exSize), NULL, _exit);

  TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);

  cfgLock(pConf);
  locked = 1;

  while ((pItem = cfgNextIter(pIter)) != NULL) {
  _start:
    col = startCol;

    // GRANT_CFG_SKIP;
    char name[TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE] = {0};
    if (likePattern && rawStrPatternMatch(pItem->name, likePattern) != TSDB_PATTERN_MATCH) {
      continue;
    }
    STR_WITH_MAXSIZE_TO_VARSTR(name, pItem->name, TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE);

    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
    if (pColInfo == NULL) {
      code = terrno;
      TAOS_CHECK_GOTO(code, NULL, _exit);
    }

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, name, false), NULL, _exit);

    char      value[TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE] = {0};
    int32_t   valueLen = 0;
    SDiskCfg* pDiskCfg = NULL;
    if (strcasecmp(pItem->name, "dataDir") == 0 && exSize > 0) {
      char* buf = &value[VARSTR_HEADER_SIZE];
      pDiskCfg = taosArrayGet(pItem->array, index);
      valueLen = tsnprintf(buf, TSDB_CONFIG_PATH_LEN, "%s", pDiskCfg->dir);
      index++;
    } else {
      TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_PATH_LEN, &valueLen), NULL,
                      _exit);
    }
    varDataSetLen(value, valueLen);

    pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
    if (pColInfo == NULL) {
      code = terrno;
      TAOS_CHECK_GOTO(code, NULL, _exit);
    }

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, value, false), NULL, _exit);

    char scope[TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE] = {0};
    TAOS_CHECK_GOTO(cfgDumpItemScope(pItem, &scope[VARSTR_HEADER_SIZE], TSDB_CONFIG_SCOPE_LEN, &valueLen), NULL, _exit);
    varDataSetLen(scope, valueLen);

    pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
    if (pColInfo == NULL) {
      code = terrno;
      TAOS_CHECK_GOTO(code, NULL, _exit);
    }
    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, scope, false), NULL, _exit);

    char category[TSDB_CONFIG_CATEGORY_LEN + VARSTR_HEADER_SIZE] = {0};
    TAOS_CHECK_GOTO(cfgDumpItemCategory(pItem, &category[VARSTR_HEADER_SIZE], TSDB_CONFIG_CATEGORY_LEN, &valueLen),
                    NULL, _exit);
    varDataSetLen(category, valueLen);

    pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
    if (pColInfo == NULL) {
      code = terrno;
      TAOS_CHECK_GOTO(code, NULL, _exit);
    }
    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, category, false), NULL, _exit);

    char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};
    if (strcasecmp(pItem->name, "dataDir") == 0 && pDiskCfg) {
      char* buf = &info[VARSTR_HEADER_SIZE];
      valueLen = tsnprintf(buf, TSDB_CONFIG_INFO_LEN, "level %d primary %d disabled %" PRIi8, pDiskCfg->level,
                           pDiskCfg->primary, pDiskCfg->disable);
    } else {
      valueLen = 0;
    }
    varDataSetLen(info, valueLen);

    pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
    if (pColInfo == NULL) {
      code = terrno;
      TAOS_CHECK_GOTO(code, NULL, _exit);
    }
    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, info, false), NULL, _exit);

    numOfRows++;
    if (index > 0 && index <= exSize) {
      goto _start;
    }
  }
  pBlock->info.rows = numOfRows;
_exit:
  if (locked) cfgUnLock(pConf);
  cfgDestroyIter(pIter);
  TAOS_RETURN(code);
}

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 "tdatablock.h"
18	#include "tglobal.h"
19	#include "tjson.h"
20	#include "tmisce.h"
21	#include "tcompare.h"
22
23	int32_t taosGetIpv4FromEp(const char* ep, SEp* pEp) {	116,035✔
24	pEp->port = 0;	116,035✔
25	memset(pEp->fqdn, 0, TSDB_FQDN_LEN);	116,035✔
26	tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);	116,035✔
27
28	char* temp = strrchr(pEp->fqdn, ':');	116,035✔
29	if (temp) {	116,035✔
30	*temp = 0;	104,683✔
31	pEp->port = taosStr2UInt16(temp + 1, NULL, 10);	104,683✔
32	if (pEp->port < 0) {
33	return TSDB_CODE_INVALID_PARA;
34	}
35	}
36
37	if (pEp->port == 0) {	116,040✔
38	pEp->port = tsServerPort;	11,347✔
39	}
40
41	if (pEp->port <= 0) {	116,040!
42	return TSDB_CODE_INVALID_PARA;	×
43	}
44	return 0;	116,040✔
45	}
46
47	int32_t taosGetDualIpFromEp(const char* ep, SEp* pEp) {	×
48	int32_t code = 0;	×
49	memset(pEp->fqdn, 0, TSDB_FQDN_LEN);	×
50
51	strncpy(pEp->fqdn, ep, TSDB_FQDN_LEN - 1);	×
52
53	char* temp = strrchr(pEp->fqdn, ':');	×
54	if (temp) {	×
55	char* ipv6Check = strchr(pEp->fqdn, ':');	×
56	if (ipv6Check != temp) {	×
57	pEp->port = tsServerPort;	×
58	} else {
59	*temp = 0;	×
60	pEp->port = taosStr2UInt16(temp + 1, NULL, 10);	×
61	if (pEp->port == 0) {	×
62	return TSDB_CODE_INVALID_PARA;	×
63	}
64	}
65	} else {
66	pEp->port = tsServerPort;	×
67	}
68	return code;	×
69	}
70	int32_t taosGetFqdnPortFromEp(const char* ep, SEp* pEp) {	116,075✔
71	if (tsEnableIpv6) {	116,075!
72	return taosGetDualIpFromEp(ep, pEp);	×
73	} else {
74	return taosGetIpv4FromEp(ep, pEp);	116,075✔
75	}
76	}
77
78	int32_t addEpIntoEpSet(SEpSet* pEpSet, const char* fqdn, uint16_t port) {	235,244✔
79	if (pEpSet == NULL \|\| fqdn == NULL \|\| strlen(fqdn) == 0) {	235,244!
80	return TSDB_CODE_INVALID_PARA;	×
81	}
82
83	int32_t index = pEpSet->numOfEps;	235,244✔
84	if (index >= sizeof(pEpSet->eps) / sizeof(pEpSet->eps[0])) {	235,244!
85	return TSDB_CODE_OUT_OF_RANGE;	×
86	}
87	tstrncpy(pEpSet->eps[index].fqdn, fqdn, tListLen(pEpSet->eps[index].fqdn));	235,244✔
88	pEpSet->eps[index].port = port;	235,244✔
89	pEpSet->numOfEps += 1;	235,244✔
90	return 0;	235,244✔
91	}
92
93	bool isEpsetEqual(const SEpSet* s1, const SEpSet* s2) {	118,784✔
94	if (s1->numOfEps != s2->numOfEps \|\| s1->inUse != s2->inUse) {	118,784✔
95	return false;	16,288✔
96	}
97
98	for (int32_t i = 0; i < s1->numOfEps; i++) {	212,553✔
99	if (s1->eps[i].port != s2->eps[i].port \|\| strncmp(s1->eps[i].fqdn, s2->eps[i].fqdn, TSDB_FQDN_LEN) != 0)	110,117✔
100	return false;	60✔
101	}
102	return true;	102,436✔
103	}
104
105	void epsetAssign(SEpSet* pDst, const SEpSet* pSrc) {	98,453✔
106	if (pSrc == NULL \|\| pDst == NULL) {	98,453!
107	return;	3✔
108	}
109
110	pDst->inUse = pSrc->inUse;	98,450✔
111	pDst->numOfEps = pSrc->numOfEps;	98,450✔
112	for (int32_t i = 0; i < pSrc->numOfEps; ++i) {	200,740✔
113	pDst->eps[i].port = pSrc->eps[i].port;	102,290✔
114	tstrncpy(pDst->eps[i].fqdn, pSrc->eps[i].fqdn, tListLen(pSrc->eps[i].fqdn));	102,290✔
115	}
116	}
117
118	void epAssign(SEp* pDst, SEp* pSrc) {	180,643✔
119	if (pSrc == NULL \|\| pDst == NULL) {	180,643!
120	return;	×
121	}
122	memset(pDst->fqdn, 0, tListLen(pSrc->fqdn));	180,651✔
123	tstrncpy(pDst->fqdn, pSrc->fqdn, tListLen(pSrc->fqdn));	180,651✔
124	pDst->port = pSrc->port;	180,651✔
125	}
126
127	void epsetSort(SEpSet* pDst) {	632,666✔
128	if (pDst->numOfEps <= 1) {	632,666✔
129	return;	551,967✔
130	}
131	int validIdx = false;	80,699✔
132	SEp ep = {0};	80,699✔
133	if (pDst->inUse >= 0 && pDst->inUse < pDst->numOfEps) {	80,699!
134	validIdx = true;	80,751✔
135	epAssign(&ep, &pDst->eps[pDst->inUse]);	80,751✔
136	}
137
138	for (int i = 0; i < pDst->numOfEps - 1; i++) {	233,318✔
139	for (int j = 0; j < pDst->numOfEps - 1 - i; j++) {	383,357✔
140	SEp* f = &pDst->eps[j];	230,801✔
141	SEp* s = &pDst->eps[j + 1];	230,801✔
142	int cmp = strncmp(f->fqdn, s->fqdn, sizeof(f->fqdn));	230,801✔
143	if (cmp > 0 \|\| (cmp == 0 && f->port > s->port)) {	230,801!
144	SEp ep1 = {0};	33,265✔
145	epAssign(&ep1, f);	33,265✔
146	epAssign(f, s);	33,299✔
147	epAssign(s, &ep1);	33,299✔
148	}
149	}
150	}
151	if (validIdx == true)	80,796✔
152	for (int i = 0; i < pDst->numOfEps; i++) {	159,817✔
153	int cmp = strncmp(ep.fqdn, pDst->eps[i].fqdn, sizeof(ep.fqdn));	159,813✔
154	if (cmp == 0 && ep.port == pDst->eps[i].port) {	159,813✔
155	pDst->inUse = i;	80,764✔
156	break;	80,764✔
157	}
158	}
159	}
160
161	void updateEpSet_s(SCorEpSet* pEpSet, SEpSet* pNewEpSet) {	16,311✔
162	taosCorBeginWrite(&pEpSet->version);	16,311!
163	pEpSet->epSet = *pNewEpSet;	16,311✔
164	taosCorEndWrite(&pEpSet->version);	16,311✔
165	}	16,311✔
166
167	SEpSet getEpSet_s(SCorEpSet* pEpSet) {	34,085,908✔
168	SEpSet ep = {0};	34,085,908✔
169	taosCorBeginRead(&pEpSet->version);	34,083,570!
170	ep = pEpSet->epSet;	34,299,122✔
171	taosCorEndRead(&pEpSet->version);	34,299,122!
172
173	return ep;	34,308,017✔
174	}
175
176	int32_t epsetToStr(const SEpSet* pEpSet, char* pBuf, int32_t cap) {	169,593✔
177	int32_t ret = 0;	169,593✔
178	int32_t nwrite = 0;	169,593✔
179
180	nwrite = snprintf(pBuf + nwrite, cap, "epset:{");	169,593✔
181	if (nwrite <= 0 \|\| nwrite >= cap) {	169,593!
182	return TSDB_CODE_OUT_OF_BUFFER;	1✔
183	}
184	cap -= nwrite;	169,592✔
185
186	for (int _i = 0; (_i < pEpSet->numOfEps) && (cap > 0); _i++) {	489,166!
187	if (_i == pEpSet->numOfEps - 1) {	319,579✔
188	ret = snprintf(pBuf + nwrite, cap, "%d. %s:%d", _i, pEpSet->eps[_i].fqdn, pEpSet->eps[_i].port);	169,592✔
189	} else {
190	ret = snprintf(pBuf + nwrite, cap, "%d. %s:%d, ", _i, pEpSet->eps[_i].fqdn, pEpSet->eps[_i].port);	149,987✔
191	}
192
193	if (ret <= 0 \|\| ret >= cap) {	319,579✔
194	return TSDB_CODE_OUT_OF_BUFFER;	5✔
195	}
196
197	nwrite += ret;	319,574✔
198	cap -= ret;	319,574✔
199	}
200
201	if (cap <= 0) {	169,587!
202	return TSDB_CODE_OUT_OF_BUFFER;	×
203	}
204
205	ret = snprintf(pBuf + nwrite, cap, "}, inUse:%d", pEpSet->inUse);	169,587✔
206	if (ret <= 0 \|\| ret >= cap) {	169,587!
207	return TSDB_CODE_OUT_OF_BUFFER;	×
208	} else {
209	return TSDB_CODE_SUCCESS;	169,593✔
210	}
211	}
212
213	int32_t taosGenCrashJsonMsg(int signum, char** pMsg, int64_t clusterId, int64_t startTime) {	×
214	int32_t code = 0;	×
215	SJson* pJson = tjsonCreateObject();	×
216	if (pJson == NULL) return terrno;	×
217
218	char tmp[4096] = {0};	×
219
220	TAOS_CHECK_GOTO(tjsonAddDoubleToObject(pJson, "reportVersion", 1), NULL, _exit);	×
221
222	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "clusterId", clusterId), NULL, _exit);	×
223	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "startTime", startTime), NULL, _exit);	×
224
225	// Do NOT invoke the taosGetFqdn here.
226	// this function may be invoked when memory exception occurs,so we should assume that it is running in a memory locked
227	// environment. The lock operation by taosGetFqdn may cause this program deadlock.
228	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "fqdn", tsLocalFqdn), NULL, _exit);	×
229
230	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "pid", taosGetPId()), NULL, _exit);	×
231
232	code = taosGetAppName(tmp, NULL);	×
233	if (code != 0) {	×
234	TAOS_CHECK_GOTO(code, NULL, _exit);	×
235	}
236	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "appName", tmp), NULL, _exit);	×
237
238	if (taosGetOsReleaseName(tmp, NULL, NULL, sizeof(tmp)) == 0) {	×
239	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "os", tmp), NULL, _exit);	×
240	} else {
241	// do nothing
242	}
243
244	float numOfCores = 0;	×
245	if (taosGetCpuInfo(tmp, sizeof(tmp), &numOfCores) == 0) {	×
246	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "cpuModel", tmp), NULL, _exit);	×
247	TAOS_CHECK_GOTO(tjsonAddDoubleToObject(pJson, "numOfCpu", numOfCores), NULL, _exit);	×
248	} else {
249	TAOS_CHECK_GOTO(tjsonAddDoubleToObject(pJson, "numOfCpu", tsNumOfCores), NULL, _exit);	×
250	}
251
252	int32_t nBytes = snprintf(tmp, sizeof(tmp), "%" PRId64 " kB", tsTotalMemoryKB);	×
253	if (nBytes <= 9 \|\| nBytes >= sizeof(tmp)) {	×
254	TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_RANGE, NULL, _exit);	×
255	}
256	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "memory", tmp), NULL, _exit);	×
257
258	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "version", td_version), NULL, _exit);	×
259	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "buildInfo", td_buildinfo), NULL, _exit);	×
260	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "gitInfo", td_gitinfo), NULL, _exit);	×
261
262	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "crashSig", signum), NULL, _exit);	×
263	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "crashTs", taosGetTimestampUs()), NULL, _exit);	×
264
265	#if 0
266	#ifdef _TD_DARWIN_64
267	taosLogTraceToBuf(tmp, sizeof(tmp), 4);
268	#elif !defined(WINDOWS)
269	taosLogTraceToBuf(tmp, sizeof(tmp), 3);
270	#else
271	taosLogTraceToBuf(tmp, sizeof(tmp), 8);
272	#endif
273
274	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "stackInfo", tmp), NULL, _exit);
275	#endif
276	char* pCont = tjsonToString(pJson);	×
277	if (pCont == NULL) {	×
278	code = terrno;	×
279	TAOS_CHECK_GOTO(code, NULL, _exit);	×
280	goto _exit;	×
281	}
282
283	tjsonDelete(pJson);	×
284	*pMsg = pCont;	×
285	pJson = NULL;	×
286	_exit:	×
287	tjsonDelete(pJson);	×
288	TAOS_RETURN(code);	×
289	}
290
291	int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol, char* likePattern) {	5,099✔
292	int32_t code = 0;	5,099✔
293	SConfig* pConf = taosGetCfg();	5,099✔
294	if (pConf == NULL) {	5,099!
295	return TSDB_CODE_INVALID_CFG;	×
296	}
297
298	int32_t numOfRows = 0;	5,099✔
299	int32_t col = startCol;	5,099✔
300	SConfigItem* pItem = NULL;	5,099✔
301	SConfigIter* pIter = NULL;	5,099✔
302
303	int8_t locked = 0;	5,099✔
304
305	size_t exSize = 0;	5,099✔
306	size_t index = 0;	5,099✔
307	SConfigItem* pDataDirItem = cfgGetItem(pConf, "dataDir");	5,099✔
308	if (pDataDirItem) {	5,099✔
309	exSize = TMAX(taosArrayGetSize(pDataDirItem->array), 1) - 1;	4,520✔
310	}
311
312	TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf) + exSize), NULL, _exit);	5,099!
313
314	TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);	5,099!
315
316	cfgLock(pConf);	5,099✔
317	locked = 1;	5,099✔
318
319	while ((pItem = cfgNextIter(pIter)) != NULL) {	1,063,432✔
320	_start:	1,058,333✔
321	col = startCol;	1,058,333✔
322
323	// GRANT_CFG_SKIP;
324	char name[TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE] = {0};	1,058,333✔
325	if (likePattern && rawStrPatternMatch(pItem->name, likePattern) != TSDB_PATTERN_MATCH) {	1,058,333✔
326	continue;	593✔
327	}
328	STR_WITH_MAXSIZE_TO_VARSTR(name, pItem->name, TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE);	1,057,740✔
329
330	SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	1,057,740✔
331	if (pColInfo == NULL) {	1,057,740!
332	code = terrno;	×
333	TAOS_CHECK_GOTO(code, NULL, _exit);	×
334	}
335
336	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, name, false), NULL, _exit);	1,057,740!
337
338	char value[TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE] = {0};	1,057,740✔
339	int32_t valueLen = 0;	1,057,740✔
340	SDiskCfg* pDiskCfg = NULL;	1,057,740✔
341	if (strcasecmp(pItem->name, "dataDir") == 0 && exSize > 0) {	1,057,740!
342	char* buf = &value[VARSTR_HEADER_SIZE];	×
343	pDiskCfg = taosArrayGet(pItem->array, index);	×
344	valueLen = tsnprintf(buf, TSDB_CONFIG_PATH_LEN, "%s", pDiskCfg->dir);	×
345	index++;	×
346	} else {
347	TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_PATH_LEN, &valueLen), NULL,	1,057,740!
348	_exit);
349	}
350	varDataSetLen(value, valueLen);	1,057,740✔
351
352	pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	1,057,740✔
353	if (pColInfo == NULL) {	1,057,740!
354	code = terrno;	×
355	TAOS_CHECK_GOTO(code, NULL, _exit);	×
356	}
357
358	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, value, false), NULL, _exit);	1,057,740!
359
360	char scope[TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE] = {0};	1,057,740✔
361	TAOS_CHECK_GOTO(cfgDumpItemScope(pItem, &scope[VARSTR_HEADER_SIZE], TSDB_CONFIG_SCOPE_LEN, &valueLen), NULL, _exit);	1,057,740!
362	varDataSetLen(scope, valueLen);	1,057,740✔
363
364	pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	1,057,740✔
365	if (pColInfo == NULL) {	1,057,740!
366	code = terrno;	×
367	TAOS_CHECK_GOTO(code, NULL, _exit);	×
368	}
369	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, scope, false), NULL, _exit);	1,057,740!
370
371	char category[TSDB_CONFIG_CATEGORY_LEN + VARSTR_HEADER_SIZE] = {0};	1,057,740✔
372	TAOS_CHECK_GOTO(cfgDumpItemCategory(pItem, &category[VARSTR_HEADER_SIZE], TSDB_CONFIG_CATEGORY_LEN, &valueLen),	1,057,740!
373	NULL, _exit);
374	varDataSetLen(category, valueLen);	1,057,740✔
375
376	pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	1,057,740✔
377	if (pColInfo == NULL) {	1,057,740!
378	code = terrno;	×
379	TAOS_CHECK_GOTO(code, NULL, _exit);	×
380	}
381	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, category, false), NULL, _exit);	1,057,740!
382
383	char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};	1,057,740✔
384	if (strcasecmp(pItem->name, "dataDir") == 0 && pDiskCfg) {	1,057,740!
385	char* buf = &info[VARSTR_HEADER_SIZE];	×
386	valueLen = tsnprintf(buf, TSDB_CONFIG_INFO_LEN, "level %d primary %d disabled %" PRIi8, pDiskCfg->level,	×
387	pDiskCfg->primary, pDiskCfg->disable);	×
388	} else {
389	valueLen = 0;	1,057,740✔
390	}
391	varDataSetLen(info, valueLen);	1,057,740✔
392
393	pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	1,057,740✔
394	if (pColInfo == NULL) {	1,057,740!
395	code = terrno;	×
396	TAOS_CHECK_GOTO(code, NULL, _exit);	×
397	}
398	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, info, false), NULL, _exit);	1,057,740!
399
400	numOfRows++;	1,057,740✔
401	if (index > 0 && index <= exSize) {	1,057,740!
402	goto _start;	×
403	}
404	}
405	pBlock->info.rows = numOfRows;	5,099✔
406	_exit:	5,099✔
407	if (locked) cfgUnLock(pConf);	5,099!
408	cfgDestroyIter(pIter);	5,099✔
409	TAOS_RETURN(code);	5,099✔
410	}

taosdata / TDengine / #4271

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