From 2136789e857a0b1eba43d1e3b0f8b8016492fda3 Mon Sep 17 00:00:00 2001 From: Hui Li Date: Sat, 8 Aug 2020 17:09:33 +0800 Subject: [PATCH] [TD-662] --- src/dnode/inc/dnodeCheck.h | 31 +++++ src/dnode/src/dnodeCheck.c | 275 +++++++++++++++++++++++++++++++++++++ src/dnode/src/dnodeMain.c | 3 + src/inc/taosdef.h | 13 ++ 4 files changed, 322 insertions(+) create mode 100644 src/dnode/inc/dnodeCheck.h create mode 100644 src/dnode/src/dnodeCheck.c diff --git a/src/dnode/inc/dnodeCheck.h b/src/dnode/inc/dnodeCheck.h new file mode 100644 index 0000000000..73f6423134 --- /dev/null +++ b/src/dnode/inc/dnodeCheck.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * 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 . + */ + +#ifndef TDENGINE_DNODE_CHECK_H +#define TDENGINE_DNODE_CHECK_H + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t dnodeInitCheck(); +void dnodeStartCheck(); +void dnodeCleanupCheck(); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/dnode/src/dnodeCheck.c b/src/dnode/src/dnodeCheck.c new file mode 100644 index 0000000000..ce03fd093b --- /dev/null +++ b/src/dnode/src/dnodeCheck.c @@ -0,0 +1,275 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * 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 . + */ + +#define _DEFAULT_SOURCE +#include +#include +#include +#include +#include + +#include "os.h" +#include "taosdef.h" +#include "tglobal.h" +#include "mnode.h" +#include "dnodeInt.h" +#include "dnodeCheck.h" + +typedef struct { + bool enable; + char * name; + int32_t (*initFp)(); + int32_t (*startFp)(); + void (*cleanUpFp)(); + void (*stopFp)(); +} SCheckItem; + +static SCheckItem tsCheckItem[TSDB_CHECK_ITEM_MAX] = {{0}}; +int64_t tsMinFreeMemSizeForStart = 0; + +static int bindTcpPort(int port) { + int serverSocket; + struct sockaddr_in server_addr; + + if ((serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { + dError("socket() fail: %s", strerror(errno)); + return -1; + } + + bzero(&server_addr, sizeof(server_addr)); + server_addr.sin_family = AF_INET; + server_addr.sin_port = htons(port); + server_addr.sin_addr.s_addr = htonl(INADDR_ANY); + + if (bind(serverSocket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) { + dError("port:%d tcp bind() fail: %s", port, strerror(errno)); + close(serverSocket); + return -1; + } + + + if (listen(serverSocket, 5) < 0) { + dError("port:%d listen() fail: %s", port, strerror(errno)); + close(serverSocket); + return -1; + } + + close(serverSocket); + return 0; +} + +static int bindUdpPort(int port) { + int serverSocket; + struct sockaddr_in server_addr; + + if ((serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { + dError("socket() fail: %s", strerror(errno)); + return -1; + } + + bzero(&server_addr, sizeof(server_addr)); + server_addr.sin_family = AF_INET; + server_addr.sin_port = htons(port); + server_addr.sin_addr.s_addr = htonl(INADDR_ANY); + + if (bind(serverSocket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) { + dError("port:%d udp bind() fail: %s", port, strerror(errno)); + close(serverSocket); + return -1; + } + + close(serverSocket); + return 0; +} + +static int dnodeCheckNetwork() { + int ret; + int startPort = tsServerPort; + + for (int port = startPort; port < startPort + 12; port++) { + ret = bindTcpPort(port); + if (0 != ret) { + return -1; + } + ret = bindUdpPort(port); + if (0 != ret) { + return -1; + } + } + + return 0; +} + +static int dnodeCheckMem() { + float memoryUsedMB; + float memoryAvailMB; + if (true != taosGetSysMemory(&memoryUsedMB)) { + dError("failed to get system mem infomation, errno:%u, reason:%s", errno, strerror(errno)); + return -1; + } + + memoryAvailMB = (float)tsTotalMemoryMB - memoryUsedMB; + + if (memoryAvailMB < tsMinFreeMemSizeForStart) { + dError("free mem %f too little, quit", memoryAvailMB); + return -1; + } + + return 0; +} + +static int dnodeCheckCpu() { + // TODO: + return 0; +} + +static int dnodeCheckDisk() { + if (tsAvailDataDirGB < tsMinimalDataDirGB) { + dError("free disk size: %f GB, too little, quit", tsAvailDataDirGB); + return -1; + } + + if (tsAvailLogDirGB < tsMinimalLogDirGB) { + dError("free disk size: %f GB, too little, quit", tsAvailLogDirGB); + return -1; + } + + if (tsAvailTmpDirectorySpace < tsReservedTmpDirectorySpace) { + dError("free disk size: %f GB, too little, quit", tsAvailTmpDirectorySpace); + return -1; + } + + return 0; +} + +static int dnodeCheckOs() { + // TODO: + + return 0; +} +static int dnodeCheckAccess() { + // TODO: + + return 0; +} + +static int dnodeCheckVersion() { + // TODO: + + return 0; +} + +static int dnodeCheckDatafile() { + // TODO: + + return 0; +} + +static void dnodeAllocCheckItem() { + tsCheckItem[TSDB_CHECK_ITEM_NETWORK].enable = true; + tsCheckItem[TSDB_CHECK_ITEM_NETWORK].name = "network"; + tsCheckItem[TSDB_CHECK_ITEM_NETWORK].initFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_NETWORK].cleanUpFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_NETWORK].startFp = dnodeCheckNetwork; + tsCheckItem[TSDB_CHECK_ITEM_NETWORK].stopFp = NULL; + + tsCheckItem[TSDB_CHECK_ITEM_MEM].enable = true; + tsCheckItem[TSDB_CHECK_ITEM_MEM].name = "mem"; + tsCheckItem[TSDB_CHECK_ITEM_MEM].initFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_MEM].cleanUpFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_MEM].startFp = dnodeCheckMem; + tsCheckItem[TSDB_CHECK_ITEM_MEM].stopFp = NULL; + + tsCheckItem[TSDB_CHECK_ITEM_CPU].enable = true; + tsCheckItem[TSDB_CHECK_ITEM_CPU].name = "cpu"; + tsCheckItem[TSDB_CHECK_ITEM_CPU].initFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_CPU].cleanUpFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_CPU].startFp = dnodeCheckCpu; + tsCheckItem[TSDB_CHECK_ITEM_CPU].stopFp = NULL; + + tsCheckItem[TSDB_CHECK_ITEM_DISK].enable = true; + tsCheckItem[TSDB_CHECK_ITEM_DISK].name = "disk"; + tsCheckItem[TSDB_CHECK_ITEM_DISK].initFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_DISK].cleanUpFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_DISK].startFp = dnodeCheckDisk; + tsCheckItem[TSDB_CHECK_ITEM_DISK].stopFp = NULL; + + tsCheckItem[TSDB_CHECK_ITEM_OS].enable = true; + tsCheckItem[TSDB_CHECK_ITEM_OS].name = "os"; + tsCheckItem[TSDB_CHECK_ITEM_OS].initFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_OS].cleanUpFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_OS].startFp = dnodeCheckOs; + tsCheckItem[TSDB_CHECK_ITEM_OS].stopFp = NULL; + + tsCheckItem[TSDB_CHECK_ITEM_ACCESS].enable = true; + tsCheckItem[TSDB_CHECK_ITEM_ACCESS].name = "access"; + tsCheckItem[TSDB_CHECK_ITEM_ACCESS].initFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_ACCESS].cleanUpFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_ACCESS].startFp = dnodeCheckAccess; + tsCheckItem[TSDB_CHECK_ITEM_ACCESS].stopFp = NULL; + + tsCheckItem[TSDB_CHECK_ITEM_VERSION].enable = true; + tsCheckItem[TSDB_CHECK_ITEM_VERSION].name = "version"; + tsCheckItem[TSDB_CHECK_ITEM_VERSION].initFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_VERSION].cleanUpFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_VERSION].startFp = dnodeCheckVersion; + tsCheckItem[TSDB_CHECK_ITEM_VERSION].stopFp = NULL; + + tsCheckItem[TSDB_CHECK_ITEM_DATAFILE].enable = true; + tsCheckItem[TSDB_CHECK_ITEM_DATAFILE].name = "datafile"; + tsCheckItem[TSDB_CHECK_ITEM_DATAFILE].initFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_DATAFILE].cleanUpFp = NULL; + tsCheckItem[TSDB_CHECK_ITEM_DATAFILE].startFp = dnodeCheckDatafile; + tsCheckItem[TSDB_CHECK_ITEM_DATAFILE].stopFp = NULL; +} + +void dnodeCleanupCheck() { + for (ECheckItemType index = 0; index < TSDB_CHECK_ITEM_MAX; ++index) { + if (tsCheckItem[index].enable && tsCheckItem[index].stopFp) { + (*tsCheckItem[index].stopFp)(); + } + if (tsCheckItem[index].cleanUpFp) { + (*tsCheckItem[index].cleanUpFp)(); + } + } +} + +int32_t dnodeInitCheck() { + dnodeAllocCheckItem(); + + for (ECheckItemType index = 0; index < TSDB_CHECK_ITEM_MAX; ++index) { + if (tsCheckItem[index].initFp) { + if ((*tsCheckItem[index].initFp)() != 0) { + dError("failed to init check item:%s", tsCheckItem[index].name); + return -1; + } + } + } + + return 0; +} + +void dnodeStartCheck() { + for (ECheckItemType index = 0; index < TSDB_CHECK_ITEM_MAX; ++index) { + if (tsCheckItem[index].enable && tsCheckItem[index].startFp) { + if ((*tsCheckItem[index].startFp)() != 0) { + dError("failed to check item:%s", tsCheckItem[index].name); + exit(-1); + } + } + } +} + + diff --git a/src/dnode/src/dnodeMain.c b/src/dnode/src/dnodeMain.c index 96f8f43265..9d22493485 100644 --- a/src/dnode/src/dnodeMain.c +++ b/src/dnode/src/dnodeMain.c @@ -24,6 +24,7 @@ #include "dnodeMgmt.h" #include "dnodePeer.h" #include "dnodeModule.h" +#include "dnodeCheck.h" #include "dnodeVRead.h" #include "dnodeVWrite.h" #include "dnodeMRead.h" @@ -61,6 +62,7 @@ static const SDnodeComponent tsDnodeComponents[] = { {"mgmt-tmr", dnodeInitMgmtTimer, dnodeCleanupMgmtTimer}, {"shell", dnodeInitShell, dnodeCleanupShell}, {"telemetry", dnodeInitTelemetry, dnodeCleanupTelemetry}, + {"check", dnodeInitCheck, dnodeCleanupCheck}, }; static int dnodeCreateDir(const char *dir) { @@ -123,6 +125,7 @@ int32_t dnodeInitSystem() { return -1; } + dnodeStartCheck(); dnodeStartModules(); dnodeSetRunStatus(TSDB_DNODE_RUN_STATUS_RUNING); diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h index ff05c840da..accdef0d47 100644 --- a/src/inc/taosdef.h +++ b/src/inc/taosdef.h @@ -416,6 +416,19 @@ typedef enum { TSDB_MOD_MAX } EModuleType; + typedef enum { + TSDB_CHECK_ITEM_NETWORK, + TSDB_CHECK_ITEM_MEM, + TSDB_CHECK_ITEM_CPU, + TSDB_CHECK_ITEM_DISK, + TSDB_CHECK_ITEM_OS, + TSDB_CHECK_ITEM_ACCESS, + TSDB_CHECK_ITEM_VERSION, + TSDB_CHECK_ITEM_DATAFILE, + TSDB_CHECK_ITEM_MAX + } ECheckItemType; + + #ifdef __cplusplus } #endif -- GitLab