#5049

Committed 11 May 2026 06:30AM UTC coverage: 73.313% (+0.09%) from 73.222%

Build # #5049

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

feat: refactor taosdump code to improve backup speed and compression ratio (#35292)

Coverage Stats

6625 of 8435 new or added lines in 28 files covered. (78.54%)

2491 existing lines in 142 files now uncovered.

281233 of 383605 relevant lines covered (73.31%)

132489999.79 hits per line

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

74.47

/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;
}

static int8_t isValidPort(const char* str) {
  if (!str || !*str) return 0;
  for (const char* p = str; *p; ++p) {
    if (*p < '0' || *p > '9') {
      return 0;
    }
  }
  return 1;
}

static int32_t taosGetDualIpFromEp(const char* ep, SEp* pEp) {
  memset(pEp->fqdn, 0, TSDB_FQDN_LEN);
  pEp->port = 0;
  char buf[TSDB_FQDN_LEN] = {0};

  if (ep[0] == '[') {
    // [IPv6]:port format
    const char* end = strchr(ep, ']');
    if (!end) return TSDB_CODE_INVALID_PARA;

    int ipLen = end - ep - 1;
    if (ipLen >= TSDB_FQDN_LEN) ipLen = TSDB_FQDN_LEN - 1;

    tstrncpy(pEp->fqdn, ep + 1, ipLen + 1);

    if (*(end + 1) == ':' && *(end + 2)) {
      pEp->port = taosStr2UInt16(end + 2, NULL, 10);
    }
  } else {
    // Compatible with ::1:6030, ::1, IPv4:port, hostname:port, etc.
    tstrncpy(buf, ep, sizeof(buf));

    char* lastColon = strrchr(buf, ':');
    char* firstColon = strchr(buf, ':');

    if (lastColon && firstColon != lastColon) {
      // Multiple colons, possibly IPv6:port or pure IPv6
      char* portStr = lastColon + 1;
      if (isValidPort(portStr) && lastColon != buf && (*(lastColon - 1) != ':')) {
        *lastColon = 0;
        tstrncpy(pEp->fqdn, buf, TSDB_FQDN_LEN);
        pEp->port = taosStr2UInt16(portStr, NULL, 10);
      } else {
        tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);
      }
    } else if (lastColon) {
      // Only one colon, IPv4:port or hostname:port
      char* portStr = lastColon + 1;
      if (isValidPort(portStr) && lastColon != buf) {
        *lastColon = 0;
        tstrncpy(pEp->fqdn, buf, TSDB_FQDN_LEN);
        pEp->port = taosStr2UInt16(portStr, NULL, 10);
      } else {
        tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);
      }
    } else {
      // No colon, pure hostname or IPv6 without port
      tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);
    }
  }

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

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

  return 0;
}
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);
}

#ifdef TD_ENTERPRISE
static bool showVarPrivAllowed(uint8_t showPrivMask, int8_t cfgPrivType) {
  switch (cfgPrivType) {
    case CFG_PRIV_SYSTEM:
      return (showPrivMask & SHOW_VAR_PRIV_SYSTEM) != 0;
    case CFG_PRIV_SECURITY:
      return (showPrivMask & SHOW_VAR_PRIV_SECURITY) != 0;
    case CFG_PRIV_AUDIT:
      return (showPrivMask & SHOW_VAR_PRIV_AUDIT) != 0;
    case CFG_PRIV_DEBUG:
      return (showPrivMask & SHOW_VAR_PRIV_DEBUG) != 0;
    default:
      return false;
  }
}
#endif

int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol, char* likePattern, uint8_t showPrivMask) {
  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;
    }
#ifdef TD_ENTERPRISE
    if (!showVarPrivAllowed(showPrivMask, pItem->privType)) {
      continue;
    }
#endif
    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 = snprintf(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 = snprintf(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) {	100,365,597✔
24	pEp->port = 0;	100,365,597✔
25	memset(pEp->fqdn, 0, TSDB_FQDN_LEN);	100,366,271✔
26	tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);	100,365,492✔
27
28	char* temp = strrchr(pEp->fqdn, ':');	100,365,163✔
29	if (temp) {	100,364,891✔
30	*temp = 0;	13,456,660✔
31	pEp->port = taosStr2UInt16(temp + 1, NULL, 10);	13,456,682✔
32	if (pEp->port < 0) {
33	return TSDB_CODE_INVALID_PARA;
34	}
35	}
36
37	if (pEp->port == 0) {	100,364,782✔
38	pEp->port = tsServerPort;	86,910,740✔
39	}
40
41	if (pEp->port <= 0) {	100,364,812✔
42	return TSDB_CODE_INVALID_PARA;	×
43	}
44	return 0;	100,366,077✔
45	}
46
47	static int8_t isValidPort(const char* str) {	816✔
48	if (!str \|\| !*str) return 0;	816✔
49	for (const char* p = str; *p; ++p) {	3,468✔
50	if (p < '0' \|\| p > '9') {	2,652✔
51	return 0;	×
52	}
53	}
54	return 1;	816✔
55	}
56
57	static int32_t taosGetDualIpFromEp(const char* ep, SEp* pEp) {	1,632✔
58	memset(pEp->fqdn, 0, TSDB_FQDN_LEN);	1,632✔
59	pEp->port = 0;	1,632✔
60	char buf[TSDB_FQDN_LEN] = {0};	1,632✔
61
62	if (ep[0] == '[') {	1,632✔
63	// [IPv6]:port format
64	const char* end = strchr(ep, ']');	408✔
65	if (!end) return TSDB_CODE_INVALID_PARA;	408✔
66
67	int ipLen = end - ep - 1;	408✔
68	if (ipLen >= TSDB_FQDN_LEN) ipLen = TSDB_FQDN_LEN - 1;	408✔
69
70	tstrncpy(pEp->fqdn, ep + 1, ipLen + 1);	408✔
71
72	if ((end + 1) == ':' && (end + 2)) {	408✔
73	pEp->port = taosStr2UInt16(end + 2, NULL, 10);	204✔
74	}
75	} else {
76	// Compatible with ::1:6030, ::1, IPv4:port, hostname:port, etc.
77	tstrncpy(buf, ep, sizeof(buf));	1,224✔
78
79	char* lastColon = strrchr(buf, ':');	1,224✔
80	char* firstColon = strchr(buf, ':');	1,224✔
81
82	if (lastColon && firstColon != lastColon) {	1,836✔
83	// Multiple colons, possibly IPv6:port or pure IPv6
84	char* portStr = lastColon + 1;	612✔
85	if (isValidPort(portStr) && lastColon != buf && (*(lastColon - 1) != ':')) {	612✔
86	*lastColon = 0;	408✔
87	tstrncpy(pEp->fqdn, buf, TSDB_FQDN_LEN);	408✔
88	pEp->port = taosStr2UInt16(portStr, NULL, 10);	408✔
89	} else {
90	tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);	204✔
91	}
92	} else if (lastColon) {	612✔
93	// Only one colon, IPv4:port or hostname:port
94	char* portStr = lastColon + 1;	204✔
95	if (isValidPort(portStr) && lastColon != buf) {	204✔
96	*lastColon = 0;	204✔
97	tstrncpy(pEp->fqdn, buf, TSDB_FQDN_LEN);	204✔
98	pEp->port = taosStr2UInt16(portStr, NULL, 10);	204✔
99	} else {
100	tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);	×
101	}
102	} else {
103	// No colon, pure hostname or IPv6 without port
104	tstrncpy(pEp->fqdn, ep, TSDB_FQDN_LEN);	408✔
105	}
106	}
107
108	if (pEp->port == 0) {	1,632✔
109	pEp->port = tsServerPort;	816✔
110	}
111
112	if (pEp->port <= 0) {	1,632✔
113	return TSDB_CODE_INVALID_PARA;	×
114	}
115
116	return 0;	1,632✔
117	}
118	int32_t taosGetFqdnPortFromEp(const char* ep, SEp* pEp) {	100,364,974✔
119	if (tsEnableIpv6) {	100,364,974✔
120	return taosGetDualIpFromEp(ep, pEp);	1,632✔
121	} else {
122	return taosGetIpv4FromEp(ep, pEp);	100,363,342✔
123	}
124	}
125
126	int32_t addEpIntoEpSet(SEpSet* pEpSet, const char* fqdn, uint16_t port) {	58,803,540✔
127	if (pEpSet == NULL \|\| fqdn == NULL \|\| strlen(fqdn) == 0) {	58,803,540✔
128	return TSDB_CODE_INVALID_PARA;	×
129	}
130
131	int32_t index = pEpSet->numOfEps;	58,803,540✔
132	if (index >= sizeof(pEpSet->eps) / sizeof(pEpSet->eps[0])) {	58,803,540✔
133	return TSDB_CODE_OUT_OF_RANGE;	×
134	}
135	tstrncpy(pEpSet->eps[index].fqdn, fqdn, tListLen(pEpSet->eps[index].fqdn));	58,803,540✔
136	pEpSet->eps[index].port = port;	58,803,540✔
137	pEpSet->numOfEps += 1;	58,803,540✔
138	return 0;	58,803,540✔
139	}
140
141	bool isEpsetEqual(const SEpSet* s1, const SEpSet* s2) {	11,926,458✔
142	if (s1->numOfEps != s2->numOfEps \|\| s1->inUse != s2->inUse) {	11,926,458✔
143	return false;	1,282,360✔
144	}
145
146	for (int32_t i = 0; i < s1->numOfEps; i++) {	22,877,650✔
147	if (s1->eps[i].port != s2->eps[i].port \|\| strncmp(s1->eps[i].fqdn, s2->eps[i].fqdn, TSDB_FQDN_LEN) != 0)	12,236,866✔
148	return false;	3,183✔
149	}
150	return true;	10,640,784✔
151	}
152
153	void epsetAssign(SEpSet* pDst, const SEpSet* pSrc) {	310,594✔
154	if (pSrc == NULL \|\| pDst == NULL) {	310,594✔
155	return;	×
156	}
157
158	pDst->inUse = pSrc->inUse;	310,594✔
159	pDst->numOfEps = pSrc->numOfEps;	310,594✔
160	for (int32_t i = 0; i < pSrc->numOfEps; ++i) {	1,195,154✔
161	pDst->eps[i].port = pSrc->eps[i].port;	884,560✔
162	tstrncpy(pDst->eps[i].fqdn, pSrc->eps[i].fqdn, tListLen(pSrc->eps[i].fqdn));	884,560✔
163	}
164	}
165
166	void epAssign(SEp* pDst, SEp* pSrc) {	84,038,049✔
167	if (pSrc == NULL \|\| pDst == NULL) {	84,038,049✔
168	return;	×
169	}
170	memset(pDst->fqdn, 0, tListLen(pSrc->fqdn));	84,038,175✔
171	tstrncpy(pDst->fqdn, pSrc->fqdn, tListLen(pSrc->fqdn));	84,038,175✔
172	pDst->port = pSrc->port;	84,038,916✔
173	}
174
175	void epsetSort(SEpSet* pDst) {	93,468,292✔
176	if (pDst->numOfEps <= 1) {	93,468,292✔
177	return;	69,709,550✔
178	}
179	int validIdx = false;	23,762,028✔
180	SEp ep = {0};	23,762,028✔
181	if (pDst->inUse >= 0 && pDst->inUse < pDst->numOfEps) {	23,761,912✔
182	validIdx = true;	23,761,639✔
183	epAssign(&ep, &pDst->eps[pDst->inUse]);	23,761,639✔
184	}
185
186	for (int i = 0; i < pDst->numOfEps - 1; i++) {	69,602,084✔
187	for (int j = 0; j < pDst->numOfEps - 1 - i; j++) {	117,739,115✔
188	SEp* f = &pDst->eps[j];	71,899,702✔
189	SEp* s = &pDst->eps[j + 1];	71,899,566✔
190	int cmp = strncmp(f->fqdn, s->fqdn, sizeof(f->fqdn));	71,898,517✔
191	if (cmp > 0 \|\| (cmp == 0 && f->port > s->port)) {	71,899,197✔
192	SEp ep1 = {0};	20,093,024✔
193	epAssign(&ep1, f);	20,091,800✔
194	epAssign(f, s);	20,092,123✔
195	epAssign(s, &ep1);	20,092,123✔
196	}
197	}
198	}
199	if (validIdx == true)	23,761,645✔
200	for (int i = 0; i < pDst->numOfEps; i++) {	45,796,678✔
201	int cmp = strncmp(ep.fqdn, pDst->eps[i].fqdn, sizeof(ep.fqdn));	45,797,311✔
202	if (cmp == 0 && ep.port == pDst->eps[i].port) {	45,796,536✔
203	pDst->inUse = i;	23,762,139✔
204	break;	23,761,425✔
205	}
206	}
207	}
208
209	void updateEpSet_s(SCorEpSet* pEpSet, SEpSet* pNewEpSet) {	1,286,325✔
210	taosCorBeginWrite(&pEpSet->version);	1,286,325✔
211	pEpSet->epSet = *pNewEpSet;	1,286,325✔
212	taosCorEndWrite(&pEpSet->version);	1,286,325✔
213	}	1,286,325✔
214
215	SEpSet getEpSet_s(SCorEpSet* pEpSet) {	2,147,483,647✔
216	SEpSet ep = {0};	2,147,483,647✔
217	taosCorBeginRead(&pEpSet->version);	2,147,483,647✔
218	ep = pEpSet->epSet;	2,147,483,647✔
219	taosCorEndRead(&pEpSet->version);	2,147,483,647✔
220
221	return ep;	2,147,483,647✔
222	}
223
224	int32_t epsetToStr(const SEpSet* pEpSet, char* pBuf, int32_t cap) {	1,249,213,990✔
225	int32_t ret = 0;	1,249,213,990✔
226	int32_t nwrite = 0;	1,249,213,990✔
227
228	nwrite = snprintf(pBuf + nwrite, cap, "epset:{");	1,249,213,990✔
229	if (nwrite <= 0 \|\| nwrite >= cap) {	1,249,292,645✔
230	return TSDB_CODE_OUT_OF_BUFFER;	40,112✔
231	}
232	cap -= nwrite;	1,249,256,815✔
233
234	for (int _i = 0; (_i < pEpSet->numOfEps) && (cap > 0); _i++) {	2,147,483,647✔
235	if (_i == pEpSet->numOfEps - 1) {	1,486,526,385✔
236	ret = snprintf(pBuf + nwrite, cap, "%d. %s:%d", _i, pEpSet->eps[_i].fqdn, pEpSet->eps[_i].port);	1,249,214,254✔
237	} else {
238	ret = snprintf(pBuf + nwrite, cap, "%d. %s:%d, ", _i, pEpSet->eps[_i].fqdn, pEpSet->eps[_i].port);	237,257,307✔
239	}
240
241	if (ret <= 0 \|\| ret >= cap) {	1,486,489,792✔
242	return TSDB_CODE_OUT_OF_BUFFER;	9,438✔
243	}
244
245	nwrite += ret;	1,486,480,354✔
246	cap -= ret;	1,486,480,354✔
247	}
248
249	if (cap <= 0) {	1,249,237,093✔
250	return TSDB_CODE_OUT_OF_BUFFER;	×
251	}
252
253	ret = snprintf(pBuf + nwrite, cap, "}, inUse:%d", pEpSet->inUse);	1,249,237,093✔
254	if (ret <= 0 \|\| ret >= cap) {	1,249,257,416✔
UNCOV 255	return TSDB_CODE_OUT_OF_BUFFER;	×
256	} else {
257	return TSDB_CODE_SUCCESS;	1,249,269,944✔
258	}
259	}
260
261	int32_t taosGenCrashJsonMsg(int signum, char** pMsg, int64_t clusterId, int64_t startTime) {	×
262	int32_t code = 0;	×
263	SJson* pJson = tjsonCreateObject();	×
264	if (pJson == NULL) return terrno;	×
265
266	char tmp[4096] = {0};	×
267
268	TAOS_CHECK_GOTO(tjsonAddDoubleToObject(pJson, "reportVersion", 1), NULL, _exit);	×
269
270	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "clusterId", clusterId), NULL, _exit);	×
271	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "startTime", startTime), NULL, _exit);	×
272
273	// Do NOT invoke the taosGetFqdn here.
274	// this function may be invoked when memory exception occurs,so we should assume that it is running in a memory locked
275	// environment. The lock operation by taosGetFqdn may cause this program deadlock.
276	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "fqdn", tsLocalFqdn), NULL, _exit);	×
277
278	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "pid", taosGetPId()), NULL, _exit);	×
279
280	code = taosGetAppName(tmp, NULL);	×
281	if (code != 0) {	×
282	TAOS_CHECK_GOTO(code, NULL, _exit);	×
283	}
284	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "appName", tmp), NULL, _exit);	×
285
286	if (taosGetOsReleaseName(tmp, NULL, NULL, sizeof(tmp)) == 0) {	×
287	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "os", tmp), NULL, _exit);	×
288	} else {
289	// do nothing
290	}
291
292	float numOfCores = 0;	×
293	if (taosGetCpuInfo(tmp, sizeof(tmp), &numOfCores) == 0) {	×
294	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "cpuModel", tmp), NULL, _exit);	×
295	TAOS_CHECK_GOTO(tjsonAddDoubleToObject(pJson, "numOfCpu", numOfCores), NULL, _exit);	×
296	} else {
297	TAOS_CHECK_GOTO(tjsonAddDoubleToObject(pJson, "numOfCpu", tsNumOfCores), NULL, _exit);	×
298	}
299
300	int32_t nBytes = snprintf(tmp, sizeof(tmp), "%" PRId64 " kB", tsTotalMemoryKB);	×
301	if (nBytes <= 9 \|\| nBytes >= sizeof(tmp)) {	×
302	TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_RANGE, NULL, _exit);	×
303	}
304	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "memory", tmp), NULL, _exit);	×
305
306	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "version", td_version), NULL, _exit);	×
307	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "buildInfo", td_buildinfo), NULL, _exit);	×
308	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "gitInfo", td_gitinfo), NULL, _exit);	×
309
310	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "crashSig", signum), NULL, _exit);	×
311	TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "crashTs", taosGetTimestampUs()), NULL, _exit);	×
312
313	#if 0
314	#ifdef _TD_DARWIN_64
315	taosLogTraceToBuf(tmp, sizeof(tmp), 4);
316	#elif !defined(WINDOWS)
317	taosLogTraceToBuf(tmp, sizeof(tmp), 3);
318	#else
319	taosLogTraceToBuf(tmp, sizeof(tmp), 8);
320	#endif
321
322	TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "stackInfo", tmp), NULL, _exit);
323	#endif
324	char* pCont = tjsonToString(pJson);	×
325	if (pCont == NULL) {	×
326	code = terrno;	×
327	TAOS_CHECK_GOTO(code, NULL, _exit);	×
328	goto _exit;	×
329	}
330
331	tjsonDelete(pJson);	×
332	*pMsg = pCont;	×
333	pJson = NULL;	×
334	_exit:	×
335	tjsonDelete(pJson);	×
336	TAOS_RETURN(code);	×
337	}
338
339	#ifdef TD_ENTERPRISE
340	static bool showVarPrivAllowed(uint8_t showPrivMask, int8_t cfgPrivType) {	10,578,478✔
341	switch (cfgPrivType) {	10,578,478✔
342	case CFG_PRIV_SYSTEM:	8,348,619✔
343	return (showPrivMask & SHOW_VAR_PRIV_SYSTEM) != 0;	8,348,619✔
344	case CFG_PRIV_SECURITY:	533,876✔
345	return (showPrivMask & SHOW_VAR_PRIV_SECURITY) != 0;	533,876✔
346	case CFG_PRIV_AUDIT:	316,210✔
347	return (showPrivMask & SHOW_VAR_PRIV_AUDIT) != 0;	316,210✔
348	case CFG_PRIV_DEBUG:	1,379,773✔
349	return (showPrivMask & SHOW_VAR_PRIV_DEBUG) != 0;	1,379,773✔
350	default:	×
351	return false;	×
352	}
353	}
354	#endif
355
356	int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol, char* likePattern, uint8_t showPrivMask) {	48,666✔
357	int32_t code = 0;	48,666✔
358	SConfig* pConf = taosGetCfg();	48,666✔
359	if (pConf == NULL) {	48,666✔
360	return TSDB_CODE_INVALID_CFG;	×
361	}
362
363	int32_t numOfRows = 0;	48,666✔
364	int32_t col = startCol;	48,666✔
365	SConfigItem* pItem = NULL;	48,666✔
366	SConfigIter* pIter = NULL;	48,666✔
367
368	int8_t locked = 0;	48,666✔
369
370	size_t exSize = 0;	48,666✔
371	size_t index = 0;	48,666✔
372	SConfigItem* pDataDirItem = cfgGetItem(pConf, "dataDir");	48,666✔
373	if (pDataDirItem) {	48,666✔
374	exSize = TMAX(taosArrayGetSize(pDataDirItem->array), 1) - 1;	31,621✔
375	}
376
377	TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf) + exSize), NULL, _exit);	48,666✔
378
379	TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);	48,666✔
380
381	cfgLock(pConf);	48,666✔
382	locked = 1;	48,666✔
383
384	while ((pItem = cfgNextIter(pIter)) != NULL) {	11,084,068✔
385	_start:	11,035,402✔
386	col = startCol;	11,035,402✔
387
388	// GRANT_CFG_SKIP;
389	char name[TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE] = {0};	11,035,402✔
390	if (likePattern && rawStrPatternMatch(pItem->name, likePattern) != TSDB_PATTERN_MATCH) {	11,035,402✔
391	continue;	456,924✔
392	}
393	#ifdef TD_ENTERPRISE
394	if (!showVarPrivAllowed(showPrivMask, pItem->privType)) {	10,578,478✔
395	continue;	4,743✔
396	}
397	#endif
398	STR_WITH_MAXSIZE_TO_VARSTR(name, pItem->name, TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE);	10,573,735✔
399
400	SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	10,573,735✔
401	if (pColInfo == NULL) {	10,573,735✔
402	code = terrno;	×
403	TAOS_CHECK_GOTO(code, NULL, _exit);	×
404	}
405
406	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, name, false), NULL, _exit);	10,573,735✔
407
408	char value[TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE] = {0};	10,573,735✔
409	int32_t valueLen = 0;	10,573,735✔
410	SDiskCfg* pDiskCfg = NULL;	10,573,735✔
411	if (strcasecmp(pItem->name, "dataDir") == 0 && exSize > 0) {	10,573,735✔
412	char* buf = &value[VARSTR_HEADER_SIZE];	×
413	pDiskCfg = taosArrayGet(pItem->array, index);	×
414	valueLen = snprintf(buf, TSDB_CONFIG_PATH_LEN, "%s", pDiskCfg->dir);	×
415	index++;	×
416	} else {
417	TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_PATH_LEN, &valueLen), NULL,	10,573,735✔
418	_exit);
419	}
420	varDataSetLen(value, valueLen);	10,573,735✔
421
422	pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	10,573,735✔
423	if (pColInfo == NULL) {	10,573,735✔
424	code = terrno;	×
425	TAOS_CHECK_GOTO(code, NULL, _exit);	×
426	}
427
428	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, value, false), NULL, _exit);	10,573,735✔
429
430	char scope[TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE] = {0};	10,573,735✔
431	TAOS_CHECK_GOTO(cfgDumpItemScope(pItem, &scope[VARSTR_HEADER_SIZE], TSDB_CONFIG_SCOPE_LEN, &valueLen), NULL, _exit);	10,573,735✔
432	varDataSetLen(scope, valueLen);	10,573,735✔
433
434	pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	10,573,735✔
435	if (pColInfo == NULL) {	10,573,735✔
436	code = terrno;	×
437	TAOS_CHECK_GOTO(code, NULL, _exit);	×
438	}
439	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, scope, false), NULL, _exit);	10,573,735✔
440
441	char category[TSDB_CONFIG_CATEGORY_LEN + VARSTR_HEADER_SIZE] = {0};	10,573,735✔
442	TAOS_CHECK_GOTO(cfgDumpItemCategory(pItem, &category[VARSTR_HEADER_SIZE], TSDB_CONFIG_CATEGORY_LEN, &valueLen),	10,573,735✔
443	NULL, _exit);
444	varDataSetLen(category, valueLen);	10,573,735✔
445
446	pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	10,573,735✔
447	if (pColInfo == NULL) {	10,573,735✔
448	code = terrno;	×
449	TAOS_CHECK_GOTO(code, NULL, _exit);	×
450	}
451	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, category, false), NULL, _exit);	10,573,735✔
452
453	char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};	10,573,735✔
454	if (strcasecmp(pItem->name, "dataDir") == 0 && pDiskCfg) {	10,573,735✔
455	char* buf = &info[VARSTR_HEADER_SIZE];	×
456	valueLen = snprintf(buf, TSDB_CONFIG_INFO_LEN, "level %d primary %d disabled %" PRIi8, pDiskCfg->level,	×
457	pDiskCfg->primary, pDiskCfg->disable);	×
458	} else {
459	valueLen = 0;	10,573,735✔
460	}
461	varDataSetLen(info, valueLen);	10,573,735✔
462
463	pColInfo = taosArrayGet(pBlock->pDataBlock, col++);	10,573,735✔
464	if (pColInfo == NULL) {	10,573,735✔
465	code = terrno;	×
466	TAOS_CHECK_GOTO(code, NULL, _exit);	×
467	}
468	TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, info, false), NULL, _exit);	10,573,735✔
469
470	numOfRows++;	10,573,735✔
471	if (index > 0 && index <= exSize) {	10,573,735✔
472	goto _start;	×
473	}
474	}
475	pBlock->info.rows = numOfRows;	48,666✔
476	_exit:	48,666✔
477	if (locked) cfgUnLock(pConf);	48,666✔
478	cfgDestroyIter(pIter);	48,666✔
479	TAOS_RETURN(code);	48,666✔
480	}

taosdata / TDengine / #5049

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