xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge pull request #4401 from taosdata/revert-4389-feature/TD-1843 

Revert "return mnode initialization stage to client"
This commit is contained in:
Shengliang Guan 2020-12-02 09:29:52 +08:00 committed by GitHub
parent 70266acff8 6517eaf048
commit c633e91bf4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 41 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/dnode/src/dnodeMPeer.c
View File

@ -122,16 +122,11 @@ void dnodeFreeMPeerQueue() {
}
void dnodeDispatchToMPeerQueue(SRpcMsg *pMsg) {
if (!mnodeIsRunning()) {
if (!mnodeIsRunning() || tsMPeerQueue == NULL) {
dnodeSendRedirectMsg(pMsg, false);
} else {
if (!mnodeIsReady()) {
SRpcMsg rpcRsp = {.handle = pMsg->handle, .code = mnodeInitCode(), .pCont = NULL};
rpcSendResponse(&rpcRsp);
} else {
SMnodeMsg *pPeer = mnodeCreateMsg(pMsg);
taosWriteQitem(tsMPeerQueue, TAOS_QTYPE_RPC, pPeer);
}
SMnodeMsg *pPeer = mnodeCreateMsg(pMsg);
taosWriteQitem(tsMPeerQueue, TAOS_QTYPE_RPC, pPeer);
}
rpcFreeCont(pMsg->pCont);

11
src/dnode/src/dnodeMRead.c
View File

@ -123,16 +123,11 @@ void dnodeFreeMReadQueue() {
}
void dnodeDispatchToMReadQueue(SRpcMsg *pMsg) {
if (!mnodeIsRunning()) {
if (!mnodeIsRunning() || tsMReadQueue == NULL) {
dnodeSendRedirectMsg(pMsg, true);
} else {
if (!mnodeIsReady()) {
SRpcMsg rpcRsp = {.handle = pMsg->handle, .code = mnodeInitCode(), .pCont = NULL};
rpcSendResponse(&rpcRsp);
} else {
SMnodeMsg *pRead = mnodeCreateMsg(pMsg);
taosWriteQitem(tsMReadQueue, TAOS_QTYPE_RPC, pRead);
}
SMnodeMsg *pRead = mnodeCreateMsg(pMsg);
taosWriteQitem(tsMReadQueue, TAOS_QTYPE_RPC, pRead);
}
rpcFreeCont(pMsg->pCont);

18
src/dnode/src/dnodeMWrite.c
View File

@ -123,18 +123,13 @@ void dnodeFreeMWritequeue() {
}
void dnodeDispatchToMWriteQueue(SRpcMsg *pMsg) {
if (!mnodeIsRunning()) {
if (!mnodeIsRunning() || tsMWriteQueue == NULL) {
dnodeSendRedirectMsg(pMsg, true);
} else {
if (!mnodeIsReady()) {
SRpcMsg rpcRsp = {.handle = pMsg->handle, .code = mnodeInitCode(), .pCont = NULL};
rpcSendResponse(&rpcRsp);
} else {
SMnodeMsg *pWrite = mnodeCreateMsg(pMsg);
dDebug("msg:%p, app:%p type:%s is put into mwrite queue:%p", pWrite, pWrite->rpcMsg.ahandle,
taosMsg[pWrite->rpcMsg.msgType], tsMWriteQueue);
taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite);
}
SMnodeMsg *pWrite = mnodeCreateMsg(pMsg);
dDebug("msg:%p, app:%p type:%s is put into mwrite queue:%p", pWrite, pWrite->rpcMsg.ahandle,
taosMsg[pWrite->rpcMsg.msgType], tsMWriteQueue);
taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite);
}
rpcFreeCont(pMsg->pCont);
@ -192,7 +187,7 @@ static void *dnodeProcessMWriteQueue(void *param) {
void dnodeReprocessMWriteMsg(void *pMsg) {
SMnodeMsg *pWrite = pMsg;
if (!mnodeIsRunning()) {
if (!mnodeIsRunning() || tsMWriteQueue == NULL) {
dDebug("msg:%p, app:%p type:%s is redirected for mnode not running, retry times:%d", pWrite, pWrite->rpcMsg.ahandle,
taosMsg[pWrite->rpcMsg.msgType], pWrite->retry);
@ -201,6 +196,7 @@ void dnodeReprocessMWriteMsg(void *pMsg) {
} else {
dDebug("msg:%p, app:%p type:%s is reput into mwrite queue:%p, retry times:%d", pWrite, pWrite->rpcMsg.ahandle,
taosMsg[pWrite->rpcMsg.msgType], tsMWriteQueue, pWrite->retry);
taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite);
}
}

2
src/dnode/src/dnodeMain.c
View File

@ -63,7 +63,6 @@ static const SDnodeComponent tsDnodeComponents[] = {
{"dnodeeps", dnodeInitEps, dnodeCleanupEps},
{"globalcfg" ,taosCheckGlobalCfg, NULL},
{"mnodeinfos",dnodeInitMInfos, dnodeCleanupMInfos},
{"shell", dnodeInitShell, dnodeCleanupShell},
{"wal", walInit, walCleanUp},
{"check", dnodeInitCheck, dnodeCleanupCheck}, // NOTES: dnodeInitCheck must be behind the dnodeinitStorage component !!!
{"vread", dnodeInitVRead, dnodeCleanupVRead},
@ -76,6 +75,7 @@ static const SDnodeComponent tsDnodeComponents[] = {
{"mgmt", dnodeInitMgmt, dnodeCleanupMgmt},
{"modules", dnodeInitModules, dnodeCleanupModules},
{"mgmt-tmr", dnodeInitMgmtTimer, dnodeCleanupMgmtTimer},
{"shell", dnodeInitShell, dnodeCleanupShell},
{"telemetry", dnodeInitTelemetry, dnodeCleanupTelemetry},
};

2
src/dnode/src/dnodeShell.c
View File

@ -144,7 +144,7 @@ static void dnodeProcessMsgFromShell(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
static int dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
int code = mnodeRetriveAuth(user, spi, encrypt, secret, ckey);
if (code != TSDB_CODE_RPC_REDIRECT) return code;
if (code != TSDB_CODE_APP_NOT_READY) return code;
SAuthMsg *pMsg = rpcMallocCont(sizeof(SAuthMsg));
tstrncpy(pMsg->user, user, sizeof(pMsg->user));

3
src/inc/mnode.h
View File

@ -65,15 +65,12 @@ void mnodeStopSystem();
void sdbUpdateAsync();
void sdbUpdateSync(void *pMnodes);
bool mnodeIsRunning();
bool mnodeIsReady();
int32_t mnodeInitCode();
int32_t mnodeProcessRead(SMnodeMsg *pMsg);
int32_t mnodeProcessWrite(SMnodeMsg *pMsg);
int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg);
void mnodeProcessPeerRsp(SRpcMsg *pMsg);
int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey);
#ifdef __cplusplus
}
#endif

3
src/inc/taoserror.h
View File

@ -125,9 +125,6 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_SHOWOBJ, 0, 0x030B, "Data expir
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_QUERY_ID, 0, 0x030C, "Invalid query id")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STREAM_ID, 0, 0x030D, "Invalid stream id")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CONN_ID, 0, 0x030E, "Invalid connection id")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INIT, 0, 0x030F, "Mnode is initializing")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INIT_SDB, 0, 0x0310, "Mnode is initializing meta data, it takes a while if many tables exists")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INIT_OTHER, 0, 0x0311, "Mnode is initializing other data")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_SDB_OBJ_ALREADY_THERE, 0, 0x0320, "Object already there")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_SDB_ERROR, 0, 0x0321, "Unexpected generic error in sdb")

80
src/mnode/src/mnodeMain.c
View File

@ -17,7 +17,6 @@
#include "os.h"
#include "taosdef.h"
#include "tsched.h"
#include "taoserror.h"
#include "tbalance.h"
#include "tgrant.h"
#include "ttimer.h"
@ -38,41 +37,30 @@
#include "mnodeShow.h"
#include "mnodeProfile.h"
typedef enum {
TSDB_MND_STATUS_NOT_RUNNING,
TSDB_MND_STATUS_INIT,
TSDB_MND_STATUS_INIT_SDB,
TSDB_MND_STATUS_INIT_OTHER,
TSDB_MND_STATUS_READY,
TSDB_MND_STATUS_CLEANING,
} EMndStatus;
typedef struct {
const char *const name;
int (*init)();
void (*cleanup)();
EMndStatus status;
} SMnodeComponent;
void *tsMnodeTmr = NULL;
static bool tsMgmtIsRunning = false;
static EMndStatus tsMgmtStatus = TSDB_MND_STATUS_NOT_RUNNING;
void *tsMnodeTmr = NULL;
static bool tsMgmtIsRunning = false;
static const SMnodeComponent tsMnodeComponents[] = {
{"sdbref", sdbInitRef, sdbCleanUpRef, TSDB_MND_STATUS_INIT},
{"profile", mnodeInitProfile, mnodeCleanupProfile, TSDB_MND_STATUS_INIT},
{"cluster", mnodeInitCluster, mnodeCleanupCluster, TSDB_MND_STATUS_INIT},
{"accts", mnodeInitAccts, mnodeCleanupAccts, TSDB_MND_STATUS_INIT},
{"users", mnodeInitUsers, mnodeCleanupUsers, TSDB_MND_STATUS_INIT},
{"dnodes", mnodeInitDnodes, mnodeCleanupDnodes, TSDB_MND_STATUS_INIT},
{"dbs", mnodeInitDbs, mnodeCleanupDbs, TSDB_MND_STATUS_INIT},
{"vgroups", mnodeInitVgroups, mnodeCleanupVgroups, TSDB_MND_STATUS_INIT},
{"tables", mnodeInitTables, mnodeCleanupTables, TSDB_MND_STATUS_INIT},
{"mnodes", mnodeInitMnodes, mnodeCleanupMnodes, TSDB_MND_STATUS_INIT},
{"sdb", sdbInit, sdbCleanUp, TSDB_MND_STATUS_INIT_SDB},
{"balance", balanceInit, balanceCleanUp, TSDB_MND_STATUS_INIT_OTHER},
{"grant", grantInit, grantCleanUp, TSDB_MND_STATUS_INIT_OTHER},
{"show", mnodeInitShow, mnodeCleanUpShow, TSDB_MND_STATUS_INIT_OTHER},
{"sdbref", sdbInitRef, sdbCleanUpRef},
{"profile", mnodeInitProfile, mnodeCleanupProfile},
{"cluster", mnodeInitCluster, mnodeCleanupCluster},
{"accts", mnodeInitAccts, mnodeCleanupAccts},
{"users", mnodeInitUsers, mnodeCleanupUsers},
{"dnodes", mnodeInitDnodes, mnodeCleanupDnodes},
{"dbs", mnodeInitDbs, mnodeCleanupDbs},
{"vgroups", mnodeInitVgroups, mnodeCleanupVgroups},
{"tables", mnodeInitTables, mnodeCleanupTables},
{"mnodes", mnodeInitMnodes, mnodeCleanupMnodes},
{"sdb", sdbInit, sdbCleanUp},
{"balance", balanceInit, balanceCleanUp},
{"grant", grantInit, grantCleanUp},
{"show", mnodeInitShow, mnodeCleanUpShow}
};
static void mnodeInitTimer();
@ -88,24 +76,21 @@ static void mnodeCleanupComponents(int32_t stepId) {
static int32_t mnodeInitComponents() {
int32_t code = 0;
for (int32_t i = 0; i < sizeof(tsMnodeComponents) / sizeof(tsMnodeComponents[0]); i++) {
tsMgmtStatus = tsMnodeComponents[i].status;
if (tsMnodeComponents[i].init() != 0) {
mnodeCleanupComponents(i);
code = -1;
break;
}
// sleep(3);
}
return code;
}
int32_t mnodeStartSystem() {
if (tsMgmtStatus != TSDB_MND_STATUS_NOT_RUNNING) {
if (tsMgmtIsRunning) {
mInfo("mnode module already started...");
return 0;
}
tsMgmtStatus = TSDB_MND_STATUS_INIT;
mInfo("starting to initialize mnode ...");
if (mkdir(tsMnodeDir, 0755) != 0 && errno != EEXIST) {
mError("failed to init mnode dir:%s, reason:%s", tsMnodeDir, strerror(errno));
@ -121,7 +106,7 @@ int32_t mnodeStartSystem() {
}
grantReset(TSDB_GRANT_ALL, 0);
tsMgmtStatus = TSDB_MND_STATUS_READY;
tsMgmtIsRunning = true;
mInfo("mnode is initialized successfully");
@ -141,7 +126,7 @@ int32_t mnodeInitSystem() {
void mnodeCleanupSystem() {
if (tsMgmtIsRunning) {
mInfo("starting to clean up mnode");
tsMgmtStatus = TSDB_MND_STATUS_CLEANING;
tsMgmtIsRunning = false;
dnodeFreeMWritequeue();
dnodeFreeMReadQueue();
@ -149,7 +134,6 @@ void mnodeCleanupSystem() {
mnodeCleanupTimer();
mnodeCleanupComponents(sizeof(tsMnodeComponents) / sizeof(tsMnodeComponents[0]) - 1);
tsMgmtStatus = TSDB_MND_STATUS_NOT_RUNNING;
mInfo("mnode is cleaned up");
}
}
@ -200,29 +184,5 @@ static bool mnodeNeedStart() {
}
bool mnodeIsRunning() {
return (tsMgmtStatus != TSDB_MND_STATUS_NOT_RUNNING && tsMgmtStatus != TSDB_MND_STATUS_CLEANING);
}
bool mnodeIsReady() {
return (tsMgmtStatus == TSDB_MND_STATUS_READY);
}
int32_t mnodeInitCode() {
int32_t code = -1;
switch (tsMgmtStatus) {
case TSDB_MND_STATUS_INIT:
code = TSDB_CODE_MND_INIT;
break;
case TSDB_MND_STATUS_INIT_SDB:
code = TSDB_CODE_MND_INIT_SDB;
break;
case TSDB_MND_STATUS_INIT_OTHER:
code = TSDB_CODE_MND_INIT_OTHER;
break;
default:
code = TSDB_CODE_MND_INIT;
}
return code;
return tsMgmtIsRunning;
}

2
src/mnode/src/mnodeSdb.c
View File

@ -309,7 +309,7 @@ void sdbUpdateAsync() {
void sdbUpdateSync(void *pMnodes) {
SMnodeInfos *mnodes = pMnodes;
if (!mnodeIsReady()) {
if (!mnodeIsRunning()) {
mDebug("vgId:1, mnode not start yet, update sync config later");
return;
}

15
src/mnode/src/mnodeUser.c
View File

@ -585,21 +585,10 @@ void mnodeDropAllUsers(SAcctObj *pAcct) {
}
int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
*secret = 0;
if (!mnodeIsRunning()) {
mDebug("user:%s, mnode is not running, fail to auth", user);
return TSDB_CODE_RPC_REDIRECT;
}
if (!mnodeIsReady()) {
mDebug("user:%s, failed to auth user, mnode is not ready", user);
return mnodeInitCode();
}
if (!sdbIsMaster()) {
*secret = 0;
mDebug("user:%s, failed to auth user, mnode is not master", user);
return TSDB_CODE_RPC_REDIRECT;
return TSDB_CODE_APP_NOT_READY;
}
SUserObj *pUser = mnodeGetUser(user);

5
src/rpc/src/rpcMain.c
View File

@ -1559,9 +1559,10 @@ static int rpcCheckAuthentication(SRpcConn *pConn, char *msg, int msgLen) {
if ( !rpcIsReq(pHead->msgType) ) {
// for response, if code is auth failure, it shall bypass the auth process
code = htonl(pHead->code);
if (code != 0) {
// tTrace("%s, dont check authentication since code is:0x%x", pConn->info, code);
if (code == TSDB_CODE_RPC_INVALID_TIME_STAMP || code == TSDB_CODE_RPC_AUTH_FAILURE ||
code == TSDB_CODE_RPC_AUTH_REQUIRED || code == TSDB_CODE_MND_INVALID_USER || code == TSDB_CODE_RPC_NOT_READY) {
pHead->msgLen = (int32_t)htonl((uint32_t)pHead->msgLen);
// tTrace("%s, dont check authentication since code is:0x%x", pConn->info, code);
return 0;
}
}