Skip to content

T
TDengine

taosdata / TDengine
大约 2 年 前同步成功

通知 1192
Star 22018
Fork 4786
T
TDengine
“524283386c30fa64509f14902a0a32a088a289b3”上不存在“docs/en/10-programming/06-connector/04-rust.md”
提交 b8fc28fb 编写于 作者: H hjxilinx
浏览文件
操作

Merge branch '2.0' into liaohj_2

上级 9eae52e1 7afea209
显示空白变更内容
内联 并排
Showing with 1315 addition and 982 deletion
src/client/inc/tsclient.h
浏览文件 @ b8fc28fb
...@@ -380,7 +380,7 @@ int tsParseSql(SSqlObj *pSql, bool multiVnodeInsertion); ...@@ -380,7 +380,7 @@ int tsParseSql(SSqlObj *pSql, bool multiVnodeInsertion);
void tscInitMsgs(); void tscInitMsgs();
extern int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo); extern int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo);
void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, int32_t code); void tscProcessMsgFromServer(SRpcMsg *rpcMsg);
int tscProcessSql(SSqlObj *pSql); int tscProcessSql(SSqlObj *pSql);
void tscAsyncInsertMultiVnodesProxy(void *param, TAOS_RES *tres, int numOfRows); void tscAsyncInsertMultiVnodesProxy(void *param, TAOS_RES *tres, int numOfRows);
......
src/client/src/tscAsync.c
浏览文件 @ b8fc28fb
...@@ -324,7 +324,6 @@ void tscProcessFetchRow(SSchedMsg *pMsg) { ...@@ -324,7 +324,6 @@ void tscProcessFetchRow(SSchedMsg *pMsg) {
void tscProcessAsyncRes(SSchedMsg *pMsg) { void tscProcessAsyncRes(SSchedMsg *pMsg) {
SSqlObj *pSql = (SSqlObj *)pMsg->ahandle; SSqlObj *pSql = (SSqlObj *)pMsg->ahandle;
STscObj *pTscObj = pSql->pTscObj;
SSqlCmd *pCmd = &pSql->cmd; SSqlCmd *pCmd = &pSql->cmd;
SSqlRes *pRes = &pSql->res; SSqlRes *pRes = &pSql->res;
......
src/client/src/tscServer.c
浏览文件 @ b8fc28fb
...@@ -98,6 +98,7 @@ void tscSetMgmtIpList(SRpcIpSet *pIpList) { ...@@ -98,6 +98,7 @@ void tscSetMgmtIpList(SRpcIpSet *pIpList) {
* The retry will not be executed since only *two* retry is allowed in case of single management node in the cluster. * The retry will not be executed since only *two* retry is allowed in case of single management node in the cluster.
* Therefore, we need to multiply the retry times by factor of 2 to fix this problem. * Therefore, we need to multiply the retry times by factor of 2 to fix this problem.
*/ */
UNUSED_FUNC
static int32_t tscGetMgmtConnMaxRetryTimes() { static int32_t tscGetMgmtConnMaxRetryTimes() {
int32_t factor = 2; int32_t factor = 2;
return tscMgmtIpList.numOfIps * factor; return tscMgmtIpList.numOfIps * factor;
...@@ -188,23 +189,34 @@ int tscSendMsgToServer(SSqlObj *pSql) { ...@@ -188,23 +189,34 @@ int tscSendMsgToServer(SSqlObj *pSql) {
tscPrint("%p msg:%s is sent to server %d", pSql, taosMsg[pSql->cmd.msgType], pSql->ipList->port); tscPrint("%p msg:%s is sent to server %d", pSql, taosMsg[pSql->cmd.msgType], pSql->ipList->port);
memcpy(pMsg, pSql->cmd.payload + tsRpcHeadSize, pSql->cmd.payloadLen); memcpy(pMsg, pSql->cmd.payload + tsRpcHeadSize, pSql->cmd.payloadLen);
SRpcMsg msg = {.msgType = pCmd->msgType, .contLen = pCmd->payloadLen, .pCont = pMsg, .handle = pSql}; SRpcMsg rpcMsg = {
rpcSendRequest(pVnodeConn, pSql->ipList, &msg); .msgType = pSql->cmd.msgType,
.pCont = pMsg,
.contLen = pSql->cmd.payloadLen,
.handle = pSql,
.code = 0
};
rpcSendRequest(pVnodeConn, pSql->ipList, &rpcMsg);
} else { } else {
pSql->ipList->port = tsMgmtShellPort; pSql->ipList->port = tsMgmtShellPort;
tscPrint("%p msg:%s is sent to server %d", pSql, taosMsg[pSql->cmd.msgType], pSql->ipList->port); tscPrint("%p msg:%s is sent to server %d", pSql, taosMsg[pSql->cmd.msgType], pSql->ipList->port);
memcpy(pMsg, pSql->cmd.payload, pSql->cmd.payloadLen); memcpy(pMsg, pSql->cmd.payload, pSql->cmd.payloadLen);
SRpcMsg rpcMsg = {
SRpcMsg msg = {.msgType = pCmd->msgType, .contLen = pCmd->payloadLen, .pCont = pMsg, .handle = pSql}; .msgType = pSql->cmd.msgType,
rpcSendRequest(pTscMgmtConn, pSql->ipList, &msg); .pCont = pMsg,
.contLen = pSql->cmd.payloadLen,
.handle = pSql,
.code = 0
};
rpcSendRequest(pTscMgmtConn, pSql->ipList, &rpcMsg);
} }
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, int32_t code) { void tscProcessMsgFromServer(SRpcMsg *rpcMsg) {
tscPrint("response:%s is received, len:%d error:%s", taosMsg[(uint8_t)type], contLen, tstrerror(code)); tscPrint("response:%s is received, len:%d error:%s", taosMsg[rpcMsg->msgType], rpcMsg->contLen, tstrerror(rpcMsg->code));
SSqlObj *pSql = (SSqlObj *)ahandle; SSqlObj *pSql = (SSqlObj *)rpcMsg->handle;
if (pSql == NULL || pSql->signature != pSql) { if (pSql == NULL || pSql->signature != pSql) {
tscError("%p sql is already released, signature:%p", pSql, pSql->signature); tscError("%p sql is already released, signature:%p", pSql, pSql->signature);
return; return;
...@@ -213,24 +225,24 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, ...@@ -213,24 +225,24 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle,
SSqlRes *pRes = &pSql->res; SSqlRes *pRes = &pSql->res;
SSqlCmd *pCmd = &pSql->cmd; SSqlCmd *pCmd = &pSql->cmd;
STscObj *pObj = pSql->pTscObj; STscObj *pObj = pSql->pTscObj;
tscTrace("%p msg:%p is received from server", pSql, pCont); tscTrace("%p msg:%p is received from server", pSql, rpcMsg->pCont);
if (pSql->freed || pObj->signature != pObj) { if (pSql->freed || pObj->signature != pObj) {
tscTrace("%p sql is already released or DB connection is closed, freed:%d pObj:%p signature:%p", pSql, pSql->freed, tscTrace("%p sql is already released or DB connection is closed, freed:%d pObj:%p signature:%p", pSql, pSql->freed,
pObj, pObj->signature); pObj, pObj->signature);
tscFreeSqlObj(pSql); tscFreeSqlObj(pSql);
rpcFreeCont(pCont); rpcFreeCont(rpcMsg->pCont);
return; return;
} }
if (pCont == NULL) { if (rpcMsg->pCont == NULL) {
code = TSDB_CODE_NETWORK_UNAVAIL; rpcMsg->code = TSDB_CODE_NETWORK_UNAVAIL;
} else { } else {
SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0); SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
if (code == TSDB_CODE_NOT_ACTIVE_TABLE || code == TSDB_CODE_INVALID_TABLE_ID || if (rpcMsg->code == TSDB_CODE_NOT_ACTIVE_TABLE || rpcMsg->code == TSDB_CODE_INVALID_TABLE_ID ||
code == TSDB_CODE_INVALID_VNODE_ID || code == TSDB_CODE_NOT_ACTIVE_VNODE || rpcMsg->code == TSDB_CODE_INVALID_VNODE_ID || rpcMsg->code == TSDB_CODE_NOT_ACTIVE_VNODE ||
code == TSDB_CODE_NETWORK_UNAVAIL || code == TSDB_CODE_NOT_ACTIVE_SESSION || rpcMsg->code == TSDB_CODE_NETWORK_UNAVAIL || rpcMsg->code == TSDB_CODE_NOT_ACTIVE_SESSION ||
code == TSDB_CODE_TABLE_ID_MISMATCH) { rpcMsg->code == TSDB_CODE_TABLE_ID_MISMATCH) {
/* /*
* not_active_table: 1. the virtual node may fail to create table, since the procedure of create table is asynchronized, * not_active_table: 1. the virtual node may fail to create table, since the procedure of create table is asynchronized,
* the virtual node may have not create table till now, so try again by using the new metermeta. * the virtual node may have not create table till now, so try again by using the new metermeta.
...@@ -242,24 +254,24 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, ...@@ -242,24 +254,24 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle,
* not_active_session: db has been move to other node, the vnode does not exist on this dnode anymore. * not_active_session: db has been move to other node, the vnode does not exist on this dnode anymore.
*/ */
if (pCmd->command == TSDB_SQL_CONNECT) { if (pCmd->command == TSDB_SQL_CONNECT) {
code = TSDB_CODE_NETWORK_UNAVAIL; rpcMsg->code = TSDB_CODE_NETWORK_UNAVAIL;
rpcFreeCont(pCont); rpcFreeCont(rpcMsg->pCont);
return; return;
} else if (pCmd->command == TSDB_SQL_HB) { } else if (pCmd->command == TSDB_SQL_HB) {
code = TSDB_CODE_NOT_READY; rpcMsg->code = TSDB_CODE_NOT_READY;
rpcFreeCont(pCont); rpcFreeCont(rpcMsg->pCont);
return; return;
} else { } else {
tscTrace("%p it shall renew meter meta, code:%d", pSql, code); tscTrace("%p it shall renew meter meta, code:%d", pSql, rpcMsg->code);
pSql->maxRetry = TSDB_VNODES_SUPPORT * 2; pSql->maxRetry = TSDB_VNODES_SUPPORT * 2;
pSql->res.code = (uint8_t) code; // keep the previous error code pSql->res.code = rpcMsg->code; // keep the previous error code
code = tscRenewMeterMeta(pSql, pMeterMetaInfo->name); rpcMsg->code = tscRenewMeterMeta(pSql, pMeterMetaInfo->name);
if (pMeterMetaInfo->pMeterMeta) { if (pMeterMetaInfo->pMeterMeta) {
tscSendMsgToServer(pSql); tscSendMsgToServer(pSql);
rpcFreeCont(pCont); rpcFreeCont(rpcMsg->pCont);
return; return;
} }
} }
...@@ -272,16 +284,16 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, ...@@ -272,16 +284,16 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle,
pRes->rspLen = 0; pRes->rspLen = 0;
if (pRes->code != TSDB_CODE_QUERY_CANCELLED) { if (pRes->code != TSDB_CODE_QUERY_CANCELLED) {
pRes->code = (code != TSDB_CODE_SUCCESS) ? code : TSDB_CODE_NETWORK_UNAVAIL; pRes->code = (rpcMsg->code != TSDB_CODE_SUCCESS) ? rpcMsg->code : TSDB_CODE_NETWORK_UNAVAIL;
} else { } else {
tscTrace("%p query is cancelled, code:%d", pSql, pRes->code); tscTrace("%p query is cancelled, code:%d", pSql, pRes->code);
} }
if (pRes->code != TSDB_CODE_QUERY_CANCELLED) { if (pRes->code != TSDB_CODE_QUERY_CANCELLED) {
assert(type == pCmd->msgType + 1); assert(rpcMsg->msgType == pCmd->msgType + 1);
pRes->code = (int32_t)code; pRes->code = (int32_t)rpcMsg->code;
pRes->rspType = type; pRes->rspType = rpcMsg->msgType;
pRes->rspLen = contLen; pRes->rspLen = rpcMsg->contLen;
char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen); char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen);
if (tmp == NULL) { if (tmp == NULL) {
...@@ -289,7 +301,7 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, ...@@ -289,7 +301,7 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle,
} else { } else {
pRes->pRsp = tmp; pRes->pRsp = tmp;
if (pRes->rspLen) { if (pRes->rspLen) {
memcpy(pRes->pRsp, pCont, pRes->rspLen); memcpy(pRes->pRsp, rpcMsg->pCont, pRes->rspLen);
} }
} }
...@@ -302,8 +314,8 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, ...@@ -302,8 +314,8 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle,
* There is not response callback function for submit response. * There is not response callback function for submit response.
* The actual inserted number of points is the first number. * The actual inserted number of points is the first number.
*/ */
if (type == TSDB_MSG_TYPE_SUBMIT_RSP) { if (rpcMsg->msgType == TSDB_MSG_TYPE_SUBMIT_RSP) {
SShellSubmitRspMsg *pMsg = pRes->pRsp; SShellSubmitRspMsg *pMsg = (SShellSubmitRspMsg*)pRes->pRsp;
pMsg->code = htonl(pMsg->code); pMsg->code = htonl(pMsg->code);
pMsg->numOfRows = htonl(pMsg->numOfRows); pMsg->numOfRows = htonl(pMsg->numOfRows);
pMsg->affectedRows = htonl(pMsg->affectedRows); pMsg->affectedRows = htonl(pMsg->affectedRows);
...@@ -322,14 +334,14 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, ...@@ -322,14 +334,14 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle,
tsem_post(&pSql->rspSem); tsem_post(&pSql->rspSem);
} else { } else {
if (pRes->code == TSDB_CODE_SUCCESS && tscProcessMsgRsp[pCmd->command]) if (pRes->code == TSDB_CODE_SUCCESS && tscProcessMsgRsp[pCmd->command])
code = (*tscProcessMsgRsp[pCmd->command])(pSql); rpcMsg->code = (*tscProcessMsgRsp[pCmd->command])(pSql);
if (code != TSDB_CODE_ACTION_IN_PROGRESS) { if (rpcMsg->code != TSDB_CODE_ACTION_IN_PROGRESS) {
int command = pCmd->command; int command = pCmd->command;
void *taosres = tscKeepConn[command] ? pSql : NULL; void *taosres = tscKeepConn[command] ? pSql : NULL;
code = pRes->code ? -pRes->code : pRes->numOfRows; rpcMsg->code = pRes->code ? -pRes->code : pRes->numOfRows;
tscTrace("%p Async SQL result:%d res:%p", pSql, code, taosres); tscTrace("%p Async SQL result:%d res:%p", pSql, rpcMsg->code, taosres);
/* /*
* Whether to free sqlObj or not should be decided before call the user defined function, since this SqlObj * Whether to free sqlObj or not should be decided before call the user defined function, since this SqlObj
...@@ -341,9 +353,9 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, ...@@ -341,9 +353,9 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle,
*/ */
bool shouldFree = tscShouldFreeAsyncSqlObj(pSql); bool shouldFree = tscShouldFreeAsyncSqlObj(pSql);
if (command == TSDB_SQL_INSERT) { // handle multi-vnode insertion situation if (command == TSDB_SQL_INSERT) { // handle multi-vnode insertion situation
(*pSql->fp)(pSql, taosres, code); (*pSql->fp)(pSql, taosres, rpcMsg->code);
} else { } else {
(*pSql->fp)(pSql->param, taosres, code); (*pSql->fp)(pSql->param, taosres, rpcMsg->code);
} }
if (shouldFree) { if (shouldFree) {
...@@ -359,7 +371,7 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, ...@@ -359,7 +371,7 @@ void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle,
} }
} }
rpcFreeCont(pCont); rpcFreeCont(rpcMsg->pCont);
} }
static SSqlObj *tscCreateSqlObjForSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj); static SSqlObj *tscCreateSqlObjForSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj);
...@@ -1212,7 +1224,7 @@ int tscBuildRetrieveMsg(SSqlObj *pSql, SSqlInfo *pInfo) { ...@@ -1212,7 +1224,7 @@ int tscBuildRetrieveMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
pStart = pSql->cmd.payload + tsRpcHeadSize; pStart = pSql->cmd.payload + tsRpcHeadSize;
pMsg = pStart; pMsg = pStart;
SRetrieveTableMsg *pRetrieveMsg = (SShellSubmitMsg *)pMsg; SRetrieveTableMsg *pRetrieveMsg = (SRetrieveTableMsg *)pMsg;
pRetrieveMsg->qhandle = htobe64(pSql->res.qhandle); pRetrieveMsg->qhandle = htobe64(pSql->res.qhandle);
pMsg += sizeof(pSql->res.qhandle); pMsg += sizeof(pSql->res.qhandle);
...@@ -1227,13 +1239,13 @@ int tscBuildRetrieveMsg(SSqlObj *pSql, SSqlInfo *pInfo) { ...@@ -1227,13 +1239,13 @@ int tscBuildRetrieveMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
} }
void tscUpdateVnodeInSubmitMsg(SSqlObj *pSql, char *buf) { void tscUpdateVnodeInSubmitMsg(SSqlObj *pSql, char *buf) {
SShellSubmitMsg *pShellMsg; //SShellSubmitMsg *pShellMsg;
char * pMsg; //char * pMsg;
SMeterMetaInfo * pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, pSql->cmd.clauseIndex, 0); //SMeterMetaInfo * pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, pSql->cmd.clauseIndex, 0);
STableMeta *pMeterMeta = pMeterMetaInfo->pMeterMeta; //STableMeta *pMeterMeta = pMeterMetaInfo->pMeterMeta;
pMsg = buf + tsRpcHeadSize; //pMsg = buf + tsRpcHeadSize;
//TODO set iplist //TODO set iplist
//pShellMsg = (SShellSubmitMsg *)pMsg; //pShellMsg = (SShellSubmitMsg *)pMsg;
...@@ -2005,7 +2017,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) { ...@@ -2005,7 +2017,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
memcpy(pMsg, &pInfo->pCreateTableInfo->usingInfo.tagdata, sizeof(STagData)); memcpy(pMsg, &pInfo->pCreateTableInfo->usingInfo.tagdata, sizeof(STagData));
pMsg += sizeof(STagData); pMsg += sizeof(STagData);
} else { // create (super) table } else { // create (super) table
pSchema = pCreateTableMsg->schema; pSchema = (SSchema *)pCreateTableMsg->schema;
for (int i = 0; i < pCmd->numOfCols + pCmd->count; ++i) { for (int i = 0; i < pCmd->numOfCols + pCmd->count; ++i) {
TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, i); TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, i);
...@@ -2045,7 +2057,7 @@ int tscEstimateAlterTableMsgLength(SSqlCmd *pCmd) { ...@@ -2045,7 +2057,7 @@ int tscEstimateAlterTableMsgLength(SSqlCmd *pCmd) {
int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) { int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
SAlterTableMsg *pAlterTableMsg; SAlterTableMsg *pAlterTableMsg;
char * pMsg, *pStart; char * pMsg;
int msgLen = 0; int msgLen = 0;
int size = 0; int size = 0;
...@@ -2563,7 +2575,6 @@ int tscBuildHeartBeatMsg(SSqlObj *pSql, SSqlInfo *pInfo) { ...@@ -2563,7 +2575,6 @@ int tscBuildHeartBeatMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
int tscProcessMeterMetaRsp(SSqlObj *pSql) { int tscProcessMeterMetaRsp(SSqlObj *pSql) {
STableMeta *pMeta; STableMeta *pMeta;
SSchema * pSchema; SSchema * pSchema;
uint8_t ieType;
pMeta = (STableMeta *)pSql->res.pRsp; pMeta = (STableMeta *)pSql->res.pRsp;
...@@ -2667,7 +2678,7 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) { ...@@ -2667,7 +2678,7 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) {
for (i = 0; i < totalNum; i++) { for (i = 0; i < totalNum; i++) {
SMultiTableMeta *pMultiMeta = (SMultiTableMeta *)rsp; SMultiTableMeta *pMultiMeta = (SMultiTableMeta *)rsp;
STableMeta * pMeta = &pMultiMeta->metas; STableMeta * pMeta = pMultiMeta->metas;
pMeta->sid = htonl(pMeta->sid); pMeta->sid = htonl(pMeta->sid);
pMeta->sversion = htons(pMeta->sversion); pMeta->sversion = htons(pMeta->sversion);
...@@ -3029,7 +3040,7 @@ int tscProcessAlterDbMsgRsp(SSqlObj *pSql) { ...@@ -3029,7 +3040,7 @@ int tscProcessAlterDbMsgRsp(SSqlObj *pSql) {
int tscProcessQueryRsp(SSqlObj *pSql) { int tscProcessQueryRsp(SSqlObj *pSql) {
SSqlRes *pRes = &pSql->res; SSqlRes *pRes = &pSql->res;
SQueryTableRsp *pQuery = (SRetrieveTableRsp *)pRes->pRsp; SQueryTableRsp *pQuery = (SQueryTableRsp *)pRes->pRsp;
pQuery->qhandle = htobe64(pQuery->qhandle); pQuery->qhandle = htobe64(pQuery->qhandle);
pRes->qhandle = pQuery->qhandle; pRes->qhandle = pQuery->qhandle;
...@@ -3041,7 +3052,6 @@ int tscProcessQueryRsp(SSqlObj *pSql) { ...@@ -3041,7 +3052,6 @@ int tscProcessQueryRsp(SSqlObj *pSql) {
int tscProcessRetrieveRspFromVnode(SSqlObj *pSql) { int tscProcessRetrieveRspFromVnode(SSqlObj *pSql) {
SSqlRes *pRes = &pSql->res; SSqlRes *pRes = &pSql->res;
SSqlCmd *pCmd = &pSql->cmd; SSqlCmd *pCmd = &pSql->cmd;
STscObj *pObj = pSql->pTscObj;
SRetrieveTableRsp *pRetrieve = (SRetrieveTableRsp *)pRes->pRsp; SRetrieveTableRsp *pRetrieve = (SRetrieveTableRsp *)pRes->pRsp;
......
src/client/src/tscSystem.c
浏览文件 @ b8fc28fb
...@@ -72,7 +72,7 @@ int32_t tscInitRpc(const char *user, const char *secret) { ...@@ -72,7 +72,7 @@ int32_t tscInitRpc(const char *user, const char *secret) {
rpcInit.cfp = tscProcessMsgFromServer; rpcInit.cfp = tscProcessMsgFromServer;
rpcInit.sessions = tsMaxVnodeConnections; rpcInit.sessions = tsMaxVnodeConnections;
rpcInit.connType = TAOS_CONN_CLIENT; rpcInit.connType = TAOS_CONN_CLIENT;
rpcInit.user = user; rpcInit.user = (char*)user;
rpcInit.ckey = "key"; rpcInit.ckey = "key";
rpcInit.secret = secretEncrypt; rpcInit.secret = secretEncrypt;
......
src/dnode/CMakeLists.txt
浏览文件 @ b8fc28fb
...@@ -11,7 +11,7 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM)) ...@@ -11,7 +11,7 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
AUX_SOURCE_DIRECTORY(src SRC) AUX_SOURCE_DIRECTORY(src SRC)
ADD_EXECUTABLE(taosd ${SRC}) ADD_EXECUTABLE(taosd ${SRC})
TARGET_LINK_LIBRARIES(taosd mnode sdb taos_static monitor http tsdb) TARGET_LINK_LIBRARIES(taosd mnode sdb taos_static monitor http)
#IF (TD_CLUSTER) #IF (TD_CLUSTER)
# TARGET_LINK_LIBRARIES(taosd dcluster) # TARGET_LINK_LIBRARIES(taosd dcluster)
...@@ -24,7 +24,7 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM)) ...@@ -24,7 +24,7 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
COMMAND echo "make test directory" COMMAND echo "make test directory"
DEPENDS taosd DEPENDS taosd
COMMAND ${CMAKE_COMMAND} -E make_directory ${TD_TESTS_OUTPUT_DIR}/cfg/ COMMAND ${CMAKE_COMMAND} -E make_directory ${TD_TESTS_OUTPUT_DIR}/cfg/
COMMAND ${CMAKE_COMMAND} -E make_directory ${TD_TESTS_OUTPUT_DIR}/log/ COMMAND ${CMAKE_COMMAND} -E make_directoryF ${TD_TESTS_OUTPUT_DIR}/log/
COMMAND ${CMAKE_COMMAND} -E make_directory ${TD_TESTS_OUTPUT_DIR}/data/ COMMAND ${CMAKE_COMMAND} -E make_directory ${TD_TESTS_OUTPUT_DIR}/data/
COMMAND ${CMAKE_COMMAND} -E echo dataDir ${TD_TESTS_OUTPUT_DIR}/data > ${TD_TESTS_OUTPUT_DIR}/cfg/taos.cfg COMMAND ${CMAKE_COMMAND} -E echo dataDir ${TD_TESTS_OUTPUT_DIR}/data > ${TD_TESTS_OUTPUT_DIR}/cfg/taos.cfg
COMMAND ${CMAKE_COMMAND} -E echo logDir ${TD_TESTS_OUTPUT_DIR}/log >> ${TD_TESTS_OUTPUT_DIR}/cfg/taos.cfg COMMAND ${CMAKE_COMMAND} -E echo logDir ${TD_TESTS_OUTPUT_DIR}/log >> ${TD_TESTS_OUTPUT_DIR}/cfg/taos.cfg
......
src/dnode/inc/dnodeVnodeMgmt.h → src/dnode/inc/dnodeMClient.h
浏览文件 @ b8fc28fb
...@@ -13,62 +13,15 @@ ...@@ -13,62 +13,15 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef TDENGINE_DNODE_VNODE_MGMT_H #ifndef TDENGINE_DNODE_MCLIENT_H
#define TDENGINE_DNODE_VNODE_MGMT_H #define TDENGINE_DNODE_MCLIENT_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <stdint.h> int32_t dnodeInitMClient();
#include <stdbool.h> void dnodeCleanupMClient();
#include "taosdef.h"
#include "taosmsg.h"
#include "tstatus.h"
/*
* Open all Vnodes in the local data directory
*/
int32_t dnodeOpenVnodes();
/*
* Close all Vnodes that have been created and opened
*/
int32_t dnodeCleanupVnodes();
/*
* Check if vnode already exists
*/
bool dnodeCheckVnodeExist(int32_t vid);
/*
* Create vnode with specified configuration and open it
* if exist, config it
*/
int32_t dnodeCreateVnode(SCreateVnodeMsg *pVnode);
/*
* Remove vnode from local repository
*/
int32_t dnodeDropVnode(int32_t vnode);
/*
* Get the vnode object that has been opened
*/
//tsdb_repo_t* dnodeGetVnode(int vid);
void* dnodeGetVnode(int32_t vnode);
int32_t dnodeGetVnodesNum();
/*
* get the status of vnode
*/
EVnodeStatus dnodeGetVnodeStatus(int32_t vnode);
/*
* Check if vnode already exists, and table exist in this vnode
*/
bool dnodeCheckTableExist(int32_t vnode, int32_t sid, int64_t uid);
#ifdef __cplusplus #ifdef __cplusplus
} }
......
src/dnode/inc/dnodeMgmt.h
浏览文件 @ b8fc28fb
...@@ -20,18 +20,17 @@ ...@@ -20,18 +20,17 @@
extern "C" { extern "C" {
#endif #endif
#include <stdint.h> int dnodeInitMgmt();
#include <stdbool.h> void dnodeCleanupMgmt();
void dnodeMgmt(SRpcMsg *);
int32_t dnodeInitMgmt();
void dnodeInitMgmtIp(); void* dnodeGetVnode(int vgId);
int dnodeGetVnodeStatus(void *);
void dnodeProcessMsgFromMgmt(char msgType, void *pCont, int32_t contLen, void *pConn, int32_t code); void* dnodeGetVnodeRworker(void *);
void dnodeSendMsgToMnode(int8_t msgType, void *pCont, int32_t contLen); void* dnodeGetVnodeWworker(void *);
void dnodeSendRspToMnode(void *pConn, int8_t msgType, int32_t code, void *pCont, int32_t contLen); void* dnodeGetVnodeWal(void *);
void* dnodeGetVnodeTsdb(void *);
void dnodeSendVnodeCfgMsg(int32_t vnode); void dnodeReleaseVnode(void *);
void dnodeSendTableCfgMsg(int32_t vnode, int32_t sid);
#ifdef __cplusplus #ifdef __cplusplus
} }
......
src/dnode/src/dnodeVnodeMgmt.c → src/dnode/inc/dnodeMnode.h
浏览文件 @ b8fc28fb
...@@ -13,52 +13,18 @@ ...@@ -13,52 +13,18 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#define _DEFAULT_SOURCE #ifndef TDENGINE_DNODE_MNODE_H
#include "os.h" #define TDENGINE_DNODE_MNODE_H
#include "tlog.h"
#include "taoserror.h"
#include "dnodeVnodeMgmt.h"
int32_t dnodeOpenVnodes() { #ifdef __cplusplus
dPrint("open all vnodes"); extern "C" {
return TSDB_CODE_SUCCESS; #endif
}
int32_t dnodeCleanupVnodes() {
dPrint("clean all vnodes");
return TSDB_CODE_SUCCESS;
}
bool dnodeCheckVnodeExist(int32_t vnode) { int32_t dnodeInitMnode();
dPrint("vnode:%d, check vnode exist", vnode); void dnodeCleanupMnode();
return true;
}
int32_t dnodeCreateVnode(SCreateVnodeMsg *pVnode) { #ifdef __cplusplus
dPrint("vnode:%d, is created", htonl(pVnode->vnode));
return TSDB_CODE_SUCCESS;
} }
#endif
int32_t dnodeDropVnode(int32_t vnode) { #endif
dPrint("vnode:%d, is dropped", vnode);
return TSDB_CODE_SUCCESS;
}
void* dnodeGetVnode(int32_t vnode) {
dPrint("vnode:%d, get vnode");
return NULL;
}
EVnodeStatus dnodeGetVnodeStatus(int32_t vnode) {
dPrint("vnode:%d, get vnode status");
return TSDB_VN_STATUS_MASTER;
}
bool dnodeCheckTableExist(int32_t vnode, int32_t sid, int64_t uid) {
dPrint("vnode:%d, sid:%d, check table exist");
return true;
}
int32_t dnodeGetVnodesNum() {
return 1;
}
src/dnode/inc/dnodeModule.h
浏览文件 @ b8fc28fb
...@@ -20,16 +20,10 @@ ...@@ -20,16 +20,10 @@
extern "C" { extern "C" {
#endif #endif
#include <stdint.h>
#include <stdbool.h>
#include <pthread.h>
void dnodeAllocModules(); void dnodeAllocModules();
int32_t dnodeInitModules(); int32_t dnodeInitModules();
void dnodeCleanUpModules(); void dnodeCleanUpModules();
extern void (*dnodeStartModules)();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
......
src/dnode/inc/dnodeRead.h
浏览文件 @ b8fc28fb
...@@ -20,31 +20,12 @@ ...@@ -20,31 +20,12 @@
extern "C" { extern "C" {
#endif #endif
#include <stdbool.h> int dnodeInitRead();
#include <stdint.h> void dnodeCleanupRead();
#include "taosdef.h" void dnodeRead(SRpcMsg *);
#include "taosmsg.h" void *dnodeAllocateReadWorker();
void dnodeFreeReadWorker(void *rqueue);
/*
* handle query message, and the result is returned by callback function
*/
void dnodeQueryData(SQueryTableMsg *pQuery, void *pConn, void (*callback)(int32_t code, void *pQInfo, void *pConn));
/*
* Dispose retrieve msg, and the result will passed through callback function
*/
typedef void (*SDnodeRetrieveCallbackFp)(int32_t code, void *pQInfo, void *pConn);
void dnodeRetrieveData(SRetrieveTableMsg *pRetrieve, void *pConn, SDnodeRetrieveCallbackFp callbackFp);
/*
* Fill retrieve result according to query info
*/
int32_t dnodeGetRetrieveData(void *pQInfo, SRetrieveTableRsp *pRetrieve);
/*
* Get the size of retrieve result according to query info
*/
int32_t dnodeGetRetrieveDataSize(void *pQInfo);
#ifdef __cplusplus #ifdef __cplusplus
} }
......
src/dnode/inc/dnodeShell.h
浏览文件 @ b8fc28fb
...@@ -20,27 +20,9 @@ ...@@ -20,27 +20,9 @@
extern "C" { extern "C" {
#endif #endif
#include <stdint.h>
#include <stdint.h>
#include "dnode.h"
typedef struct {
int sid;
uint32_t ip;
uint16_t port;
int32_t count; // track the number of imports
int32_t code; // track the code of imports
int32_t numOfTotalPoints; // track the total number of points imported
void *thandle; // handle from TAOS layer
void *qhandle;
} SShellObj;
int32_t dnodeInitShell(); int32_t dnodeInitShell();
void dnodeCleanupShell(); void dnodeCleanupShell();
//SDnodeStatisInfo dnodeGetStatisInfo()
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
......
src/dnode/inc/dnodeSystem.h
浏览文件 @ b8fc28fb
...@@ -20,34 +20,15 @@ ...@@ -20,34 +20,15 @@
extern "C" { extern "C" {
#endif #endif
#include <stdint.h>
#include <stdbool.h>
typedef enum { typedef enum {
TSDB_DNODE_RUN_STATUS_INITIALIZE, TSDB_DNODE_RUN_STATUS_INITIALIZE,
TSDB_DNODE_RUN_STATUS_RUNING, TSDB_DNODE_RUN_STATUS_RUNING,
TSDB_DNODE_RUN_STATUS_STOPPED TSDB_DNODE_RUN_STATUS_STOPPED
} SDnodeRunStatus; } SDnodeRunStatus;
extern int32_t (*dnodeInitPeers)(int32_t numOfThreads);
extern int32_t (*dnodeCheckSystem)();
extern int32_t (*dnodeInitStorage)();
extern void (*dnodeCleanupStorage)();
extern int32_t tsMaxQueues;
extern void ** tsRpcQhandle;
extern void *tsQueryQhandle;
extern void *tsDnodeMgmtQhandle;
extern void *tsDnodeTmr;
int32_t dnodeInitSystem(); int32_t dnodeInitSystem();
void dnodeCleanUpSystem(); void dnodeCleanUpSystem();
void dnodeInitPlugins();
SDnodeRunStatus dnodeGetRunStatus(); SDnodeRunStatus dnodeGetRunStatus();
void dnodeSetRunStatus(SDnodeRunStatus status);
void dnodeCheckDataDirOpenned(const char *dir);
void dnodeLockVnodes();
void dnodeUnLockVnodes();
#ifdef __cplusplus #ifdef __cplusplus
} }
......
src/dnode/inc/dnodeWrite.h
浏览文件 @ b8fc28fb
...@@ -20,41 +20,12 @@ ...@@ -20,41 +20,12 @@
extern "C" { extern "C" {
#endif #endif
#include <stdbool.h> int dnodeInitWrite();
#include <stdint.h> void dnodeCleanupWrite();
#include "taosdef.h" void dnodeWrite(SRpcMsg *pMsg);
#include "taosmsg.h" void *dnodeAllocateWriteWorker();
void dnodeFreeWriteWorker(void *worker);
/*
* Write data based on dnode, the detail result can be fetched from rsponse
* pSubmit: Data to be written
* pConn: Communication handle
* callback: Pass the write result through a callback function, possibly in a different thread space
* rsp: will not be freed by callback function
*/
void dnodeWriteData(SShellSubmitMsg *pSubmit, void *pConn, void (*callback)(SShellSubmitRspMsg *rsp, void *pConn));
/*
* Create table with specified configuration and open it
* if table already exist, update its schema and tag
*/
int32_t dnodeCreateTable(SDCreateTableMsg *pTable);
/*
* Remove table from local repository
*/
int32_t dnodeDropTable(SDRemoveTableMsg *pTable);
/*
* Create stream
* if stream already exist, update it
*/
int32_t dnodeCreateStream(SDAlterStreamMsg *pStream);
/*
* Remove all child tables of supertable from local repository
*/
int32_t dnodeDropSuperTable(SDRemoveSuperTableMsg *pStable);
#ifdef __cplusplus #ifdef __cplusplus
} }
......
src/dnode/src/dnodeMClient.c 0 → 100644
浏览文件 @ b8fc28fb
/*
* 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 "os.h"
#include "taosmsg.h"
#include "tlog.h"
#include "trpc.h"
#include "dnodeSystem.h"
static void (*dnodeProcessMgmtRspFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *);
static void dnodeProcessRspFromMnode(SRpcMsg *pMsg);
static void dnodeProcessStatusRsp(SRpcMsg *pMsg);
static void *tsDnodeMClientRpc;
int32_t dnodeInitMClient() {
dnodeProcessMgmtRspFp[TSDB_MSG_TYPE_STATUS_RSP] = dnodeProcessStatusRsp;
SRpcInit rpcInit;
memset(&rpcInit, 0, sizeof(rpcInit));
rpcInit.localIp = tsAnyIp ? "0.0.0.0" : tsPrivateIp;
rpcInit.localPort = 0;
rpcInit.label = "DND-MC";
rpcInit.numOfThreads = 1;
rpcInit.cfp = dnodeProcessRspFromMnode;
rpcInit.sessions = TSDB_SESSIONS_PER_DNODE;
rpcInit.connType = TAOS_CONN_CLIENT;
rpcInit.idleTime = tsShellActivityTimer * 1000;
tsDnodeMClientRpc = rpcOpen(&rpcInit);
if (tsDnodeMClientRpc == NULL) {
dError("failed to init connection from mgmt");
return -1;
}
dPrint("client connection to mgmt is opened");
return 0;
}
void dnodeCleanupMClient() {
if (tsDnodeMClientRpc) {
rpcClose(tsDnodeMClientRpc);
}
}
static void dnodeProcessRspFromMnode(SRpcMsg *pMsg) {
if (dnodeProcessMgmtRspFp[pMsg->msgType]) {
(*dnodeProcessMgmtRspFp[pMsg->msgType])(pMsg);
} else {
dError("%s is not processed", taosMsg[pMsg->msgType]);
}
rpcFreeCont(pMsg->pCont);
}
static void dnodeProcessStatusRsp(SRpcMsg *pMsg) {
}
src/dnode/src/dnodeMgmt.c
浏览文件 @ b8fc28fb
...@@ -15,327 +15,219 @@ ...@@ -15,327 +15,219 @@
#define _DEFAULT_SOURCE #define _DEFAULT_SOURCE
#include "os.h" #include "os.h"
#include "taosmsg.h"
#include "tlog.h" #include "tlog.h"
#include "taoserror.h"
#include "taosmsg.h"
#include "trpc.h" #include "trpc.h"
#include "tsched.h"
#include "tsystem.h"
#include "mnode.h"
#include "dnode.h"
#include "dnodeSystem.h"
#include "dnodeMgmt.h"
#include "dnodeWrite.h" #include "dnodeWrite.h"
#include "dnodeVnodeMgmt.h" #include "dnodeRead.h"
#include "dnodeMgmt.h"
void (*dnodeInitMgmtIpFp)() = NULL;
int32_t (*dnodeInitMgmtFp)() = NULL;
void (*dnodeCleanUpMgmtFp)() = NULL;
void (*dnodeProcessStatusRspFp)(void *pCont, int32_t contLen, int8_t msgType, void *pConn) = NULL;
void (*dnodeSendMsgToMnodeFp)(int8_t msgType, void *pCont, int32_t contLen) = NULL;
void (*dnodeSendRspToMnodeFp)(void *handle, int32_t code, void *pCont, int contLen) = NULL;
static void *tsStatusTimer = NULL;
static void (*dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_MAX])(void *pCont, int32_t contLen, int8_t msgType, void *pConn);
static void dnodeInitProcessShellMsg();
static void dnodeSendMsgToMnodeQueueFp(SSchedMsg *sched) {
int32_t contLen = *(int32_t *) (sched->msg - 4);
int32_t code = *(int32_t *) (sched->msg - 8);
int8_t msgType = *(int8_t *) (sched->msg - 9);
void *handle = sched->ahandle;
int8_t *pCont = sched->msg;
mgmtProcessMsgFromDnode(msgType, pCont, contLen, handle, code);
}
void dnodeSendMsgToMnode(int8_t msgType, void *pCont, int32_t contLen) { typedef struct {
dTrace("msg:%d:%s is sent to mnode", msgType, taosMsg[msgType]); int32_t vgId; // global vnode group ID
if (dnodeSendMsgToMnodeFp) { int status; // status: master, slave, notready, deleting
dnodeSendMsgToMnodeFp(msgType, pCont, contLen); int refCount; // reference count
} else { int64_t version;
if (pCont == NULL) { void *wworker;
pCont = rpcMallocCont(1); void *rworker;
contLen = 0; void *wal;
} void *tsdb;
SSchedMsg schedMsg = {0}; void *replica;
schedMsg.fp = dnodeSendMsgToMnodeQueueFp; void *events;
schedMsg.msg = pCont; void *cq; // continuous query
*(int32_t *) (pCont - 4) = contLen; } SVnodeObj;
*(int32_t *) (pCont - 8) = TSDB_CODE_SUCCESS;
*(int8_t *) (pCont - 9) = msgType; static int dnodeOpenVnodes();
taosScheduleTask(tsDnodeMgmtQhandle, &schedMsg); static void dnodeCleanupVnodes();
} static int dnodeCreateVnode(int32_t vgId, SCreateVnodeMsg *cfg);
static int dnodeDropVnode(SVnodeObj *pVnode);
static void dnodeRemoveVnode(SVnodeObj *pVnode);
static void dnodeProcessCreateVnodeMsg(SRpcMsg *pMsg);
static void dnodeProcessDropVnodeMsg(SRpcMsg *pMsg);
static void dnodeProcessAlterVnodeMsg(SRpcMsg *pMsg);
static void (*dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *pMsg);
int dnodeInitMgmt() {
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_FREE_VNODE] = dnodeProcessDropVnodeMsg;
} }
void dnodeSendRspToMnode(void *pConn, int8_t msgType, int32_t code, void *pCont, int32_t contLen) { void dnodeCleanupMgmt() {
dTrace("rsp:%d:%s is sent to mnode, pConn:%p", msgType, taosMsg[msgType], pConn);
if (dnodeSendRspToMnodeFp) {
dnodeSendRspToMnodeFp(pConn, code, pCont, contLen);
} else {
//hack way
if (pCont == NULL) {
pCont = rpcMallocCont(1);
contLen = 0;
}
SSchedMsg schedMsg = {0};
schedMsg.fp = dnodeSendMsgToMnodeQueueFp;
schedMsg.msg = pCont;
schedMsg.ahandle = pConn;
*(int32_t *) (pCont - 4) = contLen;
*(int32_t *) (pCont - 8) = code;
*(int8_t *) (pCont - 9) = msgType;
taosScheduleTask(tsDnodeMgmtQhandle, &schedMsg);
}
} }
void dnodeSendStatusMsgToMgmt(void *handle, void *tmrId) { void dnodeMgmt(SRpcMsg *pMsg) {
taosTmrReset(dnodeSendStatusMsgToMgmt, tsStatusInterval * 1000, NULL, tsDnodeTmr, &tsStatusTimer);
if (tsStatusTimer == NULL) { terrno = 0;
dError("Failed to start status timer");
return;
}
int32_t contLen = sizeof(SStatusMsg) + dnodeGetVnodesNum() * sizeof(SVnodeLoad); if (dnodeProcessMgmtMsgFp[pMsg->msgType]) {
SStatusMsg *pStatus = rpcMallocCont(contLen); (*dnodeProcessMgmtMsgFp[pMsg->msgType])(pMsg);
if (pStatus == NULL) { } else {
dError("Failed to malloc status message"); terrno = TSDB_CODE_MSG_NOT_PROCESSED;
return;
} }
int32_t totalVnodes = dnodeGetVnodesNum(); SRpcMsg rsp;
rsp.handle = pMsg->handle;
pStatus->version = htonl(tsVersion); rsp.code = terrno;
pStatus->privateIp = htonl(inet_addr(tsPrivateIp)); rsp.pCont = NULL;
pStatus->publicIp = htonl(inet_addr(tsPublicIp)); rpcSendResponse(&rsp);
pStatus->lastReboot = htonl(tsRebootTime); rpcFreeCont(pMsg->pCont); // free the received message
pStatus->numOfTotalVnodes = htons((uint16_t) tsNumOfTotalVnodes);
pStatus->openVnodes = htons((uint16_t) totalVnodes);
pStatus->numOfCores = htons((uint16_t) tsNumOfCores);
pStatus->diskAvailable = tsAvailDataDirGB;
pStatus->alternativeRole = (uint8_t) tsAlternativeRole;
SVnodeLoad *pLoad = (SVnodeLoad *)pStatus->load;
//TODO loop all vnodes
// for (int32_t vnode = 0, count = 0; vnode <= totalVnodes; ++vnode) {
// if (vnodeList[vnode].cfg.maxSessions <= 0) continue;
//
// SVnodeObj *pVnode = vnodeList + vnode;
// pLoad->vnode = htonl(vnode);
// pLoad->vgId = htonl(pVnode->cfg.vgId);
// pLoad->status = (uint8_t)vnodeList[vnode].vnodeStatus;
// pLoad->syncStatus =(uint8_t)vnodeList[vnode].syncStatus;
// pLoad->accessState = (uint8_t)(pVnode->accessState);
// pLoad->totalStorage = htobe64(pVnode->vnodeStatistic.totalStorage);
// pLoad->compStorage = htobe64(pVnode->vnodeStatistic.compStorage);
// if (pVnode->vnodeStatus == TSDB_VN_STATUS_MASTER) {
// pLoad->pointsWritten = htobe64(pVnode->vnodeStatistic.pointsWritten);
// } else {
// pLoad->pointsWritten = htobe64(0);
// }
// pLoad++;
//
// if (++count >= tsOpenVnodes) {
// break;
// }
// }
dnodeSendMsgToMnode(TSDB_MSG_TYPE_STATUS, pStatus, contLen);
} }
void *dnodeGetVnode(int vgId) {
SVnodeObj *pVnode;
int32_t dnodeInitMgmt() { // retrieve the pVnode from vgId
if (dnodeInitMgmtFp) {
dnodeInitMgmtFp();
}
dnodeInitProcessShellMsg();
taosTmrReset(dnodeSendStatusMsgToMgmt, 500, NULL, tsDnodeTmr, &tsStatusTimer); // if (pVnode->status == ....) {
return 0; // terrno = ;
// return NULL;
// }
atomic_add_fetch_32(&pVnode->refCount, 1);
return pVnode;
} }
void dnodeInitMgmtIp() { int dnodeGetVnodeStatus(void *pVnode) {
if (dnodeInitMgmtIpFp) { return ((SVnodeObj *)pVnode)->status;
dnodeInitMgmtIpFp();
}
} }
void dnodeCleanUpMgmt() { void *dnodeGetVnodeWworker(void *pVnode) {
if (tsStatusTimer != NULL) { return ((SVnodeObj *)pVnode)->wworker;
taosTmrStopA(&tsStatusTimer); }
tsStatusTimer = NULL;
}
if (dnodeCleanUpMgmtFp) { void *dnodeGetVnodeRworker(void *pVnode) {
dnodeCleanUpMgmtFp(); return ((SVnodeObj *)pVnode)->rworker;
}
} }
void dnodeProcessMsgFromMgmt(char msgType, void *pCont, int32_t contLen, void *pConn, int32_t code) { void *dnodeGetVnodeWal(void *pVnode) {
if (msgType < 0 || msgType >= TSDB_MSG_TYPE_MAX) { return ((SVnodeObj *)pVnode)->wal;
dError("invalid msg type:%d", msgType); }
return;
}
dTrace("msg:%d:%s is received from mgmt, pConn:%p", msgType, taosMsg[(int8_t)msgType], pConn); void *dnodeGetVnodeTsdb(void *pVnode) {
return ((SVnodeObj *)pVnode)->tsdb;
}
if (msgType == TSDB_MSG_TYPE_STATUS_RSP && dnodeProcessStatusRspFp != NULL) { void dnodeReleaseVnode(void *param) {
dnodeProcessStatusRspFp(pCont, contLen, msgType, pConn); SVnodeObj *pVnode = (SVnodeObj *)param;
}
if (dnodeProcessMgmtMsgFp[msgType]) {
(*dnodeProcessMgmtMsgFp[msgType])(pCont, contLen, msgType, pConn);
} else {
dError("%s is not processed", taosMsg[msgType]);
}
//rpcFreeCont(pCont); int refCount = atomic_sub_fetch_32(&pVnode->refCount, 1);
if (refCount == 0) dnodeRemoveVnode(pVnode);
} }
static void dnodeProcessCreateTableRequest(void *pCont, int32_t contLen, int8_t msgType, void *pConn) { static int dnodeOpenVnode() {
SDCreateTableMsg *pTable = pCont; SVnodeObj *pVnode;
pTable->numOfColumns = htons(pTable->numOfColumns);
pTable->numOfTags = htons(pTable->numOfTags);
pTable->sid = htonl(pTable->sid);
pTable->sversion = htonl(pTable->sversion);
pTable->tagDataLen = htonl(pTable->tagDataLen);
pTable->sqlDataLen = htonl(pTable->sqlDataLen);
pTable->contLen = htonl(pTable->contLen);
pTable->numOfVPeers = htonl(pTable->numOfVPeers);
pTable->uid = htobe64(pTable->uid);
pTable->superTableUid = htobe64(pTable->superTableUid);
pTable->createdTime = htobe64(pTable->createdTime);
for (int i = 0; i < pTable->numOfVPeers; ++i) {
pTable->vpeerDesc[i].ip = htonl(pTable->vpeerDesc[i].ip);
pTable->vpeerDesc[i].vnode = htonl(pTable->vpeerDesc[i].vnode);
}
int32_t totalCols = pTable->numOfColumns + pTable->numOfTags; // create tsdb
SSchema *pSchema = (SSchema *) pTable->data;
for (int32_t col = 0; col < totalCols; ++col) {
pSchema->bytes = htons(pSchema->bytes);
pSchema->colId = htons(pSchema->colId);
pSchema++;
}
int32_t code = dnodeCreateTable(pTable); // create wal
dnodeSendRspToMnode(pConn, msgType + 1, code, NULL, 0);
}
static void dnodeProcessAlterStreamRequest(void *pCont, int32_t contLen, int8_t msgType, void *pConn) { // allocate write worker
SDAlterStreamMsg *pStream = pCont; pVnode->wworker = dnodeAllocateWriteWorker();
pStream->uid = htobe64(pStream->uid);
pStream->stime = htobe64(pStream->stime);
pStream->vnode = htonl(pStream->vnode);
pStream->sid = htonl(pStream->sid);
pStream->status = htonl(pStream->status);
int32_t code = dnodeCreateStream(pStream); // create read queue
dnodeSendRspToMnode(pConn, msgType + 1, code, NULL, 0); pVnode->rworker = dnodeAllocateReadWorker();
}
static void dnodeProcessRemoveTableRequest(void *pCont, int32_t contLen, int8_t msgType, void *pConn) { // create the replica
SDRemoveTableMsg *pTable = pCont;
pTable->sid = htonl(pTable->sid);
pTable->numOfVPeers = htonl(pTable->numOfVPeers);
pTable->uid = htobe64(pTable->uid);
for (int i = 0; i < pTable->numOfVPeers; ++i) { // set the status
pTable->vpeerDesc[i].ip = htonl(pTable->vpeerDesc[i].ip);
pTable->vpeerDesc[i].vnode = htonl(pTable->vpeerDesc[i].vnode); pVnode->refCount = 1;
}
int32_t code = dnodeDropTable(pTable); return 0;
dnodeSendRspToMnode(pConn, msgType + 1, code, NULL, 0);
} }
static void dnodeProcessVPeerCfgRsp(void *pCont, int32_t contLen, int8_t msgType, void *pConn) { static int dnodeOpenVnodes() {
int32_t code = htonl(*((int32_t *) pCont)); return 0;
if (code == TSDB_CODE_SUCCESS) {
SCreateVnodeMsg *pVnode = (SCreateVnodeMsg *) (pCont + sizeof(int32_t));
dnodeCreateVnode(pVnode);
} else if (code == TSDB_CODE_INVALID_VNODE_ID) {
SFreeVnodeMsg *vpeer = (SFreeVnodeMsg *) (pCont + sizeof(int32_t));
int32_t vnode = htonl(vpeer->vnode);
dError("vnode:%d, not exist, remove it", vnode);
dnodeDropVnode(vnode);
} else {
dError("code:%d invalid message", code);
}
} }
static void dnodeProcessTableCfgRsp(void *pCont, int32_t contLen, int8_t msgType, void *pConn) { static void dnodeCleanupVnode() {
int32_t code = htonl(*((int32_t *) pCont));
if (code == TSDB_CODE_SUCCESS) {
SDCreateTableMsg *table = (SDCreateTableMsg *) (pCont + sizeof(int32_t));
dnodeCreateTable(table);
} else if (code == TSDB_CODE_INVALID_TABLE_ID) {
SDRemoveTableMsg *pTable = (SDRemoveTableMsg *) (pCont + sizeof(int32_t));
pTable->sid = htonl(pTable->sid);
pTable->uid = htobe64(pTable->uid);
dError("table:%s, sid:%d table is not configured, remove it", pTable->tableId, pTable->sid);
dnodeDropTable(pTable);
} else {
dError("code:%d invalid message", code);
}
} }
static void dnodeProcessCreateVnodeRequest(void *pCont, int32_t contLen, int8_t msgType, void *pConn) { static void dnodeCleanupVnodes() {
SCreateVnodeMsg *pVnode = (SCreateVnodeMsg *) pCont;
int32_t code = dnodeCreateVnode(pVnode);
dnodeSendRspToMnode(pConn, msgType + 1, code, NULL, 0);
} }
static void dnodeProcessFreeVnodeRequest(void *pCont, int32_t contLen, int8_t msgType, void *pConn) { static int dnodeCreateVnode(int32_t vgId, SCreateVnodeMsg *cfg) {
SFreeVnodeMsg *pVnode = (SFreeVnodeMsg *) pCont;
int32_t vnode = htonl(pVnode->vnode); SVnodeObj *pVnode = malloc(sizeof(SVnodeObj));
// save the vnode info in non-volatile storage
// add into hash, so it can be retrieved
dnodeOpenVnode(pVnode);
int32_t code = dnodeDropVnode(vnode); return 0;
dnodeSendRspToMnode(pConn, msgType + 1, code, NULL, 0);
} }
static void dnodeProcessDnodeCfgRequest(void *pCont, int32_t contLen, int8_t msgType, void *pConn) { static void dnodeRemoveVnode(SVnodeObj *pVnode) {
SCfgDnodeMsg *pCfg = (SCfgDnodeMsg *)pCont;
// remove replica
// remove read queue
dnodeFreeReadWorker(pVnode->rworker);
// remove write queue
dnodeFreeWriteWorker(pVnode->wworker);
// remove wal
// remove tsdb
int32_t code = tsCfgDynamicOptions(pCfg->config);
dnodeSendRspToMnode(pConn, msgType + 1, code, NULL, 0);
} }
static void dnodeProcessDropStableRequest(void *pCont, int32_t contLen, int8_t msgType, void *pConn) { static int dnodeDropVnode(SVnodeObj *pVnode) {
dnodeSendRspToMnode(pConn, msgType + 1, TSDB_CODE_SUCCESS, NULL, 0);
int count = atomic_sub_fetch_32(&pVnode->refCount, 1);
if (count<=0) dnodeRemoveVnode(pVnode);
return 0;
} }
void dnodeSendVnodeCfgMsg(int32_t vnode) { static void dnodeProcessCreateVnodeMsg(SRpcMsg *pMsg) {
SVpeerCfgMsg *cfg = (SVpeerCfgMsg *) rpcMallocCont(sizeof(SVpeerCfgMsg));
if (cfg == NULL) { // SVnodeObj *pVnode;
return; // int vgId;
} // SVPeersMsg *pCfg;
// check everything, if not ok, set terrno;
cfg->vnode = htonl(vnode); // everything is ok
dnodeSendMsgToMnode(TSDB_MSG_TYPE_VNODE_CFG, cfg, sizeof(SVpeerCfgMsg));
// dnodeCreateVnode(vgId, pCfg);
//if (pVnode == NULL) terrno = TSDB_CODE
} }
void dnodeSendTableCfgMsg(int32_t vnode, int32_t sid) { static void dnodeProcessDropVnodeMsg(SRpcMsg *pMsg) {
STableCfgMsg *cfg = (STableCfgMsg *) rpcMallocCont(sizeof(STableCfgMsg));
if (cfg == NULL) { SVnodeObj *pVnode;
return; int vgId;
}
cfg->vnode = htonl(vnode); // check everything, if not ok, set terrno;
dnodeSendMsgToMnode(TSDB_MSG_TYPE_TABLE_CFG, cfg, sizeof(STableCfgMsg));
// everything is ok
dnodeDropVnode(pVnode);
//if (pVnode == NULL) terrno = TSDB_CODE
} }
static void dnodeInitProcessShellMsg() { static void dnodeProcessAlterVnodeMsg(SRpcMsg *pMsg) {
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_DNODE_CREATE_TABLE] = dnodeProcessCreateTableRequest;
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_DNODE_REMOVE_TABLE] = dnodeProcessRemoveTableRequest; SVnodeObj *pVnode;
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_CREATE_VNODE] = dnodeProcessCreateVnodeRequest; int vgId;
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_FREE_VNODE] = dnodeProcessFreeVnodeRequest;
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_DNODE_CFG] = dnodeProcessDnodeCfgRequest; // check everything, if not ok, set terrno;
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_ALTER_STREAM] = dnodeProcessAlterStreamRequest;
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_DROP_STABLE] = dnodeProcessDropStableRequest;
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_VNODE_CFG_RSP] = dnodeProcessVPeerCfgRsp; // everything is ok
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_TABLE_CFG_RSP] = dnodeProcessTableCfgRsp; // dnodeAlterVnode(pVnode);
//if (pVnode == NULL) terrno = TSDB_CODE
} }
src/dnode/src/dnodeMnode.c 0 → 100644
浏览文件 @ b8fc28fb
/*
* 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/>.
*/
#include "os.h"
#include "taosmsg.h"
#include "tlog.h"
#include "trpc.h"
#include "dnodeSystem.h"
#include "dnodeMgmt.h"
#include "dnodeWrite.h"
static void (*dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *);
static void dnodeProcessMsgFromMnode(SRpcMsg *pMsg);
static void *tsDnodeMnodeRpc = NULL;
int32_t dnodeInitMnode() {
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_DNODE_CREATE_TABLE] = dnodeWrite;
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_DNODE_REMOVE_TABLE] = dnodeWrite;
dnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_FREE_VNODE] = dnodeMgmt;
SRpcInit rpcInit;
memset(&rpcInit, 0, sizeof(rpcInit));
rpcInit.localIp = tsAnyIp ? "0.0.0.0" : tsPrivateIp;
// note: a new port shall be assigned
// rpcInit.localPort = tsDnodeMnodePort;
rpcInit.label = "DND-mgmt";
rpcInit.numOfThreads = 1;
rpcInit.cfp = dnodeProcessMsgFromMnode;
rpcInit.sessions = TSDB_SESSIONS_PER_DNODE;
rpcInit.connType = TAOS_CONN_SERVER;
rpcInit.idleTime = tsShellActivityTimer * 1500;
tsDnodeMnodeRpc = rpcOpen(&rpcInit);
if (tsDnodeMnodeRpc == NULL) {
dError("failed to init connection from mgmt");
return -1;
}
dPrint("connection to mgmt is opened");
return 0;
}
void dnodeCleanupMnode() {
if (tsDnodeMnodeRpc) {
rpcClose(tsDnodeMnodeRpc);
}
}
static void dnodeProcessMsgFromMnode(SRpcMsg *pMsg) {
SRpcMsg rspMsg;
rspMsg.handle = pMsg->handle;
rspMsg.pCont = NULL;
rspMsg.contLen = 0;
if (dnodeGetRunStatus() != TSDB_DNODE_RUN_STATUS_RUNING) {
rspMsg.code = TSDB_CODE_NOT_READY;
rpcSendResponse(&rspMsg);
rpcFreeCont(pMsg->pCont);
dTrace("conn:%p, query msg is ignored since dnode not running", pMsg->handle);
return;
}
if (dnodeProcessMgmtMsgFp[pMsg->msgType]) {
(*dnodeProcessMgmtMsgFp[pMsg->msgType])(pMsg);
} else {
dError("%s is not processed", taosMsg[pMsg->msgType]);
rspMsg.code = TSDB_CODE_MSG_NOT_PROCESSED;
rpcSendResponse(&rspMsg);
rpcFreeCont(pMsg->pCont);
}
}
src/dnode/src/dnodeRead.c
浏览文件 @ b8fc28fb
...@@ -17,56 +17,196 @@ ...@@ -17,56 +17,196 @@
#include "os.h" #include "os.h"
#include "taoserror.h" #include "taoserror.h"
#include "tlog.h" #include "tlog.h"
#include "tsched.h" #include "trpc.h"
#include "dnode.h" #include "taosmsg.h"
#include "tqueue.h"
#include "dnodeRead.h" #include "dnodeRead.h"
#include "dnodeSystem.h" #include "dnodeMgmt.h"
void dnodeQueryData(SQueryTableMsg *pQuery, void *pConn, void (*callback)(int32_t code, void *pQInfo, void *pConn)) { typedef struct {
dTrace("conn:%p, query msg is disposed", pConn); int32_t code;
void *pQInfo = 100; int32_t count;
callback(TSDB_CODE_SUCCESS, pQInfo, pConn); int32_t numOfVnodes;
} SRpcContext;
typedef struct {
void *pCont;
int contLen;
SRpcMsg rpcMsg;
void *pVnode;
SRpcContext *pRpcContext; // RPC message context
} SReadMsg;
static void *dnodeProcessReadQueue(void *param);
static void dnodeProcessReadResult(SReadMsg *pRead);
static void dnodeHandleIdleReadWorker();
static void dnodeProcessQueryMsg(SReadMsg *pMsg);
static void dnodeProcessRetrieveMsg(SReadMsg *pMsg);
static void (*dnodeProcessReadMsgFp[TSDB_MSG_TYPE_MAX])(SReadMsg *pNode);
// module global variable
static taos_qset readQset;
static int threads; // number of query threads
static int maxThreads;
static int minThreads;
int dnodeInitRead() {
dnodeProcessReadMsgFp[TSDB_MSG_TYPE_QUERY] = dnodeProcessQueryMsg;
dnodeProcessReadMsgFp[TSDB_MSG_TYPE_RETRIEVE] = dnodeProcessRetrieveMsg;
readQset = taosOpenQset();
minThreads = 3;
maxThreads = tsNumOfCores*tsNumOfThreadsPerCore;
if (maxThreads <= minThreads*2) maxThreads = 2*minThreads;
return 0;
}
void dnodeCleanupRead() {
taosCloseQset(readQset);
} }
static void dnodeExecuteRetrieveData(SSchedMsg *pSched) { void dnodeRead(SRpcMsg *pMsg) {
SDnodeRetrieveCallbackFp callback = (SDnodeRetrieveCallbackFp)pSched->thandle; int leftLen = pMsg->contLen;
SRetrieveTableMsg *pRetrieve = pSched->msg; char *pCont = (char *)pMsg->pCont;
void *pConn = pSched->ahandle; int contLen = 0;
int numOfVnodes = 0;
int32_t vgId = 0;
SRpcContext *pRpcContext = NULL;
dTrace("conn:%p, retrieve msg is disposed, qhandle:%" PRId64, pConn, pRetrieve->qhandle); // parse head, get number of vnodes;
if ( numOfVnodes > 1) {
pRpcContext = calloc(sizeof(SRpcContext), 1);
pRpcContext->numOfVnodes = 1;
}
//examples while (leftLen > 0) {
int32_t code = TSDB_CODE_SUCCESS; // todo: parse head, get vgId, contLen
void *pQInfo = (void*)pRetrieve->qhandle;
(*callback)(code, pQInfo, pConn); // get pVnode from vgId
void *pVnode = dnodeGetVnode(vgId);
if (pVnode == NULL) {
free(pSched->msg); continue;
}
// put message into queue
SReadMsg readMsg;
readMsg.rpcMsg = *pMsg;
readMsg.pCont = pCont;
readMsg.contLen = contLen;
readMsg.pRpcContext = pRpcContext;
readMsg.pVnode = pVnode;
taos_queue queue = dnodeGetVnodeRworker(pVnode);
taosWriteQitem(queue, &readMsg);
// next vnode
leftLen -= contLen;
pCont -= contLen;
}
} }
void dnodeRetrieveData(SRetrieveTableMsg *pRetrieve, void *pConn, SDnodeRetrieveCallbackFp callbackFp) { void *dnodeAllocateReadWorker() {
dTrace("conn:%p, retrieve msg is received", pConn);
taos_queue *queue = taosOpenQueue(sizeof(SReadMsg));
if ( queue == NULL ) return NULL;
taosAddIntoQset(readQset, queue);
void *msg = malloc(sizeof(SRetrieveTableMsg)); // spawn a thread to process queue
memcpy(msg, pRetrieve, sizeof(SRetrieveTableMsg)); if (threads < maxThreads) {
pthread_t thread;
pthread_attr_t thAttr;
pthread_attr_init(&thAttr);
pthread_attr_setdetachstate(&thAttr, PTHREAD_CREATE_JOINABLE);
SSchedMsg schedMsg; if (pthread_create(&thread, &thAttr, dnodeProcessReadQueue, readQset) != 0) {
schedMsg.msg = msg; dError("failed to create thread to process read queue, reason:%s", strerror(errno));
schedMsg.ahandle = pConn; }
schedMsg.thandle = callbackFp; }
schedMsg.fp = dnodeExecuteRetrieveData;
taosScheduleTask(tsQueryQhandle, &schedMsg); return queue;
} }
int32_t dnodeGetRetrieveData(void *pQInfo, SRetrieveTableRsp *pRetrieve) { void dnodeFreeReadWorker(void *rqueue) {
dTrace("qInfo:%p, data is retrieved");
pRetrieve->numOfRows = 0; taosCloseQueue(rqueue);
return 0;
// dynamically adjust the number of threads
} }
int32_t dnodeGetRetrieveDataSize(void *pQInfo) { static void *dnodeProcessReadQueue(void *param) {
dTrace("qInfo:%p, contLen is 100"); taos_qset qset = (taos_qset)param;
return 100; SReadMsg readMsg;
while (1) {
if (taosReadQitemFromQset(qset, &readMsg) <= 0) {
dnodeHandleIdleReadWorker();
continue;
}
terrno = 0;
if (dnodeProcessReadMsgFp[readMsg.rpcMsg.msgType]) {
(*dnodeProcessReadMsgFp[readMsg.rpcMsg.msgType]) (&readMsg);
} else {
terrno = TSDB_CODE_MSG_NOT_PROCESSED;
}
dnodeProcessReadResult(&readMsg);
}
return NULL;
}
static void dnodeHandleIdleReadWorker() {
int num = taosGetQueueNumber(readQset);
if (num == 0 || (num <= minThreads && threads > minThreads)) {
threads--;
pthread_exit(NULL);
} else {
usleep(100);
sched_yield();
}
}
static void dnodeProcessReadResult(SReadMsg *pRead) {
SRpcContext *pRpcContext = pRead->pRpcContext;
int32_t code = 0;
dnodeReleaseVnode(pRead->pVnode);
if (pRpcContext) {
if (terrno) {
if (pRpcContext->code == 0) pRpcContext->code = terrno;
}
int count = atomic_add_fetch_32(&pRpcContext->count, 1);
if (count < pRpcContext->numOfVnodes) {
// not over yet, multiple vnodes
return;
}
// over, result can be merged now
code = pRpcContext->code;
} else {
code = terrno;
}
SRpcMsg rsp;
rsp.handle = pRead->rpcMsg.handle;
rsp.code = code;
rsp.pCont = NULL;
rpcSendResponse(&rsp);
rpcFreeCont(pRead->rpcMsg.pCont); // free the received message
} }
static void dnodeProcessQueryMsg(SReadMsg *pMsg) {
}
static void dnodeProcessRetrieveMsg(SReadMsg *pMsg) {
}
src/dnode/src/dnodeShell.c
浏览文件 @ b8fc28fb
...@@ -19,31 +19,22 @@ ...@@ -19,31 +19,22 @@
#include "taosdef.h" #include "taosdef.h"
#include "taosmsg.h" #include "taosmsg.h"
#include "tlog.h" #include "tlog.h"
#include "tsocket.h"
#include "tschemautil.h"
#include "textbuffer.h"
#include "trpc.h" #include "trpc.h"
#include "http.h"
#include "dnode.h"
#include "dnodeMgmt.h"
#include "dnodeRead.h"
#include "dnodeSystem.h" #include "dnodeSystem.h"
#include "dnodeShell.h" #include "dnodeRead.h"
#include "dnodeVnodeMgmt.h"
#include "dnodeWrite.h" #include "dnodeWrite.h"
#include "dnodeShell.h"
static void dnodeProcessRetrieveMsg(void *pCont, int32_t contLen, void *pConn); static void (*dnodeProcessShellMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *);
static void dnodeProcessQueryMsg(void *pCont, int32_t contLen, void *pConn); static void dnodeProcessMsgFromShell(SRpcMsg *pMsg);
static void dnodeProcessSubmitMsg(void *pCont, int32_t contLen, void *pConn); static void *tsDnodeShellRpc = NULL;
static void dnodeProcessMsgFromShell(char msgType, void *pCont, int contLen, void *handle, int32_t code);
static int dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey);
static void *tsDnodeShellServer = NULL;
static int32_t tsDnodeQueryReqNum = 0;
static int32_t tsDnodeSubmitReqNum = 0;
int32_t dnodeInitShell() { int32_t dnodeInitShell() {
int32_t numOfThreads = tsNumOfCores * tsNumOfThreadsPerCore; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_SUBMIT] = dnodeWrite;
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_QUERY] = dnodeRead;
dnodeProcessShellMsgFp[TSDB_MSG_TYPE_RETRIEVE] = dnodeRead;
int numOfThreads = tsNumOfCores * tsNumOfThreadsPerCore;
numOfThreads = (int32_t) ((1.0 - tsRatioOfQueryThreads) * numOfThreads / 2.0); numOfThreads = (int32_t) ((1.0 - tsRatioOfQueryThreads) * numOfThreads / 2.0);
if (numOfThreads < 1) { if (numOfThreads < 1) {
numOfThreads = 1; numOfThreads = 1;
...@@ -58,164 +49,47 @@ int32_t dnodeInitShell() { ...@@ -58,164 +49,47 @@ int32_t dnodeInitShell() {
rpcInit.cfp = dnodeProcessMsgFromShell; rpcInit.cfp = dnodeProcessMsgFromShell;
rpcInit.sessions = TSDB_SESSIONS_PER_DNODE; rpcInit.sessions = TSDB_SESSIONS_PER_DNODE;
rpcInit.connType = TAOS_CONN_SERVER; rpcInit.connType = TAOS_CONN_SERVER;
rpcInit.idleTime = tsShellActivityTimer * 2000; rpcInit.idleTime = tsShellActivityTimer * 1500;
rpcInit.afp = dnodeRetrieveUserAuthInfo;
tsDnodeShellServer = rpcOpen(&rpcInit); tsDnodeShellRpc = rpcOpen(&rpcInit);
if (tsDnodeShellServer == NULL) { if (tsDnodeShellRpc == NULL) {
dError("failed to init connection from shell"); dError("failed to init connection from shell");
return -1; return -1;
} }
dPrint("shell is opened"); dPrint("connection to shell is opened");
return TSDB_CODE_SUCCESS; return 0;
} }
void dnodeCleanupShell() { void dnodeCleanupShell() {
if (tsDnodeShellServer) { if (tsDnodeShellRpc) {
rpcClose(tsDnodeShellServer); rpcClose(tsDnodeShellRpc);
} }
} }
SDnodeStatisInfo dnodeGetStatisInfo() { void dnodeProcessMsgFromShell(SRpcMsg *pMsg) {
SDnodeStatisInfo info = {0}; SRpcMsg rpcMsg;
if (dnodeGetRunStatus() == TSDB_DNODE_RUN_STATUS_RUNING) {
info.httpReqNum = httpGetReqCount();
info.queryReqNum = atomic_exchange_32(&tsDnodeQueryReqNum, 0);
info.submitReqNum = atomic_exchange_32(&tsDnodeSubmitReqNum, 0);
}
return info; rpcMsg.handle = pMsg->handle;
} rpcMsg.pCont = NULL;
rpcMsg.contLen = 0;
static void dnodeProcessMsgFromShell(char msgType, void *pCont, int contLen, void *handle, int32_t code) {
if (dnodeGetRunStatus() != TSDB_DNODE_RUN_STATUS_RUNING) { if (dnodeGetRunStatus() != TSDB_DNODE_RUN_STATUS_RUNING) {
rpcSendResponse(handle, TSDB_CODE_NOT_READY, 0, 0); dError("RPC %p, shell msg is ignored since dnode not running", pMsg->handle);
dTrace("query msg is ignored since dnode not running"); rpcMsg.code = TSDB_CODE_NOT_READY;
rpcSendResponse(&rpcMsg);
rpcFreeCont(pMsg->pCont);
return; return;
} }
dTrace("conn:%p, msg:%s is received", handle, taosMsg[(int8_t)msgType]); if ( dnodeProcessShellMsgFp[pMsg->msgType] ) {
(*dnodeProcessShellMsgFp[pMsg->msgType])(pMsg);
if (msgType == TSDB_MSG_TYPE_QUERY) {
dnodeProcessQueryMsg(pCont, contLen, handle);
} else if (msgType == TSDB_MSG_TYPE_RETRIEVE) {
dnodeProcessRetrieveMsg(pCont, contLen, handle);
} else if (msgType == TSDB_MSG_TYPE_SUBMIT) {
dnodeProcessSubmitMsg(pCont, contLen, handle);
} else { } else {
dError("conn:%p, msg:%s is not processed", handle, taosMsg[(int8_t)msgType]); dError("RPC %p, msg:%s from shell is not handled", pMsg->handle, taosMsg[pMsg->msgType]);
rpcMsg.code = TSDB_CODE_MSG_NOT_PROCESSED;
rpcSendResponse(&rpcMsg);
rpcFreeCont(pMsg->pCont);
} }
//TODO free may be cause segmentfault
// rpcFreeCont(pCont);
} }
static int dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
return TSDB_CODE_SUCCESS;
}
static void dnodeProcessQueryMsgCb(int32_t code, void *pQInfo, void *pConn) {
dTrace("conn:%p, query is returned, code:%d", pConn, code);
int32_t contLen = sizeof(SQueryTableRsp);
SQueryTableRsp *queryRsp = (SQueryTableRsp *) rpcMallocCont(contLen);
if (queryRsp == NULL) {
rpcSendResponse(pConn, TSDB_CODE_SERV_OUT_OF_MEMORY, NULL, 0);
return;
}
queryRsp->code = htonl(code);
queryRsp->qhandle = htobe64((uint64_t) (pQInfo));
rpcSendResponse(pConn, TSDB_CODE_SUCCESS, queryRsp, contLen);
}
static void dnodeProcessQueryMsg(void *pCont, int32_t contLen, void *pConn) {
atomic_fetch_add_32(&tsDnodeQueryReqNum, 1);
SQueryTableMsg *pQuery = (SQueryTableMsg *) pCont;
dnodeQueryData(pQuery, pConn, dnodeProcessQueryMsgCb);
}
void dnodeProcessRetrieveMsgCb(int32_t code, void *pQInfo, void *pConn) {
dTrace("conn:%p, retrieve is returned, code:%d", pConn, code);
assert(pConn != NULL);
if (code != TSDB_CODE_SUCCESS) {
rpcSendResponse(pConn, code, 0, 0);
return;
}
assert(pQInfo != NULL);
int32_t contLen = dnodeGetRetrieveDataSize(pQInfo);
SRetrieveTableRsp *pRetrieve = (SRetrieveTableRsp *) rpcMallocCont(contLen);
if (pRetrieve == NULL) {
rpcSendResponse(pConn, TSDB_CODE_SERV_OUT_OF_MEMORY, 0, 0);
return;
}
code = dnodeGetRetrieveData(pQInfo, pRetrieve);
if (code != TSDB_CODE_SUCCESS) {
rpcSendResponse(pConn, TSDB_CODE_INVALID_QHANDLE, 0, 0);
}
pRetrieve->numOfRows = htonl(pRetrieve->numOfRows);
pRetrieve->precision = htons(pRetrieve->precision);
pRetrieve->offset = htobe64(pRetrieve->offset);
pRetrieve->useconds = htobe64(pRetrieve->useconds);
rpcSendResponse(pConn, TSDB_CODE_SUCCESS, pRetrieve, contLen);
}
static void dnodeProcessRetrieveMsg(void *pCont, int32_t contLen, void *pConn) {
SRetrieveTableMsg *pRetrieve = (SRetrieveTableMsg *) pCont;
pRetrieve->qhandle = htobe64(pRetrieve->qhandle);
pRetrieve->free = htons(pRetrieve->free);
dnodeRetrieveData(pRetrieve, pConn, dnodeProcessRetrieveMsgCb);
}
void dnodeProcessSubmitMsgCb(SShellSubmitRspMsg *result, void *pConn) {
assert(result != NULL);
dTrace("conn:%p, submit is returned, code:%d", pConn, result->code);
if (result->code != 0) {
rpcSendResponse(pConn, result->code, NULL, 0);
return;
}
int32_t contLen = sizeof(SShellSubmitRspMsg) + result->numOfFailedBlocks * sizeof(SShellSubmitRspBlock);
SShellSubmitRspMsg *submitRsp = (SShellSubmitRspMsg *) rpcMallocCont(contLen);
if (submitRsp == NULL) {
rpcSendResponse(pConn, TSDB_CODE_SERV_OUT_OF_MEMORY, NULL, 0);
return;
}
memcpy(submitRsp, result, contLen);
for (int i = 0; i < submitRsp->numOfFailedBlocks; ++i) {
SShellSubmitRspBlock *block = &submitRsp->failedBlocks[i];
if (block->code == TSDB_CODE_NOT_ACTIVE_VNODE || block->code == TSDB_CODE_INVALID_VNODE_ID) {
dnodeSendVnodeCfgMsg(block->vnode);
} else if (block->code == TSDB_CODE_INVALID_TABLE_ID || block->code == TSDB_CODE_NOT_ACTIVE_TABLE) {
dnodeSendTableCfgMsg(block->vnode, block->sid);
}
block->index = htonl(block->index);
block->vnode = htonl(block->vnode);
block->sid = htonl(block->sid);
block->code = htonl(block->code);
}
submitRsp->code = htonl(submitRsp->code);
submitRsp->numOfRows = htonl(submitRsp->numOfRows);
submitRsp->affectedRows = htonl(submitRsp->affectedRows);
submitRsp->failedRows = htonl(submitRsp->failedRows);
submitRsp->numOfFailedBlocks = htonl(submitRsp->numOfFailedBlocks);
rpcSendResponse(pConn, TSDB_CODE_SUCCESS, submitRsp, contLen);
}
static void dnodeProcessSubmitMsg(void *pCont, int32_t contLen, void *pConn) {
atomic_fetch_add_32(&tsDnodeSubmitReqNum, 1);
SShellSubmitMsg *pSubmit = (SShellSubmitMsg *) pCont;
dnodeWriteData(pSubmit, pConn, dnodeProcessSubmitMsgCb);
}
src/dnode/src/dnodeSystem.c
浏览文件 @ b8fc28fb
...@@ -25,12 +25,12 @@ ...@@ -25,12 +25,12 @@
#include "ttimer.h" #include "ttimer.h"
#include "tutil.h" #include "tutil.h"
#include "http.h" #include "http.h"
#include "trpc.h"
#include "dnode.h" #include "dnode.h"
#include "dnodeMgmt.h" #include "dnodeMgmt.h"
#include "dnodeModule.h" #include "dnodeModule.h"
#include "dnodeShell.h" #include "dnodeShell.h"
#include "dnodeSystem.h" #include "dnodeSystem.h"
#include "dnodeVnodeMgmt.h"
#ifdef CLUSTER #ifdef CLUSTER
#include "account.h" #include "account.h"
...@@ -50,6 +50,11 @@ static int32_t dnodeInitRpcQHandle(); ...@@ -50,6 +50,11 @@ static int32_t dnodeInitRpcQHandle();
static int32_t dnodeInitQueryQHandle(); static int32_t dnodeInitQueryQHandle();
static int32_t dnodeInitTmrCtl(); static int32_t dnodeInitTmrCtl();
int32_t (*dnodeInitStorage)() = NULL;
void (*dnodeCleanupStorage)() = NULL;
int32_t (*dnodeInitPeers)(int32_t numOfThreads) = NULL;
void *tsDnodeTmr; void *tsDnodeTmr;
void **tsRpcQhandle; void **tsRpcQhandle;
void *tsDnodeMgmtQhandle; void *tsDnodeMgmtQhandle;
...@@ -93,7 +98,7 @@ void dnodeCleanUpSystem() { ...@@ -93,7 +98,7 @@ void dnodeCleanUpSystem() {
dnodeCleanupShell(); dnodeCleanupShell();
dnodeCleanUpModules(); dnodeCleanUpModules();
dnodeCleanupVnodes(); dnodeCleanupMgmt();
taosCloseLogger(); taosCloseLogger();
dnodeCleanupStorage(); dnodeCleanupStorage();
dnodeCleanVnodesLock(); dnodeCleanVnodesLock();
...@@ -154,7 +159,7 @@ int32_t dnodeInitSystem() { ...@@ -154,7 +159,7 @@ int32_t dnodeInitSystem() {
return -1; return -1;
} }
dnodeInitMgmtIp(); // dnodeInitMgmtIp();
tsPrintGlobalConfig(); tsPrintGlobalConfig();
...@@ -193,7 +198,7 @@ int32_t dnodeInitSystem() { ...@@ -193,7 +198,7 @@ int32_t dnodeInitSystem() {
return -1; return -1;
} }
if (dnodeOpenVnodes() < 0) { if (dnodeInitMgmt() < 0) {
dError("failed to init vnode storage"); dError("failed to init vnode storage");
return -1; return -1;
} }
...@@ -246,12 +251,6 @@ int32_t dnodeInitStorageImp() { ...@@ -246,12 +251,6 @@ int32_t dnodeInitStorageImp() {
return 0; return 0;
} }
int32_t (*dnodeInitStorage)() = dnodeInitStorageImp;
void dnodeCleanupStorageImp() {}
void (*dnodeCleanupStorage)() = dnodeCleanupStorageImp;
static int32_t dnodeInitQueryQHandle() { static int32_t dnodeInitQueryQHandle() {
int32_t numOfThreads = tsRatioOfQueryThreads * tsNumOfCores * tsNumOfThreadsPerCore; int32_t numOfThreads = tsRatioOfQueryThreads * tsNumOfCores * tsNumOfThreadsPerCore;
if (numOfThreads < 1) { if (numOfThreads < 1) {
...@@ -303,9 +302,3 @@ int32_t (*dnodeCheckSystem)() = dnodeCheckSystemImp; ...@@ -303,9 +302,3 @@ int32_t (*dnodeCheckSystem)() = dnodeCheckSystemImp;
int32_t dnodeInitPeersImp(int32_t numOfThreads) { int32_t dnodeInitPeersImp(int32_t numOfThreads) {
return 0; return 0;
} }
int32_t (*dnodeInitPeers)(int32_t numOfThreads) = dnodeInitPeersImp;
src/dnode/src/dnodeWrite.c
浏览文件 @ b8fc28fb
...@@ -17,82 +17,246 @@ ...@@ -17,82 +17,246 @@
#include "os.h" #include "os.h"
#include "taoserror.h" #include "taoserror.h"
#include "tlog.h" #include "tlog.h"
#include "tutil.h" #include "trpc.h"
#include "tqueue.h"
#include "taosmsg.h"
#include "dnodeWrite.h" #include "dnodeWrite.h"
#include "dnodeVnodeMgmt.h" #include "dnodeMgmt.h"
void dnodeWriteData(SShellSubmitMsg *pSubmit, void *pConn, void (*callback)(SShellSubmitRspMsg *rsp, void *pConn)) { typedef struct {
dTrace("submit msg is disposed, affectrows:1"); int32_t code;
int32_t count; // number of vnodes returned result
int32_t numOfVnodes; // number of vnodes involved
} SRpcContext;
SShellSubmitRspMsg result = {0}; typedef struct _write {
void *pCont;
int contLen;
SRpcMsg rpcMsg;
void *pVnode; // pointer to vnode
SRpcContext *pRpcContext; // RPC message context
} SWriteMsg;
int32_t numOfSid = htonl(pSubmit->numOfSid); typedef struct {
if (numOfSid <= 0) { taos_qset qset; // queue set
dError("invalid num of tables:%d", numOfSid); pthread_t thread; // thread
result.code = TSDB_CODE_INVALID_QUERY_MSG; int workerId; // worker ID
callback(&result, pConn); } SWriteWorker;
typedef struct _thread_obj {
int max; // max number of workers
int nextId; // from 0 to max-1, cyclic
SWriteWorker *writeWorker;
} SWriteWorkerPool;
static void (*dnodeProcessWriteMsgFp[TSDB_MSG_TYPE_MAX])(SWriteMsg *);
static void *dnodeProcessWriteQueue(void *param);
static void dnodeHandleIdleWorker(SWriteWorker *pWorker);
static void dnodeProcessWriteResult(SWriteMsg *pWrite);
static void dnodeProcessSubmitMsg(SWriteMsg *pMsg);
static void dnodeProcessCreateTableMsg(SWriteMsg *pMsg);
static void dnodeProcessDropTableMsg(SWriteMsg *pMsg);
SWriteWorkerPool wWorkerPool;
int dnodeInitWrite() {
dnodeProcessWriteMsgFp[TSDB_MSG_TYPE_SUBMIT] = dnodeProcessSubmitMsg;
dnodeProcessWriteMsgFp[TSDB_MSG_TYPE_DNODE_CREATE_TABLE] = dnodeProcessCreateTableMsg;
dnodeProcessWriteMsgFp[TSDB_MSG_TYPE_DNODE_REMOVE_TABLE] = dnodeProcessDropTableMsg;
wWorkerPool.max = tsNumOfCores;
wWorkerPool.writeWorker = (SWriteWorker *)calloc(sizeof(SWriteWorker), wWorkerPool.max);
if (wWorkerPool.writeWorker == NULL) return -1;
for (int i=0; i<wWorkerPool.max; ++i) {
wWorkerPool.writeWorker[i].workerId = i;
}
return 0;
}
void dnodeCleanupWrite() {
free(wWorkerPool.writeWorker);
}
void dnodeWrite(SRpcMsg *pMsg) {
int leftLen = pMsg->contLen;
char *pCont = (char *)pMsg->pCont;
int contLen = 0;
int numOfVnodes = 0;
int32_t vgId = 0;
SRpcContext *pRpcContext = NULL;
// parse head, get number of vnodes;
if ( numOfVnodes > 1) {
pRpcContext = calloc(sizeof(SRpcContext), 1);
pRpcContext->numOfVnodes = numOfVnodes;
}
while (leftLen > 0) {
// todo: parse head, get vgId, contLen
// get pVnode from vgId
void *pVnode = dnodeGetVnode(vgId);
if (pVnode == NULL) {
continue;
}
// put message into queue
SWriteMsg writeMsg;
writeMsg.rpcMsg = *pMsg;
writeMsg.pCont = pCont;
writeMsg.contLen = contLen;
writeMsg.pRpcContext = pRpcContext;
writeMsg.pVnode = pVnode; // pVnode shall be saved for usage later
taos_queue queue = dnodeGetVnodeWworker(pVnode);
taosWriteQitem(queue, &writeMsg);
// next vnode
leftLen -= contLen;
pCont -= contLen;
}
}
void *dnodeAllocateWriteWorker() {
SWriteWorker *pWorker = wWorkerPool.writeWorker + wWorkerPool.nextId;
if (pWorker->qset == NULL) {
pWorker->qset = taosOpenQset();
if (pWorker->qset == NULL) return NULL;
pthread_attr_t thAttr;
pthread_attr_init(&thAttr);
pthread_attr_setdetachstate(&thAttr, PTHREAD_CREATE_JOINABLE);
if (pthread_create(&pWorker->thread, &thAttr, dnodeProcessWriteQueue, pWorker) != 0) {
dError("failed to create thread to process read queue, reason:%s", strerror(errno));
taosCloseQset(pWorker->qset);
} }
}
taos_queue *queue = taosOpenQueue(sizeof(SWriteMsg));
if (queue) {
taosAddIntoQset(pWorker->qset, queue);
wWorkerPool.nextId = (wWorkerPool.nextId + 1) % wWorkerPool.max;
}
return queue;
}
void dnodeFreeWriteWorker(void *wqueue) {
result.code = 0; taosCloseQueue(wqueue);
result.numOfRows = 1;
result.affectedRows = 1; // dynamically adjust the number of threads
result.numOfFailedBlocks = 0;
callback(&result, pConn);
} }
int32_t dnodeCreateTable(SDCreateTableMsg *pTable) { static void *dnodeProcessWriteQueue(void *param) {
if (pTable->tableType == TSDB_TABLE_TYPE_CHILD_TABLE) { SWriteWorker *pWorker = (SWriteWorker *)param;
dTrace("table:%s, start to create child table, stable:%s", pTable->tableId, pTable->superTableId); taos_qall qall;
} else if (pTable->tableType == TSDB_TABLE_TYPE_NORMAL_TABLE){ SWriteMsg writeMsg;
dTrace("table:%s, start to create normal table", pTable->tableId); int numOfMsgs;
} else if (pTable->tableType == TSDB_TABLE_TYPE_STREAM_TABLE){
dTrace("table:%s, start to create stream table", pTable->tableId); while (1) {
numOfMsgs = taosReadAllQitemsFromQset(pWorker->qset, &qall);
if (numOfMsgs <=0) {
dnodeHandleIdleWorker(pWorker); // thread exit if no queues anymore
continue;
}
for (int i=0; i<numOfMsgs; ++i) {
// retrieve all items, and write them into WAL
taosGetQitem(qall, &writeMsg);
// walWrite(pVnode->whandle, writeMsg.rpcMsg.msgType, writeMsg.pCont, writeMsg.contLen);
}
// flush WAL file
// walFsync(pVnode->whandle);
// browse all items, and process them one by one
taosResetQitems(qall);
for (int i=0; i<numOfMsgs; ++i) {
taosGetQitem(qall, &writeMsg);
terrno = 0;
if (dnodeProcessWriteMsgFp[writeMsg.rpcMsg.msgType]) {
(*dnodeProcessWriteMsgFp[writeMsg.rpcMsg.msgType]) (&writeMsg);
} else { } else {
dError("table:%s, invalid table type:%d", pTable->tableType); terrno = TSDB_CODE_MSG_NOT_PROCESSED;
} }
for (int i = 0; i < pTable->numOfVPeers; ++i) { dnodeProcessWriteResult(&writeMsg);
dTrace("table:%s ip:%s vnode:%d sid:%d", pTable->tableId, taosIpStr(pTable->vpeerDesc[i].ip),
pTable->vpeerDesc[i].vnode, pTable->sid);
} }
SSchema *pSchema = (SSchema *) pTable->data; // free the Qitems;
for (int32_t col = 0; col < pTable->numOfColumns; ++col) { taosFreeQitems(qall);
dTrace("table:%s col index:%d colId:%d bytes:%d type:%d name:%s",
pTable->tableId, col, pSchema->colId, pSchema->bytes, pSchema->type, pSchema->name);
pSchema++;
} }
for (int32_t col = 0; col < pTable->numOfTags; ++col) {
dTrace("table:%s tag index:%d colId:%d bytes:%d type:%d name:%s", return NULL;
pTable->tableId, col, pSchema->colId, pSchema->bytes, pSchema->type, pSchema->name); }
pSchema++;
static void dnodeProcessWriteResult(SWriteMsg *pWrite) {
SRpcContext *pRpcContext = pWrite->pRpcContext;
int32_t code = 0;
dnodeReleaseVnode(pWrite->pVnode);
if (pRpcContext) {
if (terrno) {
if (pRpcContext->code == 0) pRpcContext->code = terrno;
}
int count = atomic_add_fetch_32(&pRpcContext->count, 1);
if (count < pRpcContext->numOfVnodes) {
// not over yet, multiple vnodes
return;
}
// over, result can be merged now
code = pRpcContext->code;
} else {
code = terrno;
} }
return TSDB_CODE_SUCCESS; SRpcMsg rsp;
rsp.handle = pWrite->rpcMsg.handle;
rsp.code = code;
rsp.pCont = NULL;
rpcSendResponse(&rsp);
rpcFreeCont(pWrite->rpcMsg.pCont); // free the received message
} }
/* static void dnodeHandleIdleWorker(SWriteWorker *pWorker) {
* Remove table from local repository
*/ int num = taosGetQueueNumber(pWorker->qset);
int32_t dnodeDropTable(SDRemoveTableMsg *pTable) {
dPrint("table:%s, sid:%d is removed", pTable->tableId, pTable->sid); if (num > 0) {
return TSDB_CODE_SUCCESS; usleep(100);
sched_yield();
} else {
taosCloseQset(pWorker->qset);
pWorker->qset = NULL;
pthread_exit(NULL);
}
} }
/* static void dnodeProcessSubmitMsg(SWriteMsg *pMsg) {
* Create stream
* if stream already exist, update it
*/
int32_t dnodeCreateStream(SDAlterStreamMsg *pStream) {
dPrint("stream:%s, is created, ", pStream->tableId);
return TSDB_CODE_SUCCESS;
} }
/* static void dnodeProcessCreateTableMsg(SWriteMsg *pMsg) {
* Remove all child tables of supertable from local repository
*/
int32_t dnodeDropSuperTable(SDRemoveSuperTableMsg *pStable) {
dPrint("stable:%s, is removed", pStable->tableId);
return TSDB_CODE_SUCCESS;
} }
static void dnodeProcessDropTableMsg(SWriteMsg *pMsg) {
}
src/mnode/inc/mgmtShell.h
浏览文件 @ b8fc28fb
...@@ -28,8 +28,6 @@ int32_t mgmtInitShell(); ...@@ -28,8 +28,6 @@ int32_t mgmtInitShell();
void mgmtCleanUpShell(); void mgmtCleanUpShell();
extern int32_t (*mgmtCheckRedirectMsg)(void *pConn); extern int32_t (*mgmtCheckRedirectMsg)(void *pConn);
extern void (*mgmtProcessCfgMnodeMsg)(void *pCont, int32_t contLen, void *ahandle);
extern void (*mgmtProcessDropMnodeMsg)(void *pCont, int32_t contLen, void *ahandle);
/* /*
* If table not exist, will create it * If table not exist, will create it
......
src/mnode/src/mgmtDnodeInt.c
浏览文件 @ b8fc28fb
...@@ -48,7 +48,7 @@ static void mgmtSendMsgToDnodeQueueFp(SSchedMsg *sched) { ...@@ -48,7 +48,7 @@ static void mgmtSendMsgToDnodeQueueFp(SSchedMsg *sched) {
void *ahandle = sched->ahandle; void *ahandle = sched->ahandle;
int8_t *pCont = sched->msg; int8_t *pCont = sched->msg;
dnodeProcessMsgFromMgmt(msgType, pCont, contLen, ahandle, code); // dnodeProcessMsgFromMgmt(msgType, pCont, contLen, ahandle, code);
} }
void mgmtSendMsgToDnode(SRpcIpSet *ipSet, int8_t msgType, void *pCont, int32_t contLen, void *ahandle) { void mgmtSendMsgToDnode(SRpcIpSet *ipSet, int8_t msgType, void *pCont, int32_t contLen, void *ahandle) {
...@@ -157,13 +157,19 @@ static void mgmtProcessCreateTableRsp(int8_t msgType, int8_t *pCont, int32_t con ...@@ -157,13 +157,19 @@ static void mgmtProcessCreateTableRsp(int8_t msgType, int8_t *pCont, int32_t con
} }
if (code != TSDB_CODE_SUCCESS) { if (code != TSDB_CODE_SUCCESS) {
rpcSendResponse(info->thandle, code, NULL, 0); SRpcMsg rpcMsg = {0};
rpcMsg.code = code;
rpcMsg.handle = info->thandle;
rpcSendResponse(&rpcMsg);
} else { } else {
if (info->type == TSDB_PROCESS_CREATE_TABLE_GET_META) { if (info->type == TSDB_PROCESS_CREATE_TABLE_GET_META) {
mTrace("table:%s, start to process get meta", pTable->tableId); mTrace("table:%s, start to process get meta", pTable->tableId);
mgmtProcessGetTableMeta(pTable, thandle); mgmtProcessGetTableMeta(pTable, thandle);
} else { } else {
rpcSendResponse(info->thandle, code, NULL, 0); SRpcMsg rpcMsg = {0};
rpcMsg.code = code;
rpcMsg.handle = info->thandle;
rpcSendResponse(&rpcMsg);
} }
} }
...@@ -236,7 +242,11 @@ static void mgmtProcessDnodeGrantMsg(void *pCont, void *thandle) { ...@@ -236,7 +242,11 @@ static void mgmtProcessDnodeGrantMsg(void *pCont, void *thandle) {
mgmtUpdateGrantInfoFp(pCont); mgmtUpdateGrantInfoFp(pCont);
mTrace("grant info is updated"); mTrace("grant info is updated");
} }
rpcSendResponse(thandle, TSDB_CODE_SUCCESS, NULL, 0);
SRpcMsg rpcMsg = {0};
rpcMsg.code = TSDB_CODE_SUCCESS;
rpcMsg.handle = thandle;
rpcSendResponse(&rpcMsg);
} }
void mgmtProcessMsgFromDnode(char msgType, void *pCont, int32_t contLen, void *pConn, int32_t code) { void mgmtProcessMsgFromDnode(char msgType, void *pCont, int32_t contLen, void *pConn, int32_t code) {
...@@ -368,7 +378,7 @@ int32_t mgmtSendCfgDnodeMsg(char *cont) { ...@@ -368,7 +378,7 @@ int32_t mgmtSendCfgDnodeMsg(char *cont) {
//#else //#else
// (void)tsCfgDynamicOptions(pCfg->config); // (void)tsCfgDynamicOptions(pCfg->config);
//#endif //#endif
// return 0; return 0;
} }
int32_t mgmtInitDnodeInt() { int32_t mgmtInitDnodeInt() {
......
src/mnode/src/mgmtShell.c
浏览文件 @ b8fc28fb
...@@ -46,34 +46,36 @@ static RetrieveMetaFp mgmtRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0}; ...@@ -46,34 +46,36 @@ static RetrieveMetaFp mgmtRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0};
static void mgmtInitShowMsgFp(); static void mgmtInitShowMsgFp();
static void mgmtInitProcessShellMsg(); static void mgmtInitProcessShellMsg();
static void mgmtProcessMsgFromShell(char type, void *pCont, int contLen, void *ahandle, int32_t code); static void mgmtProcessMsgFromShell(SRpcMsg *msg);
static void (*mgmtProcessShellMsg[TSDB_MSG_TYPE_MAX])(void *pCont, int32_t contLen, void *ahandle); static void (*mgmtProcessShellMsg[TSDB_MSG_TYPE_MAX])(SRpcMsg *msg);
static void mgmtProcessUnSupportMsg(void *pCont, int32_t contLen, void *ahandle); static void mgmtProcessUnSupportMsg(SRpcMsg *msg);
static int mgmtRetriveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey); static int mgmtRetriveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey);
void *tsShellConnServer = NULL; void *tsShellConnServer = NULL;
void mgmtProcessTranRequest(SSchedMsg *sched) { void mgmtProcessTranRequest(SSchedMsg *sched) {
int8_t msgType = *(int8_t *) (sched->msg); SRpcMsg rpcMsg;
int32_t contLen = *(int32_t *) (sched->msg + sizeof(int8_t)); rpcMsg.msgType = *(int8_t *) (sched->msg);
int8_t *pCont = sched->msg + sizeof(int32_t) + sizeof(int8_t); rpcMsg.contLen = *(int32_t *) (sched->msg + sizeof(int8_t));
void *pConn = sched->thandle; rpcMsg.pCont = sched->msg + sizeof(int32_t) + sizeof(int8_t);
rpcMsg.handle = sched->thandle;
(*mgmtProcessShellMsg[msgType])(pCont, contLen, pConn); rpcMsg.code = TSDB_CODE_SUCCESS;
(*mgmtProcessShellMsg[rpcMsg.msgType])(&rpcMsg);
if (sched->msg) { if (sched->msg) {
free(sched->msg); free(sched->msg);
} }
} }
void mgmtAddToTranRequest(int8_t type, void *pCont, int contLen, void *ahandle) { void mgmtAddToTranRequest(SRpcMsg *rpcMsg) {
SSchedMsg schedMsg; SSchedMsg schedMsg;
schedMsg.msg = malloc(contLen + sizeof(int32_t) + sizeof(int8_t)); schedMsg.msg = malloc(rpcMsg->contLen + sizeof(int32_t) + sizeof(int8_t));
schedMsg.fp = mgmtProcessTranRequest; schedMsg.fp = mgmtProcessTranRequest;
schedMsg.tfp = NULL; schedMsg.tfp = NULL;
schedMsg.thandle = ahandle; schedMsg.thandle = rpcMsg->handle;
*(int8_t *) (schedMsg.msg) = type; *(int8_t *) (schedMsg.msg) = rpcMsg->msgType;
*(int32_t *) (schedMsg.msg + sizeof(int8_t)) = contLen; *(int32_t *) (schedMsg.msg + sizeof(int8_t)) = rpcMsg->contLen;
memcpy(schedMsg.msg + sizeof(int32_t) + sizeof(int8_t), pCont, contLen); memcpy(schedMsg.msg + sizeof(int32_t) + sizeof(int8_t), rpcMsg->pCont, rpcMsg->contLen);
taosScheduleTask(tsMgmtTranQhandle, &schedMsg); taosScheduleTask(tsMgmtTranQhandle, &schedMsg);
} }
...@@ -115,14 +117,20 @@ void mgmtCleanUpShell() { ...@@ -115,14 +117,20 @@ void mgmtCleanUpShell() {
} }
} }
void mgmtProcessTableMetaMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessTableMetaMsg(SRpcMsg *rpcMsg) {
STableInfoMsg *pInfo = pCont; SRpcMsg rpcRsp;
rpcRsp.handle = rpcMsg->handle;
rpcRsp.pCont = NULL;
rpcRsp.contLen = 0;
STableInfoMsg *pInfo = rpcMsg->pCont;
pInfo->createFlag = htons(pInfo->createFlag); pInfo->createFlag = htons(pInfo->createFlag);
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
mError("table:%s, failed to get table meta, invalid user", pInfo->tableId); mError("table:%s, failed to get table meta, invalid user", pInfo->tableId);
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -130,19 +138,22 @@ void mgmtProcessTableMetaMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -130,19 +138,22 @@ void mgmtProcessTableMetaMsg(void *pCont, int32_t contLen, void *ahandle) {
if (pTable == NULL) { if (pTable == NULL) {
if (pInfo->createFlag != 1) { if (pInfo->createFlag != 1) {
mError("table:%s, failed to get table meta, table not exist", pInfo->tableId); mError("table:%s, failed to get table meta, table not exist", pInfo->tableId);
rpcSendResponse(ahandle, TSDB_CODE_INVALID_TABLE, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_TABLE;
rpcSendResponse(&rpcRsp);
return; return;
} else { } else {
// on demand create table from super table if table does not exists // on demand create table from super table if table does not exists
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
mError("table:%s, failed to create table while get meta info, need redirect message", pInfo->tableId); mError("table:%s, failed to create table while get meta info, need redirect message", pInfo->tableId);
return; return;
} }
SCreateTableMsg *pCreateMsg = rpcMallocCont(sizeof(SCreateTableMsg) + sizeof(STagData)); int32_t contLen = sizeof(SCreateTableMsg) + sizeof(STagData);
SCreateTableMsg *pCreateMsg = rpcMallocCont(contLen);
if (pCreateMsg == NULL) { if (pCreateMsg == NULL) {
mError("table:%s, failed to create table while get meta info, no enough memory", pInfo->tableId); mError("table:%s, failed to create table while get meta info, no enough memory", pInfo->tableId);
rpcSendResponse(ahandle, TSDB_CODE_SERV_OUT_OF_MEMORY, NULL, 0); rpcRsp.code = TSDB_CODE_SERV_OUT_OF_MEMORY;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -150,31 +161,38 @@ void mgmtProcessTableMetaMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -150,31 +161,38 @@ void mgmtProcessTableMetaMsg(void *pCont, int32_t contLen, void *ahandle) {
strcpy(pCreateMsg->tableId, pInfo->tableId); strcpy(pCreateMsg->tableId, pInfo->tableId);
mError("table:%s, start to create table while get meta info", pInfo->tableId); mError("table:%s, start to create table while get meta info", pInfo->tableId);
mgmtCreateTable(pCreateMsg, contLen, ahandle, true); mgmtCreateTable(pCreateMsg, contLen, rpcMsg->handle, true);
} }
} else { } else {
mgmtProcessGetTableMeta(pTable, ahandle); mgmtProcessGetTableMeta(pTable, rpcMsg->handle);
} }
} }
void mgmtProcessMultiTableMetaMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessMultiTableMetaMsg(SRpcMsg *rpcMsg) {
SRpcMsg rpcRsp;
rpcRsp.handle = rpcMsg->handle;
rpcRsp.pCont = NULL;
rpcRsp.contLen = 0;
SRpcConnInfo connInfo; SRpcConnInfo connInfo;
rpcGetConnInfo(ahandle, &connInfo); rpcGetConnInfo(rpcMsg->handle, &connInfo);
bool usePublicIp = (connInfo.serverIp == tsPublicIpInt); bool usePublicIp = (connInfo.serverIp == tsPublicIpInt);
SUserObj *pUser = mgmtGetUser(connInfo.user); SUserObj *pUser = mgmtGetUser(connInfo.user);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
SMultiTableInfoMsg *pInfo = pCont; SMultiTableInfoMsg *pInfo = rpcMsg->pCont;
pInfo->numOfTables = htonl(pInfo->numOfTables); pInfo->numOfTables = htonl(pInfo->numOfTables);
int32_t totalMallocLen = 4*1024*1024; // first malloc 4 MB, subsequent reallocation as twice int32_t totalMallocLen = 4*1024*1024; // first malloc 4 MB, subsequent reallocation as twice
SMultiTableMeta *pMultiMeta = rpcMallocCont(totalMallocLen); SMultiTableMeta *pMultiMeta = rpcMallocCont(totalMallocLen);
if (pMultiMeta == NULL) { if (pMultiMeta == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_SERV_OUT_OF_MEMORY, NULL, 0); rpcRsp.code = TSDB_CODE_SERV_OUT_OF_MEMORY;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -211,43 +229,48 @@ void mgmtProcessMultiTableMetaMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -211,43 +229,48 @@ void mgmtProcessMultiTableMetaMsg(void *pCont, int32_t contLen, void *ahandle) {
} }
} }
rpcSendResponse(ahandle, TSDB_CODE_SUCCESS, pMultiMeta, pMultiMeta->contLen); rpcRsp.pCont = pMultiMeta;
rpcRsp.contLen = pMultiMeta->contLen;
rpcSendResponse(&rpcRsp);
} }
void mgmtProcessSuperTableMetaMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessSuperTableMetaMsg(SRpcMsg *rpcMsg) {
SRpcConnInfo connInfo; SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
rpcGetConnInfo(ahandle, &connInfo); SSuperTableInfoMsg *pInfo = rpcMsg->pCont;
// bool usePublicIp = (connInfo.serverIp == tsPublicIpInt);
SSuperTableInfoMsg *pInfo = pCont;
STableInfo *pTable = mgmtGetSuperTable(pInfo->tableId); STableInfo *pTable = mgmtGetSuperTable(pInfo->tableId);
if (pTable == NULL) { if (pTable == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_TABLE, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_TABLE;
rpcSendResponse(&rpcRsp);
return; return;
} }
SSuperTableInfoRsp *pRsp = mgmtGetSuperTableVgroup((SSuperTableObj *) pTable); SSuperTableInfoRsp *pRsp = mgmtGetSuperTableVgroup((SSuperTableObj *) pTable);
if (pRsp != NULL) { if (pRsp != NULL) {
int32_t msgLen = sizeof(SSuperTableObj) + htonl(pRsp->numOfDnodes) * sizeof(int32_t); int32_t msgLen = sizeof(SSuperTableObj) + htonl(pRsp->numOfDnodes) * sizeof(int32_t);
rpcSendResponse(ahandle, TSDB_CODE_SUCCESS, pRsp, msgLen); rpcRsp.pCont = pRsp;
rpcRsp.contLen = msgLen;
rpcSendResponse(&rpcRsp);
} else { } else {
rpcSendResponse(ahandle, TSDB_CODE_SUCCESS, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_TABLE;
rpcSendResponse(&rpcRsp);
} }
} }
void mgmtProcessCreateDbMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessCreateDbMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
SCreateDbMsg *pCreate = (SCreateDbMsg *) pCont; SCreateDbMsg *pCreate = (SCreateDbMsg *) rpcMsg->pCont;
pCreate->maxSessions = htonl(pCreate->maxSessions); pCreate->maxSessions = htonl(pCreate->maxSessions);
pCreate->cacheBlockSize = htonl(pCreate->cacheBlockSize); pCreate->cacheBlockSize = htonl(pCreate->cacheBlockSize);
...@@ -272,21 +295,24 @@ void mgmtProcessCreateDbMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -272,21 +295,24 @@ void mgmtProcessCreateDbMsg(void *pCont, int32_t contLen, void *ahandle) {
} }
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
void mgmtProcessAlterDbMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessAlterDbMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
SAlterDbMsg *pAlter = (SAlterDbMsg *) pCont; SAlterDbMsg *pAlter = (SAlterDbMsg *) rpcMsg->pCont;
pAlter->daysPerFile = htonl(pAlter->daysPerFile); pAlter->daysPerFile = htonl(pAlter->daysPerFile);
pAlter->daysToKeep = htonl(pAlter->daysToKeep); pAlter->daysToKeep = htonl(pAlter->daysToKeep);
pAlter->maxSessions = htonl(pAlter->maxSessions) + 1; pAlter->maxSessions = htonl(pAlter->maxSessions) + 1;
...@@ -301,92 +327,104 @@ void mgmtProcessAlterDbMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -301,92 +327,104 @@ void mgmtProcessAlterDbMsg(void *pCont, int32_t contLen, void *ahandle) {
} }
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
void mgmtProcessKillQueryMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessKillQueryMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
SKillQueryMsg *pKill = (SKillQueryMsg *) pCont; SKillQueryMsg *pKill = (SKillQueryMsg *) rpcMsg->pCont;
int32_t code; int32_t code;
if (!pUser->writeAuth) { if (!pUser->writeAuth) {
code = TSDB_CODE_NO_RIGHTS; code = TSDB_CODE_NO_RIGHTS;
} else { } else {
code = mgmtKillQuery(pKill->queryId, ahandle); code = mgmtKillQuery(pKill->queryId, rpcMsg->handle);
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
void mgmtProcessKillStreamMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessKillStreamMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
SKillStreamMsg *pKill = (SKillStreamMsg *) pCont; SKillStreamMsg *pKill = (SKillStreamMsg *) rpcMsg->pCont;
int32_t code; int32_t code;
if (!pUser->writeAuth) { if (!pUser->writeAuth) {
code = TSDB_CODE_NO_RIGHTS; code = TSDB_CODE_NO_RIGHTS;
} else { } else {
code = mgmtKillStream(pKill->queryId, ahandle); code = mgmtKillStream(pKill->queryId, rpcMsg->handle);
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
void mgmtProcessKillConnectionMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessKillConnectionMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
SKillConnectionMsg *pKill = (SKillConnectionMsg *) pCont; SKillConnectionMsg *pKill = (SKillConnectionMsg *) rpcMsg->pCont;
int32_t code; int32_t code;
if (!pUser->writeAuth) { if (!pUser->writeAuth) {
code = TSDB_CODE_NO_RIGHTS; code = TSDB_CODE_NO_RIGHTS;
} else { } else {
code = mgmtKillConnection(pKill->queryId, ahandle); code = mgmtKillConnection(pKill->queryId, rpcMsg->handle);
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
void mgmtProcessCreateUserMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessCreateUserMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
int32_t code; int32_t code;
if (pUser->superAuth) { if (pUser->superAuth) {
SCreateUserMsg *pCreate = pCont; SCreateUserMsg *pCreate = rpcMsg->pCont;
code = mgmtCreateUser(pUser->pAcct, pCreate->user, pCreate->pass); code = mgmtCreateUser(pUser->pAcct, pCreate->user, pCreate->pass);
if (code == TSDB_CODE_SUCCESS) { if (code == TSDB_CODE_SUCCESS) {
mLPrint("user:%s is created by %s", pCreate->user, pUser->user); mLPrint("user:%s is created by %s", pCreate->user, pUser->user);
...@@ -395,29 +433,34 @@ void mgmtProcessCreateUserMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -395,29 +433,34 @@ void mgmtProcessCreateUserMsg(void *pCont, int32_t contLen, void *ahandle) {
code = TSDB_CODE_NO_RIGHTS; code = TSDB_CODE_NO_RIGHTS;
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
void mgmtProcessAlterUserMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessAlterUserMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
SUserObj *pOperUser = mgmtGetUserFromConn(ahandle); SUserObj *pOperUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pOperUser == NULL) { if (pOperUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
SAlterUserMsg *pAlter = pCont; SAlterUserMsg *pAlter = rpcMsg->pCont;
SUserObj *pUser = mgmtGetUser(pAlter->user); SUserObj *pUser = mgmtGetUser(pAlter->user);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) { if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
rpcSendResponse(ahandle, TSDB_CODE_NO_RIGHTS, NULL, 0); rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -447,7 +490,9 @@ void mgmtProcessAlterUserMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -447,7 +490,9 @@ void mgmtProcessAlterUserMsg(void *pCont, int32_t contLen, void *ahandle) {
code = TSDB_CODE_NO_RIGHTS; code = TSDB_CODE_NO_RIGHTS;
} }
rpcSendResponse(ahandle, code, NULL, 0);
rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -496,34 +541,40 @@ void mgmtProcessAlterUserMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -496,34 +541,40 @@ void mgmtProcessAlterUserMsg(void *pCont, int32_t contLen, void *ahandle) {
code = TSDB_CODE_NO_RIGHTS; code = TSDB_CODE_NO_RIGHTS;
} }
rpcSendResponse(ahandle, code, NULL, 0);
rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
return; return;
} }
code = TSDB_CODE_NO_RIGHTS; rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(ahandle, code, NULL, 0); rpcSendResponse(&rpcRsp);
} }
void mgmtProcessDropUserMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessDropUserMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return ; return ;
} }
SUserObj *pOperUser = mgmtGetUserFromConn(ahandle); SUserObj *pOperUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pOperUser == NULL) { if (pOperUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return ; return ;
} }
SDropUserMsg *pDrop = pCont; SDropUserMsg *pDrop = rpcMsg->pCont;
SUserObj *pUser = mgmtGetUser(pDrop->user); SUserObj *pUser = mgmtGetUser(pDrop->user);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return ; return ;
} }
if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) { if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
rpcSendResponse(ahandle, TSDB_CODE_NO_RIGHTS, NULL, 0); rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(&rpcRsp);
return ; return ;
} }
...@@ -554,23 +605,26 @@ void mgmtProcessDropUserMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -554,23 +605,26 @@ void mgmtProcessDropUserMsg(void *pCont, int32_t contLen, void *ahandle) {
code = TSDB_CODE_NO_RIGHTS; code = TSDB_CODE_NO_RIGHTS;
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
void mgmtProcessDropDbMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessDropDbMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return ; return ;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return ; return ;
} }
int32_t code; int32_t code;
if (pUser->superAuth) { if (pUser->superAuth) {
SDropDbMsg *pDrop = pCont; SDropDbMsg *pDrop = rpcMsg->pCont;
code = mgmtDropDbByName(pUser->pAcct, pDrop->db, pDrop->ignoreNotExists); code = mgmtDropDbByName(pUser->pAcct, pDrop->db, pDrop->ignoreNotExists);
if (code == TSDB_CODE_SUCCESS) { if (code == TSDB_CODE_SUCCESS) {
mLPrint("DB:%s is dropped by %s", pDrop->db, pUser->user); mLPrint("DB:%s is dropped by %s", pDrop->db, pUser->user);
...@@ -579,7 +633,8 @@ void mgmtProcessDropDbMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -579,7 +633,8 @@ void mgmtProcessDropDbMsg(void *pCont, int32_t contLen, void *ahandle) {
code = TSDB_CODE_NO_RIGHTS; code = TSDB_CODE_NO_RIGHTS;
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
static void mgmtInitShowMsgFp() { static void mgmtInitShowMsgFp() {
...@@ -618,10 +673,12 @@ static void mgmtInitShowMsgFp() { ...@@ -618,10 +673,12 @@ static void mgmtInitShowMsgFp() {
mgmtRetrieveFp[TSDB_MGMT_TABLE_VNODES] = mgmtRetrieveVnodes; mgmtRetrieveFp[TSDB_MGMT_TABLE_VNODES] = mgmtRetrieveVnodes;
} }
void mgmtProcessShowMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessShowMsg(SRpcMsg *rpcMsg) {
SShowMsg *pShowMsg = pCont; SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
SShowMsg *pShowMsg = rpcMsg->pCont;
if (pShowMsg->type == TSDB_MGMT_TABLE_DNODE || TSDB_MGMT_TABLE_GRANTS || TSDB_MGMT_TABLE_SCORES) { if (pShowMsg->type == TSDB_MGMT_TABLE_DNODE || TSDB_MGMT_TABLE_GRANTS || TSDB_MGMT_TABLE_SCORES) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
} }
...@@ -629,7 +686,8 @@ void mgmtProcessShowMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -629,7 +686,8 @@ void mgmtProcessShowMsg(void *pCont, int32_t contLen, void *ahandle) {
int32_t size = sizeof(SShowRsp) + sizeof(SSchema) * TSDB_MAX_COLUMNS + TSDB_EXTRA_PAYLOAD_SIZE; int32_t size = sizeof(SShowRsp) + sizeof(SSchema) * TSDB_MAX_COLUMNS + TSDB_EXTRA_PAYLOAD_SIZE;
SShowRsp *pShowRsp = rpcMallocCont(size); SShowRsp *pShowRsp = rpcMallocCont(size);
if (pShowRsp == NULL) { if (pShowRsp == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_SERV_OUT_OF_MEMORY, NULL, 0); rpcRsp.code = TSDB_CODE_SERV_OUT_OF_MEMORY;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -649,7 +707,7 @@ void mgmtProcessShowMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -649,7 +707,7 @@ void mgmtProcessShowMsg(void *pCont, int32_t contLen, void *ahandle) {
mgmtSaveQhandle(pShow); mgmtSaveQhandle(pShow);
pShowRsp->qhandle = htobe64((uint64_t) pShow); pShowRsp->qhandle = htobe64((uint64_t) pShow);
code = (*mgmtGetMetaFp[(uint8_t) pShowMsg->type])(&pShowRsp->tableMeta, pShow, ahandle); code = (*mgmtGetMetaFp[(uint8_t) pShowMsg->type])(&pShowRsp->tableMeta, pShow, rpcMsg->handle);
if (code == 0) { if (code == 0) {
size = sizeof(SShowRsp) + sizeof(SSchema) * pShow->numOfColumns; size = sizeof(SShowRsp) + sizeof(SSchema) * pShow->numOfColumns;
} else { } else {
...@@ -659,14 +717,18 @@ void mgmtProcessShowMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -659,14 +717,18 @@ void mgmtProcessShowMsg(void *pCont, int32_t contLen, void *ahandle) {
} }
} }
rpcSendResponse(ahandle, code, pShowRsp, size); rpcRsp.pCont = pShowRsp;
rpcRsp.contLen = size;
rpcSendResponse(&rpcRsp);
} }
void mgmtProcessRetrieveMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessRetrieveMsg(SRpcMsg *rpcMsg) {
SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
int32_t rowsToRead = 0; int32_t rowsToRead = 0;
int32_t size = 0; int32_t size = 0;
int32_t rowsRead = 0; int32_t rowsRead = 0;
SRetrieveTableMsg *pRetrieve = (SRetrieveTableMsg *)pCont; SRetrieveTableMsg *pRetrieve = (SRetrieveTableMsg *) rpcMsg->pCont;
pRetrieve->qhandle = htobe64(pRetrieve->qhandle); pRetrieve->qhandle = htobe64(pRetrieve->qhandle);
/* /*
...@@ -675,14 +737,16 @@ void mgmtProcessRetrieveMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -675,14 +737,16 @@ void mgmtProcessRetrieveMsg(void *pCont, int32_t contLen, void *ahandle) {
*/ */
if (!mgmtCheckQhandle(pRetrieve->qhandle)) { if (!mgmtCheckQhandle(pRetrieve->qhandle)) {
mError("retrieve:%p, qhandle:%p is invalid", pRetrieve, pRetrieve->qhandle); mError("retrieve:%p, qhandle:%p is invalid", pRetrieve, pRetrieve->qhandle);
rpcSendResponse(ahandle, TSDB_CODE_INVALID_QHANDLE, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_QHANDLE;
rpcSendResponse(&rpcRsp);
return; return;
} }
SShowObj *pShow = (SShowObj *)pRetrieve->qhandle; SShowObj *pShow = (SShowObj *)pRetrieve->qhandle;
if (pShow->signature != (void *)pShow) { if (pShow->signature != (void *)pShow) {
mError("pShow:%p, signature:%p, query memory is corrupted", pShow, pShow->signature); mError("pShow:%p, signature:%p, query memory is corrupted", pShow, pShow->signature);
rpcSendResponse(ahandle, TSDB_CODE_MEMORY_CORRUPTED, NULL, 0); rpcRsp.code = TSDB_CODE_MEMORY_CORRUPTED;
rpcSendResponse(&rpcRsp);
return; return;
} else { } else {
if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) { if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) {
...@@ -705,7 +769,7 @@ void mgmtProcessRetrieveMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -705,7 +769,7 @@ void mgmtProcessRetrieveMsg(void *pCont, int32_t contLen, void *ahandle) {
// if free flag is set, client wants to clean the resources // if free flag is set, client wants to clean the resources
if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE)
rowsRead = (*mgmtRetrieveFp[(uint8_t) pShow->type])(pShow, pRsp->data, rowsToRead, ahandle); rowsRead = (*mgmtRetrieveFp[(uint8_t) pShow->type])(pShow, pRsp->data, rowsToRead, rpcMsg->handle);
if (rowsRead < 0) { if (rowsRead < 0) {
rowsRead = 0; // TSDB_CODE_ACTION_IN_PROGRESS; rowsRead = 0; // TSDB_CODE_ACTION_IN_PROGRESS;
...@@ -716,107 +780,120 @@ void mgmtProcessRetrieveMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -716,107 +780,120 @@ void mgmtProcessRetrieveMsg(void *pCont, int32_t contLen, void *ahandle) {
pRsp->numOfRows = htonl(rowsRead); pRsp->numOfRows = htonl(rowsRead);
pRsp->precision = htonl(TSDB_TIME_PRECISION_MILLI); // millisecond time precision pRsp->precision = htonl(TSDB_TIME_PRECISION_MILLI); // millisecond time precision
rpcSendResponse(ahandle, TSDB_CODE_SUCCESS, pRsp, size); rpcRsp.pCont = pRsp;
rpcRsp.contLen = size;
rpcSendResponse(&rpcRsp);
if (rowsToRead == 0) { if (rowsToRead == 0) {
mgmtFreeQhandle(pShow); mgmtFreeQhandle(pShow);
} }
} }
void mgmtProcessCreateTableMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessCreateTableMsg(SRpcMsg *rpcMsg) {
SCreateTableMsg *pCreate = (SCreateTableMsg *) pCont; SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
SCreateTableMsg *pCreate = (SCreateTableMsg *) rpcMsg->pCont;
pCreate->numOfColumns = htons(pCreate->numOfColumns); pCreate->numOfColumns = htons(pCreate->numOfColumns);
pCreate->numOfTags = htons(pCreate->numOfTags); pCreate->numOfTags = htons(pCreate->numOfTags);
pCreate->sqlLen = htons(pCreate->sqlLen); pCreate->sqlLen = htons(pCreate->sqlLen);
SSchema *pSchema = pCreate->schema; SSchema *pSchema = (SSchema*) pCreate->schema;
for (int32_t i = 0; i < pCreate->numOfColumns + pCreate->numOfTags; ++i) { for (int32_t i = 0; i < pCreate->numOfColumns + pCreate->numOfTags; ++i) {
pSchema->bytes = htons(pSchema->bytes); pSchema->bytes = htons(pSchema->bytes);
pSchema->colId = i; pSchema->colId = i;
pSchema++; pSchema++;
} }
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
mError("table:%s, failed to create table, need redirect message", pCreate->tableId); mError("table:%s, failed to create table, need redirect message", pCreate->tableId);
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
mError("table:%s, failed to create table, invalid user", pCreate->tableId); mError("table:%s, failed to create table, invalid user", pCreate->tableId);
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
if (!pUser->writeAuth) { if (!pUser->writeAuth) {
mError("table:%s, failed to create table, no rights", pCreate->tableId); mError("table:%s, failed to create table, no rights", pCreate->tableId);
rpcSendResponse(ahandle, TSDB_CODE_NO_RIGHTS, NULL, 0); rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(&rpcRsp);
return; return;
} }
int32_t code = mgmtCreateTable(pCreate, contLen, ahandle, false); int32_t code = mgmtCreateTable(pCreate, rpcMsg->contLen, rpcMsg->handle, false);
if (code != TSDB_CODE_ACTION_IN_PROGRESS) { if (code != TSDB_CODE_ACTION_IN_PROGRESS) {
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
} }
void mgmtProcessDropTableMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessDropTableMsg(SRpcMsg *rpcMsg) {
SDropTableMsg *pDrop = (SDropTableMsg *) pCont; SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
SDropTableMsg *pDrop = (SDropTableMsg *) rpcMsg->pCont;
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
mError("table:%s, failed to drop table, need redirect message", pDrop->tableId); mError("table:%s, failed to drop table, need redirect message", pDrop->tableId);
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
mError("table:%s, failed to drop table, invalid user", pDrop->tableId); mError("table:%s, failed to drop table, invalid user", pDrop->tableId);
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
if (!pUser->writeAuth) { if (!pUser->writeAuth) {
mError("table:%s, failed to drop table, no rights", pDrop->tableId); mError("table:%s, failed to drop table, no rights", pDrop->tableId);
rpcSendResponse(ahandle, TSDB_CODE_NO_RIGHTS, NULL, 0); rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(&rpcRsp);
return; return;
} }
SDbObj *pDb = mgmtGetDbByTableId(pDrop->tableId); SDbObj *pDb = mgmtGetDbByTableId(pDrop->tableId);
if (pDb == NULL) { if (pDb == NULL) {
mError("table:%s, failed to drop table, db not selected", pDrop->tableId); mError("table:%s, failed to drop table, db not selected", pDrop->tableId);
rpcSendResponse(ahandle, TSDB_CODE_DB_NOT_SELECTED, NULL, 0); rpcRsp.code = TSDB_CODE_DB_NOT_SELECTED;
rpcSendResponse(&rpcRsp);
return; return;
} }
int32_t code = mgmtDropTable(pDb, pDrop->tableId, pDrop->igNotExists); int32_t code = mgmtDropTable(pDb, pDrop->tableId, pDrop->igNotExists);
if (code != TSDB_CODE_ACTION_IN_PROGRESS) { if (code != TSDB_CODE_ACTION_IN_PROGRESS) {
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
} }
void mgmtProcessAlterTableMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessAlterTableMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
SAlterTableMsg *pAlter = (SAlterTableMsg *) pCont; SAlterTableMsg *pAlter = (SAlterTableMsg *) rpcMsg->pCont;
int32_t code;
if (!pUser->writeAuth) { if (!pUser->writeAuth) {
code = TSDB_CODE_NO_RIGHTS; rpcRsp.code = TSDB_CODE_NO_RIGHTS;
} else { } else {
pAlter->type = htons(pAlter->type); pAlter->type = htons(pAlter->type);
pAlter->numOfCols = htons(pAlter->numOfCols); pAlter->numOfCols = htons(pAlter->numOfCols);
if (pAlter->numOfCols > 2) { if (pAlter->numOfCols > 2) {
mError("table:%s error numOfCols:%d in alter table", pAlter->tableId, pAlter->numOfCols); mError("table:%s error numOfCols:%d in alter table", pAlter->tableId, pAlter->numOfCols);
code = TSDB_CODE_APP_ERROR; rpcRsp.code = TSDB_CODE_APP_ERROR;
} else { } else {
SDbObj *pDb = mgmtGetDb(pAlter->db); SDbObj *pDb = mgmtGetDb(pAlter->db);
if (pDb) { if (pDb) {
...@@ -824,61 +901,61 @@ void mgmtProcessAlterTableMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -824,61 +901,61 @@ void mgmtProcessAlterTableMsg(void *pCont, int32_t contLen, void *ahandle) {
pAlter->schema[i].bytes = htons(pAlter->schema[i].bytes); pAlter->schema[i].bytes = htons(pAlter->schema[i].bytes);
} }
code = mgmtAlterTable(pDb, pAlter); rpcRsp.code = mgmtAlterTable(pDb, pAlter);
if (code == 0) { if (rpcRsp.code == 0) {
mLPrint("table:%s is altered by %s", pAlter->tableId, pUser->user); mLPrint("table:%s is altered by %s", pAlter->tableId, pUser->user);
} }
} else { } else {
code = TSDB_CODE_DB_NOT_SELECTED; rpcRsp.code = TSDB_CODE_DB_NOT_SELECTED;
} }
} }
} }
if (code != TSDB_CODE_SUCCESS) { rpcSendResponse(&rpcRsp);
rpcSendResponse(ahandle, code, NULL, 0);
}
} }
void mgmtProcessCfgDnodeMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessCfgDnodeMsg(SRpcMsg *rpcMsg) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
SCfgDnodeMsg *pCfg = (SCfgDnodeMsg *)pCont; SCfgDnodeMsg *pCfg = (SCfgDnodeMsg *) rpcMsg->pCont;
int32_t code;
if (strcmp(pUser->pAcct->user, "root") != 0) { if (strcmp(pUser->pAcct->user, "root") != 0) {
code = TSDB_CODE_NO_RIGHTS; rpcRsp.code = TSDB_CODE_NO_RIGHTS;
} else { } else {
code = mgmtSendCfgDnodeMsg(pCont); rpcRsp.code = mgmtSendCfgDnodeMsg(rpcMsg->pCont);
} }
if (code == TSDB_CODE_SUCCESS) { if (rpcRsp.code == TSDB_CODE_SUCCESS) {
mTrace("dnode:%s is configured by %s", pCfg->ip, pUser->user); mTrace("dnode:%s is configured by %s", pCfg->ip, pUser->user);
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcSendResponse(&rpcRsp);
} }
void mgmtProcessHeartBeatMsg(void *pCont, int32_t contLen, void *ahandle) { void mgmtProcessHeartBeatMsg(SRpcMsg *rpcMsg) {
SHeartBeatMsg *pHBMsg = (SHeartBeatMsg *) pCont; SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
SHeartBeatMsg *pHBMsg = (SHeartBeatMsg *) rpcMsg->pCont;
mgmtSaveQueryStreamList(pHBMsg); mgmtSaveQueryStreamList(pHBMsg);
SHeartBeatRsp *pHBRsp = (SHeartBeatRsp *) rpcMallocCont(contLen); SHeartBeatRsp *pHBRsp = (SHeartBeatRsp *) rpcMallocCont(sizeof(SHeartBeatRsp));
if (pHBRsp == NULL) { if (pHBRsp == NULL) {
rpcSendResponse(ahandle, TSDB_CODE_SERV_OUT_OF_MEMORY, NULL, 0); rpcRsp.code = TSDB_CODE_SERV_OUT_OF_MEMORY;
rpcFreeCont(pCont); rpcSendResponse(&rpcRsp);
return; return;
} }
SRpcConnInfo connInfo; SRpcConnInfo connInfo;
rpcGetConnInfo(ahandle, &connInfo); rpcGetConnInfo(rpcMsg->handle, &connInfo);
pHBRsp->ipList.inUse = 0; pHBRsp->ipList.inUse = 0;
pHBRsp->ipList.port = htons(tsMgmtShellPort); pHBRsp->ipList.port = htons(tsMgmtShellPort);
...@@ -904,7 +981,9 @@ void mgmtProcessHeartBeatMsg(void *pCont, int32_t contLen, void *ahandle) { ...@@ -904,7 +981,9 @@ void mgmtProcessHeartBeatMsg(void *pCont, int32_t contLen, void *ahandle) {
pHBRsp->streamId = 0; pHBRsp->streamId = 0;
pHBRsp->killConnection = 0; pHBRsp->killConnection = 0;
rpcSendResponse(ahandle, TSDB_CODE_SUCCESS, pHBRsp, sizeof(SHeartBeatMsg)); rpcRsp.pCont = pHBRsp;
rpcRsp.contLen = sizeof(SHeartBeatRsp);
rpcSendResponse(&rpcRsp);
} }
int mgmtRetriveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) { int mgmtRetriveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
...@@ -922,10 +1001,12 @@ int mgmtRetriveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, ...@@ -922,10 +1001,12 @@ int mgmtRetriveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret,
} }
} }
static void mgmtProcessConnectMsg(void *pCont, int32_t contLen, void *thandle) { static void mgmtProcessConnectMsg(SRpcMsg *rpcMsg) {
SConnectMsg *pConnectMsg = (SConnectMsg *) pCont; SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
SConnectMsg *pConnectMsg = (SConnectMsg *) rpcMsg->pCont;
SRpcConnInfo connInfo; SRpcConnInfo connInfo;
rpcGetConnInfo(thandle, &connInfo); rpcGetConnInfo(rpcMsg->handle, &connInfo);
int32_t code; int32_t code;
SUserObj *pUser = mgmtGetUser(connInfo.user); SUserObj *pUser = mgmtGetUser(connInfo.user);
...@@ -987,13 +1068,15 @@ static void mgmtProcessConnectMsg(void *pCont, int32_t contLen, void *thandle) { ...@@ -987,13 +1068,15 @@ static void mgmtProcessConnectMsg(void *pCont, int32_t contLen, void *thandle) {
} }
connect_over: connect_over:
rpcRsp.code = code;
if (code != TSDB_CODE_SUCCESS) { if (code != TSDB_CODE_SUCCESS) {
mLError("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code); mLError("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
rpcSendResponse(thandle, code, NULL, 0);
} else { } else {
mLPrint("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code); mLPrint("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
rpcSendResponse(thandle, code, pConnectRsp, sizeof(SConnectRsp)); rpcRsp.pCont = pConnectRsp;
rpcRsp.contLen = sizeof(SConnectRsp);
} }
rpcSendResponse(&rpcRsp);
} }
/** /**
...@@ -1024,48 +1107,51 @@ static bool mgmtCheckMsgReadOnly(int8_t type, void *pCont) { ...@@ -1024,48 +1107,51 @@ static bool mgmtCheckMsgReadOnly(int8_t type, void *pCont) {
return false; return false;
} }
static void mgmtProcessMsgFromShell(char type, void *pCont, int contLen, void *ahandle, int32_t code) { static void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg) {
if (sdbGetRunStatus() != SDB_STATUS_SERVING) { if (sdbGetRunStatus() != SDB_STATUS_SERVING) {
mTrace("shell msg is ignored since SDB is not ready"); mTrace("shell msg is ignored since SDB is not ready");
rpcSendResponse(ahandle, TSDB_CODE_NOT_READY, NULL, 0); SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = TSDB_CODE_NOT_READY, .msgType = 0};
rpcFreeCont(pCont); rpcSendResponse(&rpcRsp);
rpcFreeCont(rpcMsg->pCont);
return; return;
} }
if (mgmtCheckMsgReadOnly(type, pCont)) { if (mgmtCheckMsgReadOnly(rpcMsg->msgType, rpcMsg->pCont)) {
(*mgmtProcessShellMsg[(int8_t)type])(pCont, contLen, ahandle); (*mgmtProcessShellMsg[rpcMsg->msgType])(rpcMsg);
} else { } else {
if (mgmtProcessShellMsg[(int8_t)type]) { if (mgmtProcessShellMsg[rpcMsg->msgType]) {
mgmtAddToTranRequest((int8_t)type, pCont, contLen, ahandle); mgmtAddToTranRequest(rpcMsg);
} else { } else {
mError("%s from shell is not processed", taosMsg[(int8_t)type]); mError("%s from shell is not processed", taosMsg[rpcMsg->msgType]);
} }
} }
//TODO free may be cause segment fault rpcFreeCont(rpcMsg->pCont);
//
// rpcFreeCont(pCont);
} }
void mgmtProcessCreateVgroup(SCreateTableMsg *pCreate, int32_t contLen, void *thandle, bool isGetMeta) { void mgmtProcessCreateVgroup(SCreateTableMsg *pCreate, int32_t contLen, void *thandle, bool isGetMeta) {
SRpcMsg rpcRsp = {.handle = thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
SDbObj *pDb = mgmtGetDb(pCreate->db); SDbObj *pDb = mgmtGetDb(pCreate->db);
if (pDb == NULL) { if (pDb == NULL) {
mError("table:%s, failed to create vgroup, db not found", pCreate->tableId); mError("table:%s, failed to create vgroup, db not found", pCreate->tableId);
rpcSendResponse(thandle, TSDB_CODE_INVALID_DB, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_DB;
rpcSendResponse(&rpcRsp);
return; return;
} }
SVgObj *pVgroup = mgmtCreateVgroup(pDb); SVgObj *pVgroup = mgmtCreateVgroup(pDb);
if (pVgroup == NULL) { if (pVgroup == NULL) {
mError("table:%s, failed to alloc vnode to vgroup", pCreate->tableId); mError("table:%s, failed to alloc vnode to vgroup", pCreate->tableId);
rpcSendResponse(thandle, TSDB_CODE_NO_ENOUGH_DNODES, NULL, 0); rpcRsp.code = TSDB_CODE_NO_ENOUGH_DNODES;
rpcSendResponse(&rpcRsp);
return; return;
} }
void *cont = rpcMallocCont(contLen); void *cont = rpcMallocCont(contLen);
if (cont == NULL) { if (cont == NULL) {
mError("table:%s, failed to create table, can not alloc memory", pCreate->tableId); mError("table:%s, failed to create table, can not alloc memory", pCreate->tableId);
rpcSendResponse(thandle, TSDB_CODE_SERV_OUT_OF_MEMORY, NULL, 0); rpcRsp.code = TSDB_CODE_SERV_OUT_OF_MEMORY;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -1087,6 +1173,7 @@ void mgmtProcessCreateVgroup(SCreateTableMsg *pCreate, int32_t contLen, void *th ...@@ -1087,6 +1173,7 @@ void mgmtProcessCreateVgroup(SCreateTableMsg *pCreate, int32_t contLen, void *th
void mgmtProcessCreateTable(SVgObj *pVgroup, SCreateTableMsg *pCreate, int32_t contLen, void *thandle, bool isGetMeta) { void mgmtProcessCreateTable(SVgObj *pVgroup, SCreateTableMsg *pCreate, int32_t contLen, void *thandle, bool isGetMeta) {
assert(pVgroup != NULL); assert(pVgroup != NULL);
SRpcMsg rpcRsp = {.handle = thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
int32_t sid = taosAllocateId(pVgroup->idPool); int32_t sid = taosAllocateId(pVgroup->idPool);
if (sid < 0) { if (sid < 0) {
...@@ -1095,21 +1182,20 @@ void mgmtProcessCreateTable(SVgObj *pVgroup, SCreateTableMsg *pCreate, int32_t c ...@@ -1095,21 +1182,20 @@ void mgmtProcessCreateTable(SVgObj *pVgroup, SCreateTableMsg *pCreate, int32_t c
return; return;
} }
int32_t code;
STableInfo *pTable; STableInfo *pTable;
SDCreateTableMsg *pDCreate = NULL; SDCreateTableMsg *pDCreate = NULL;
if (pCreate->numOfColumns == 0) { if (pCreate->numOfColumns == 0) {
mTrace("table:%s, start to create child table, vgroup:%d sid:%d", pCreate->tableId, pVgroup->vgId, sid); mTrace("table:%s, start to create child table, vgroup:%d sid:%d", pCreate->tableId, pVgroup->vgId, sid);
code = mgmtCreateChildTable(pCreate, contLen, pVgroup, sid, &pDCreate, &pTable); rpcRsp.code = mgmtCreateChildTable(pCreate, contLen, pVgroup, sid, &pDCreate, &pTable);
} else { } else {
mTrace("table:%s, start to create normal table, vgroup:%d sid:%d", pCreate->tableId, pVgroup->vgId, sid); mTrace("table:%s, start to create normal table, vgroup:%d sid:%d", pCreate->tableId, pVgroup->vgId, sid);
code = mgmtCreateNormalTable(pCreate, contLen, pVgroup, sid, &pDCreate, &pTable); rpcRsp.code = mgmtCreateNormalTable(pCreate, contLen, pVgroup, sid, &pDCreate, &pTable);
} }
if (code != TSDB_CODE_SUCCESS) { if (rpcRsp.code != TSDB_CODE_SUCCESS) {
mTrace("table:%s, failed to create table in vgroup:%d sid:%d ", pCreate->tableId, pVgroup->vgId, sid); mTrace("table:%s, failed to create table in vgroup:%d sid:%d ", pCreate->tableId, pVgroup->vgId, sid);
rpcSendResponse(thandle, code, NULL, 0); rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -1129,10 +1215,12 @@ void mgmtProcessCreateTable(SVgObj *pVgroup, SCreateTableMsg *pCreate, int32_t c ...@@ -1129,10 +1215,12 @@ void mgmtProcessCreateTable(SVgObj *pVgroup, SCreateTableMsg *pCreate, int32_t c
} }
void mgmtProcessGetTableMeta(STableInfo *pTable, void *thandle) { void mgmtProcessGetTableMeta(STableInfo *pTable, void *thandle) {
SRpcMsg rpcRsp = {.handle = thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
SDbObj* pDb = mgmtGetDbByTableId(pTable->tableId); SDbObj* pDb = mgmtGetDbByTableId(pTable->tableId);
if (pDb == NULL || pDb->dropStatus != TSDB_DB_STATUS_READY) { if (pDb == NULL || pDb->dropStatus != TSDB_DB_STATUS_READY) {
mError("table:%s, failed to get table meta, db not selected", pTable->tableId); mError("table:%s, failed to get table meta, db not selected", pTable->tableId);
rpcSendResponse(thandle, TSDB_CODE_DB_NOT_SELECTED, NULL, 0); rpcRsp.code = TSDB_CODE_DB_NOT_SELECTED;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -1141,15 +1229,17 @@ void mgmtProcessGetTableMeta(STableInfo *pTable, void *thandle) { ...@@ -1141,15 +1229,17 @@ void mgmtProcessGetTableMeta(STableInfo *pTable, void *thandle) {
bool usePublicIp = (connInfo.serverIp == tsPublicIpInt); bool usePublicIp = (connInfo.serverIp == tsPublicIpInt);
STableMeta *pMeta = rpcMallocCont(sizeof(STableMeta) + sizeof(SSchema) * TSDB_MAX_COLUMNS); STableMeta *pMeta = rpcMallocCont(sizeof(STableMeta) + sizeof(SSchema) * TSDB_MAX_COLUMNS);
int32_t code = mgmtGetTableMeta(pDb, pTable, pMeta, usePublicIp); rpcRsp.code = mgmtGetTableMeta(pDb, pTable, pMeta, usePublicIp);
if (code != TSDB_CODE_SUCCESS) { if (rpcRsp.code != TSDB_CODE_SUCCESS) {
rpcFreeCont(pMeta); rpcFreeCont(pMeta);
rpcSendResponse(thandle, TSDB_CODE_SUCCESS, NULL, 0);
} else { } else {
pMeta->contLen = htons(pMeta->contLen); pMeta->contLen = htons(pMeta->contLen);
rpcSendResponse(thandle, TSDB_CODE_SUCCESS, pMeta, pMeta->contLen); rpcRsp.pCont = pMeta;
rpcRsp.contLen = pMeta->contLen;
} }
rpcSendResponse(&rpcRsp);
} }
static int32_t mgmtCheckRedirectMsgImp(void *pConn) { static int32_t mgmtCheckRedirectMsgImp(void *pConn) {
...@@ -1158,20 +1248,26 @@ static int32_t mgmtCheckRedirectMsgImp(void *pConn) { ...@@ -1158,20 +1248,26 @@ static int32_t mgmtCheckRedirectMsgImp(void *pConn) {
int32_t (*mgmtCheckRedirectMsg)(void *pConn) = mgmtCheckRedirectMsgImp; int32_t (*mgmtCheckRedirectMsg)(void *pConn) = mgmtCheckRedirectMsgImp;
static void mgmtProcessUnSupportMsg(void *pCont, int32_t contLen, void *ahandle) { static void mgmtProcessUnSupportMsg(SRpcMsg *rpcMsg) {
rpcSendResponse(ahandle, TSDB_CODE_OPS_NOT_SUPPORT, NULL, 0); SRpcMsg rpcRsp = {
.msgType = 0,
.pCont = 0,
.contLen = 0,
.code = TSDB_CODE_OPS_NOT_SUPPORT,
.handle = rpcMsg->handle
};
rpcSendResponse(&rpcRsp);
} }
void (*mgmtProcessCfgMnodeMsg)(void *pCont, int32_t contLen, void *ahandle) = mgmtProcessUnSupportMsg; static void mgmtProcessAlterAcctMsg(SRpcMsg *rpcMsg) {
void (*mgmtProcessDropMnodeMsg)(void *pCont, int32_t contLen, void *ahandle) = mgmtProcessUnSupportMsg; SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
static void mgmtProcessAlterAcctMsg(void *pCont, int32_t contLen, void *ahandle) {
if (!mgmtAlterAcctFp) { if (!mgmtAlterAcctFp) {
rpcSendResponse(ahandle, TSDB_CODE_OPS_NOT_SUPPORT, NULL, 0); rpcRsp.code = TSDB_CODE_OPS_NOT_SUPPORT;
rpcSendResponse(&rpcRsp);
return; return;
} }
SAlterAcctMsg *pAlter = pCont; SAlterAcctMsg *pAlter = rpcMsg->pCont;
pAlter->cfg.maxUsers = htonl(pAlter->cfg.maxUsers); pAlter->cfg.maxUsers = htonl(pAlter->cfg.maxUsers);
pAlter->cfg.maxDbs = htonl(pAlter->cfg.maxDbs); pAlter->cfg.maxDbs = htonl(pAlter->cfg.maxDbs);
pAlter->cfg.maxTimeSeries = htonl(pAlter->cfg.maxTimeSeries); pAlter->cfg.maxTimeSeries = htonl(pAlter->cfg.maxTimeSeries);
...@@ -1183,21 +1279,23 @@ static void mgmtProcessAlterAcctMsg(void *pCont, int32_t contLen, void *ahandle) ...@@ -1183,21 +1279,23 @@ static void mgmtProcessAlterAcctMsg(void *pCont, int32_t contLen, void *ahandle)
pAlter->cfg.maxInbound = htobe64(pAlter->cfg.maxInbound); pAlter->cfg.maxInbound = htobe64(pAlter->cfg.maxInbound);
pAlter->cfg.maxOutbound = htobe64(pAlter->cfg.maxOutbound); pAlter->cfg.maxOutbound = htobe64(pAlter->cfg.maxOutbound);
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
mError("account:%s, failed to alter account, need redirect message", pAlter->user); mError("account:%s, failed to alter account, need redirect message", pAlter->user);
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
mError("account:%s, failed to alter account, invalid user", pAlter->user); mError("account:%s, failed to alter account, invalid user", pAlter->user);
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
if (strcmp(pUser->user, "root") != 0) { if (strcmp(pUser->user, "root") != 0) {
mError("account:%s, failed to alter account, no rights", pAlter->user); mError("account:%s, failed to alter account, no rights", pAlter->user);
rpcSendResponse(ahandle, TSDB_CODE_NO_RIGHTS, NULL, 0); rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -1208,32 +1306,36 @@ static void mgmtProcessAlterAcctMsg(void *pCont, int32_t contLen, void *ahandle) ...@@ -1208,32 +1306,36 @@ static void mgmtProcessAlterAcctMsg(void *pCont, int32_t contLen, void *ahandle)
mError("account:%s, failed to alter account, reason:%s", pAlter->user, tstrerror(code)); mError("account:%s, failed to alter account, reason:%s", pAlter->user, tstrerror(code));
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
static void mgmtProcessDropAcctMsg(void *pCont, int32_t contLen, void *ahandle) { static void mgmtProcessDropAcctMsg(SRpcMsg *rpcMsg) {
SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (!mgmtDropAcctFp) { if (!mgmtDropAcctFp) {
rpcSendResponse(ahandle, TSDB_CODE_OPS_NOT_SUPPORT, NULL, 0); rpcRsp.code = TSDB_CODE_OPS_NOT_SUPPORT;
rpcSendResponse(&rpcRsp);
return; return;
} }
SDropAcctMsg *pDrop = (SDropAcctMsg *) pCont; SDropAcctMsg *pDrop = (SDropAcctMsg *) rpcMsg->pCont;
if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) {
mError("account:%s, failed to drop account, need redirect message", pDrop->user); mError("account:%s, failed to drop account, need redirect message", pDrop->user);
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
mError("account:%s, failed to drop account, invalid user", pDrop->user); mError("account:%s, failed to drop account, invalid user", pDrop->user);
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
if (strcmp(pUser->user, "root") != 0) { if (strcmp(pUser->user, "root") != 0) {
mError("account:%s, failed to drop account, no rights", pDrop->user); mError("account:%s, failed to drop account, no rights", pDrop->user);
rpcSendResponse(ahandle, TSDB_CODE_NO_RIGHTS, NULL, 0); rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -1244,16 +1346,19 @@ static void mgmtProcessDropAcctMsg(void *pCont, int32_t contLen, void *ahandle) ...@@ -1244,16 +1346,19 @@ static void mgmtProcessDropAcctMsg(void *pCont, int32_t contLen, void *ahandle)
mError("account:%s, failed to drop account, reason:%s", pDrop->user, tstrerror(code)); mError("account:%s, failed to drop account, reason:%s", pDrop->user, tstrerror(code));
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
static void mgmtProcessCreateAcctMsg(void *pCont, int32_t contLen, void *ahandle) { static void mgmtProcessCreateAcctMsg(SRpcMsg *rpcMsg) {
SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (!mgmtCreateAcctFp) { if (!mgmtCreateAcctFp) {
rpcSendResponse(ahandle, TSDB_CODE_OPS_NOT_SUPPORT, NULL, 0); rpcRsp.code = TSDB_CODE_OPS_NOT_SUPPORT;
rpcSendResponse(&rpcRsp);
return; return;
} }
SCreateAcctMsg *pCreate = (SCreateAcctMsg *) pCont; SCreateAcctMsg *pCreate = (SCreateAcctMsg *) rpcMsg->pCont;
pCreate->cfg.maxUsers = htonl(pCreate->cfg.maxUsers); pCreate->cfg.maxUsers = htonl(pCreate->cfg.maxUsers);
pCreate->cfg.maxDbs = htonl(pCreate->cfg.maxDbs); pCreate->cfg.maxDbs = htonl(pCreate->cfg.maxDbs);
pCreate->cfg.maxTimeSeries = htonl(pCreate->cfg.maxTimeSeries); pCreate->cfg.maxTimeSeries = htonl(pCreate->cfg.maxTimeSeries);
...@@ -1265,21 +1370,23 @@ static void mgmtProcessCreateAcctMsg(void *pCont, int32_t contLen, void *ahandle ...@@ -1265,21 +1370,23 @@ static void mgmtProcessCreateAcctMsg(void *pCont, int32_t contLen, void *ahandle
pCreate->cfg.maxInbound = htobe64(pCreate->cfg.maxInbound); pCreate->cfg.maxInbound = htobe64(pCreate->cfg.maxInbound);
pCreate->cfg.maxOutbound = htobe64(pCreate->cfg.maxOutbound); pCreate->cfg.maxOutbound = htobe64(pCreate->cfg.maxOutbound);
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
mError("account:%s, failed to create account, need redirect message", pCreate->user); mError("account:%s, failed to create account, need redirect message", pCreate->user);
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
mError("account:%s, failed to create account, invalid user", pCreate->user); mError("account:%s, failed to create account, invalid user", pCreate->user);
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
if (strcmp(pUser->user, "root") != 0) { if (strcmp(pUser->user, "root") != 0) {
mError("account:%s, failed to create account, no rights", pCreate->user); mError("account:%s, failed to create account, no rights", pCreate->user);
rpcSendResponse(ahandle, TSDB_CODE_NO_RIGHTS, NULL, 0); rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -1290,31 +1397,36 @@ static void mgmtProcessCreateAcctMsg(void *pCont, int32_t contLen, void *ahandle ...@@ -1290,31 +1397,36 @@ static void mgmtProcessCreateAcctMsg(void *pCont, int32_t contLen, void *ahandle
mError("account:%s, failed to create account, reason:%s", pCreate->user, tstrerror(code)); mError("account:%s, failed to create account, reason:%s", pCreate->user, tstrerror(code));
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
static void mgmtProcessCreateDnodeMsg(void *pCont, int32_t contLen, void *ahandle) { static void mgmtProcessCreateDnodeMsg(SRpcMsg *rpcMsg) {
SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (!mgmtCreateDnodeFp) { if (!mgmtCreateDnodeFp) {
rpcSendResponse(ahandle, TSDB_CODE_OPS_NOT_SUPPORT, NULL, 0); rpcRsp.code = TSDB_CODE_OPS_NOT_SUPPORT;
rpcSendResponse(&rpcRsp);
return; return;
} }
SCreateDnodeMsg *pCreate = (SCreateDnodeMsg *)pCont; SCreateDnodeMsg *pCreate = (SCreateDnodeMsg *) rpcMsg->pCont;
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
mError("failed to create dnode:%s, redirect this message", pCreate->ip); mError("failed to create dnode:%s, redirect this message", pCreate->ip);
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
mError("failed to create dnode:%s, reason:%s", pCreate->ip, tstrerror(TSDB_CODE_INVALID_USER)); mError("failed to create dnode:%s, reason:%s", pCreate->ip, tstrerror(TSDB_CODE_INVALID_USER));
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
if (strcmp(pUser->user, "root") != 0) { if (strcmp(pUser->user, "root") != 0) {
mError("failed to create dnode:%s, reason:%s", pCreate->ip, tstrerror(TSDB_CODE_NO_RIGHTS)); mError("failed to create dnode:%s, reason:%s", pCreate->ip, tstrerror(TSDB_CODE_NO_RIGHTS));
rpcSendResponse(ahandle, TSDB_CODE_NO_RIGHTS, NULL, 0); rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -1325,31 +1437,36 @@ static void mgmtProcessCreateDnodeMsg(void *pCont, int32_t contLen, void *ahandl ...@@ -1325,31 +1437,36 @@ static void mgmtProcessCreateDnodeMsg(void *pCont, int32_t contLen, void *ahandl
mError("failed to create dnode:%s, reason:%s", pCreate->ip, tstrerror(code)); mError("failed to create dnode:%s, reason:%s", pCreate->ip, tstrerror(code));
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
static void mgmtProcessDropDnodeMsg(void *pCont, int32_t contLen, void *ahandle) { static void mgmtProcessDropDnodeMsg(SRpcMsg *rpcMsg) {
SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
if (!mgmtDropDnodeByIpFp) { if (!mgmtDropDnodeByIpFp) {
rpcSendResponse(ahandle, TSDB_CODE_OPS_NOT_SUPPORT, NULL, 0); rpcRsp.code = TSDB_CODE_OPS_NOT_SUPPORT;
rpcSendResponse(&rpcRsp);
return; return;
} }
SDropDnodeMsg *pDrop = (SDropDnodeMsg *)pCont; SDropDnodeMsg *pDrop = (SDropDnodeMsg *) rpcMsg->pCont;
if (mgmtCheckRedirectMsg(ahandle) != TSDB_CODE_SUCCESS) { if (mgmtCheckRedirectMsg(rpcMsg->handle) != TSDB_CODE_SUCCESS) {
mError("failed to drop dnode:%s, redirect this message", pDrop->ip); mError("failed to drop dnode:%s, redirect this message", pDrop->ip);
return; return;
} }
SUserObj *pUser = mgmtGetUserFromConn(ahandle); SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
if (pUser == NULL) { if (pUser == NULL) {
mError("failed to drop dnode:%s, reason:%s", pDrop->ip, tstrerror(TSDB_CODE_INVALID_USER)); mError("failed to drop dnode:%s, reason:%s", pDrop->ip, tstrerror(TSDB_CODE_INVALID_USER));
rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0); rpcRsp.code = TSDB_CODE_INVALID_USER;
rpcSendResponse(&rpcRsp);
return; return;
} }
if (strcmp(pUser->user, "root") != 0) { if (strcmp(pUser->user, "root") != 0) {
mError("failed to drop dnode:%s, reason:%s", pDrop->ip, tstrerror(TSDB_CODE_NO_RIGHTS)); mError("failed to drop dnode:%s, reason:%s", pDrop->ip, tstrerror(TSDB_CODE_NO_RIGHTS));
rpcSendResponse(ahandle, TSDB_CODE_NO_RIGHTS, NULL, 0); rpcRsp.code = TSDB_CODE_NO_RIGHTS;
rpcSendResponse(&rpcRsp);
return; return;
} }
...@@ -1360,7 +1477,8 @@ static void mgmtProcessDropDnodeMsg(void *pCont, int32_t contLen, void *ahandle) ...@@ -1360,7 +1477,8 @@ static void mgmtProcessDropDnodeMsg(void *pCont, int32_t contLen, void *ahandle)
mError("failed to drop dnode:%s, reason:%s", pDrop->ip, tstrerror(code)); mError("failed to drop dnode:%s, reason:%s", pDrop->ip, tstrerror(code));
} }
rpcSendResponse(ahandle, code, NULL, 0); rpcRsp.code = code;
rpcSendResponse(&rpcRsp);
} }
void mgmtInitProcessShellMsg() { void mgmtInitProcessShellMsg() {
...@@ -1383,8 +1501,8 @@ void mgmtInitProcessShellMsg() { ...@@ -1383,8 +1501,8 @@ void mgmtInitProcessShellMsg() {
mgmtProcessShellMsg[TSDB_MSG_TYPE_DROP_DNODE] = mgmtProcessDropDnodeMsg; mgmtProcessShellMsg[TSDB_MSG_TYPE_DROP_DNODE] = mgmtProcessDropDnodeMsg;
mgmtProcessShellMsg[TSDB_MSG_TYPE_DNODE_CFG] = mgmtProcessCfgDnodeMsg; mgmtProcessShellMsg[TSDB_MSG_TYPE_DNODE_CFG] = mgmtProcessCfgDnodeMsg;
mgmtProcessShellMsg[TSDB_MSG_TYPE_CREATE_MNODE] = mgmtProcessUnSupportMsg; mgmtProcessShellMsg[TSDB_MSG_TYPE_CREATE_MNODE] = mgmtProcessUnSupportMsg;
mgmtProcessShellMsg[TSDB_MSG_TYPE_DROP_MNODE] = mgmtProcessDropMnodeMsg; mgmtProcessShellMsg[TSDB_MSG_TYPE_DROP_MNODE] = mgmtProcessUnSupportMsg;
mgmtProcessShellMsg[TSDB_MSG_TYPE_CFG_MNODE] = mgmtProcessCfgMnodeMsg; mgmtProcessShellMsg[TSDB_MSG_TYPE_CFG_MNODE] = mgmtProcessUnSupportMsg;
mgmtProcessShellMsg[TSDB_MSG_TYPE_KILL_QUERY] = mgmtProcessKillQueryMsg; mgmtProcessShellMsg[TSDB_MSG_TYPE_KILL_QUERY] = mgmtProcessKillQueryMsg;
mgmtProcessShellMsg[TSDB_MSG_TYPE_KILL_STREAM] = mgmtProcessKillStreamMsg; mgmtProcessShellMsg[TSDB_MSG_TYPE_KILL_STREAM] = mgmtProcessKillStreamMsg;
mgmtProcessShellMsg[TSDB_MSG_TYPE_KILL_CONNECTION] = mgmtProcessKillConnectionMsg; mgmtProcessShellMsg[TSDB_MSG_TYPE_KILL_CONNECTION] = mgmtProcessKillConnectionMsg;
......
src/mnode/src/mgmtTable.c
浏览文件 @ b8fc28fb
...@@ -133,7 +133,7 @@ int32_t mgmtCreateTable(SCreateTableMsg *pCreate, int32_t contLen, void *thandle ...@@ -133,7 +133,7 @@ int32_t mgmtCreateTable(SCreateTableMsg *pCreate, int32_t contLen, void *thandle
SAcctObj *pAcct = mgmtGetAcct(pDb->cfg.acct); SAcctObj *pAcct = mgmtGetAcct(pDb->cfg.acct);
assert(pAcct != NULL); assert(pAcct != NULL);
int32_t code = mgmtCheckTableLimit(pAcct, pCreate); int32_t code = mgmtCheckTableLimit(pAcct, pCreate->numOfColumns);
if (code != TSDB_CODE_SUCCESS) { if (code != TSDB_CODE_SUCCESS) {
mError("table:%s, failed to create table, table num exceed the limit", pCreate->tableId); mError("table:%s, failed to create table, table num exceed the limit", pCreate->tableId);
return code; return code;
......
src/rpc/src/rpcMain.c
浏览文件 @ b8fc28fb
...@@ -359,7 +359,7 @@ void rpcSendRequest(void *shandle, SRpcIpSet *pIpSet, SRpcMsg *pMsg) { ...@@ -359,7 +359,7 @@ void rpcSendRequest(void *shandle, SRpcIpSet *pIpSet, SRpcMsg *pMsg) {
// connection type is application specific. // connection type is application specific.
// for TDengine, all the query, show commands shall have TCP connection // for TDengine, all the query, show commands shall have TCP connection
char type = pMsg->msgType; char type = pMsg->msgType;
if (type == TSDB_MSG_TYPE_DNODE_QUERY || type == TSDB_MSG_TYPE_DNODE_RETRIEVE || if (type == TSDB_MSG_TYPE_QUERY || type == TSDB_MSG_TYPE_RETRIEVE ||
type == TSDB_MSG_TYPE_STABLE_META || type == TSDB_MSG_TYPE_MULTI_TABLE_META || type == TSDB_MSG_TYPE_STABLE_META || type == TSDB_MSG_TYPE_MULTI_TABLE_META ||
type == TSDB_MSG_TYPE_SHOW ) type == TSDB_MSG_TYPE_SHOW )
pContext->connType = RPC_CONN_TCPC; pContext->connType = RPC_CONN_TCPC;
......
src/vnode/CMakeLists.txt
浏览文件 @ b8fc28fb
cmake_minimum_required(VERSION 2.8) CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
add_subdirectory(common) ADD_SUBDIRECTORY(common)
ADD_SUBDIRECTORY(tsdb)
add_subdirectory(tsdb) # ENABLE_TESTING()
# ADD_SUBDIRECTORY(tests)
enable_testing()
# add_subdirectory(tests)
\ No newline at end of file
src/vnode/common/CMakeLists.txt
浏览文件 @ b8fc28fb
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/src SOURCE_LIST) CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
list(REMOVE_ITEM SOURCE_LIST ${CMAKE_CURRENT_SOURCE_DIR}/src/vnodePeer.c) IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/dnode/inc)
message(STATUS "Common source file ${SOURCE_LIST}") INCLUDE_DIRECTORIES(inc)
AUX_SOURCE_DIRECTORY(src SRC)
add_library(common ${SOURCE_LIST}) ADD_LIBRARY(common ${SRC})
target_include_directories(common PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc") ENDIF ()
src/vnode/tsdb/CMakeLists.txt
浏览文件 @ b8fc28fb
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/src SOURCE_LIST) CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
add_library(tsdb STATIC ${SOURCE_LIST}) IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
target_link_libraries(tsdb common tutil) INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/vnode/common/inc)
target_include_directories(tsdb INCLUDE_DIRECTORIES(inc)
PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc" AUX_SOURCE_DIRECTORY(src SRC)
PUBLIC "${CMAKE_SOURCE_DIR}/src/inc"
PUBLIC "${CMAKE_SOURCE_DIR}/src/util/inc"
PUBLIC "${CMAKE_SOURCE_DIR}/src/os/linux/inc"
)
add_subdirectory(tests) ADD_LIBRARY(tsdb ${SRC})
\ No newline at end of file TARGET_LINK_LIBRARIES(tsdb common tutil)
# Someone has no gtest directory, so comment it
#ADD_SUBDIRECTORY(tests)
ENDIF ()
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或