diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h index 565e0dcb02047f17f7c220bd4f1be1f44900bdc0..2870819e1b321752dfb1b637d694a40e478fe8ae 100644 --- a/src/inc/taosdef.h +++ b/src/inc/taosdef.h @@ -184,6 +184,7 @@ do { \ #define TSDB_TABLE_NAME_LEN 193 // it is a null-terminated string #define TSDB_DB_NAME_LEN 33 #define TSDB_FUNC_NAME_LEN 128 +#define TSDB_FUNC_CODE_LEN (4096 - 512) #define TSDB_TABLE_FNAME_LEN (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_TABLE_NAME_LEN) #define TSDB_COL_NAME_LEN 65 #define TSDB_MAX_SAVED_SQL_LEN TSDB_MAX_COLUMNS * 64 diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h index af933fa4e9cb194034b68643cdf23dbb6811ee02..9b7b746116619464cd49e03ef13bc1267f1ec502 100644 --- a/src/inc/taoserror.h +++ b/src/inc/taoserror.h @@ -173,6 +173,12 @@ int32_t* taosGetErrno(); #define TSDB_CODE_MND_INVALID_STABLE_NAME TAOS_DEF_ERROR_CODE(0, 0x036D) //"Super table does not exist") #define TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG TAOS_DEF_ERROR_CODE(0, 0x036E) //"Invalid create table message") +#define TSDB_CODE_MND_INVALID_FUNC_NAME TAOS_DEF_ERROR_CODE(0, 0x0370) //"Invalid func name") +#define TSDB_CODE_MND_INVALID_FUNC_LEN TAOS_DEF_ERROR_CODE(0, 0x0371) //"Invalid func length") +#define TSDB_CODE_MND_INVALID_FUNC_CODE TAOS_DEF_ERROR_CODE(0, 0x0372) //"Invalid func code") +#define TSDB_CODE_MND_FUNC_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x0373) //"Func already exists") +#define TSDB_CODE_MND_INVALID_FUNC TAOS_DEF_ERROR_CODE(0, 0x0351) //"Invalid func") + #define TSDB_CODE_MND_DB_NOT_SELECTED TAOS_DEF_ERROR_CODE(0, 0x0380) //"Database not specified or available") #define TSDB_CODE_MND_DB_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x0381) //"Database already exists") #define TSDB_CODE_MND_INVALID_DB_OPTION TAOS_DEF_ERROR_CODE(0, 0x0382) //"Invalid database options") diff --git a/src/mnode/inc/mnodeDef.h b/src/mnode/inc/mnodeDef.h index ed1de1b87a475cf5a2264abb4b8787c0841d1b63..0a6f66c44b020216d3583f19abb52f16f03cb72d 100644 --- a/src/mnode/inc/mnodeDef.h +++ b/src/mnode/inc/mnodeDef.h @@ -214,6 +214,17 @@ typedef struct SUserObj { struct SAcctObj * pAcct; } SUserObj; +typedef struct SFuncObj { + char name[TSDB_FUNC_NAME_LEN]; + char path[PATH_MAX]; + int32_t codeLen; + char code[TSDB_FUNC_CODE_LEN]; + int64_t createdTime; + int8_t reserved[64]; + int8_t updateEnd[4]; + int32_t refCount; +} SFuncObj; + typedef struct { int64_t totalStorage; // Total storage wrtten from this account int64_t compStorage; // Compressed storage on disk diff --git a/src/mnode/inc/mnodeFunc.h b/src/mnode/inc/mnodeFunc.h new file mode 100644 index 0000000000000000000000000000000000000000..4cf2c16936d91b2c970e3eccbc7e9d3b5cf675db --- /dev/null +++ b/src/mnode/inc/mnodeFunc.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#ifndef TDENGINE_MNODE_FUNC_H +#define TDENGINE_MNODE_FUNC_H + +#ifdef __cplusplus +extern "C" { +#endif +#include "mnodeDef.h" + +int32_t mnodeInitFuncs(); +void mnodeCleanupFuncs(); + +SFuncObj *mnodeGetFunc(char *name); +void * mnodeGetNextFunc(void *pIter, SFuncObj **pFunc); +void mnodeCancelGetNextFunc(void *pIter); + +void mnodeIncFuncRef(SFuncObj *pFunc); +void mnodeDecFuncRef(SFuncObj *pFunc); + +int32_t mnodeCreateFunc(SAcctObj *pAcct, char *name, int32_t codeLen, char *code, char *path, SMnodeMsg *pMsg); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/mnode/inc/mnodeSdb.h b/src/mnode/inc/mnodeSdb.h index e4e4a7a054ff194a578dbaad75b2ae17bfe6f1ad..3d997a21f32dcea9ac9d5517d57d3880302d585b 100644 --- a/src/mnode/inc/mnodeSdb.h +++ b/src/mnode/inc/mnodeSdb.h @@ -33,7 +33,8 @@ typedef enum { SDB_TABLE_VGROUP = 6, SDB_TABLE_STABLE = 7, SDB_TABLE_CTABLE = 8, - SDB_TABLE_MAX = 9 + SDB_TABLE_FUNC = 9, + SDB_TABLE_MAX = 10 } ESdbTable; typedef enum { @@ -110,4 +111,4 @@ bool sdbCheckRowDeleted(void *pTable, void *pRow); } #endif -#endif \ No newline at end of file +#endif diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c index a4f7d74dee5def42d26ecdfb3a12421c72dbf8c7..0b97df2d380e98004894659028529954b6ab0059 100644 --- a/src/mnode/src/mnodeDb.c +++ b/src/mnode/src/mnodeDb.c @@ -44,17 +44,12 @@ void * tsDbSdb = NULL; static int32_t tsDbUpdateSize; static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg *pMsg); -static int32_t mnodeCreateFunc(SAcctObj *pAcct, SCreateFuncMsg *pCreate, SMnodeMsg *pMsg); static int32_t mnodeDropDb(SMnodeMsg *newMsg); static int32_t mnodeSetDbDropping(SDbObj *pDb); static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); static int32_t mnodeRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn); static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg); -static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg); static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg); -static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg); int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg); @@ -182,14 +177,10 @@ int32_t mnodeInitDbs() { } mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DB, mnodeProcessCreateDbMsg); - mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_FUNCTION, mnodeProcessCreateFuncMsg); mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_DB, mnodeProcessAlterDbMsg); mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_DB, mnodeProcessDropDbMsg); - mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_FUNCTION, mnodeProcessDropFuncMsg); mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DB, mnodeGetDbMeta); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeGetFuncMeta); mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DB, mnodeRetrieveDbs); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeRetrieveFuncs); mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_DB, mnodeCancelGetNextDb); mDebug("table:dbs table is created"); @@ -473,17 +464,6 @@ static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg * return code; } -static int32_t mnodeCreateFunc(SAcctObj *pAcct, SCreateFuncMsg *pCreate, SMnodeMsg *pMsg) { - int32_t code = acctCheck(pAcct, ACCT_GRANT_DB); - if (code != 0) return code; - - mError("Function name:%s, path:%s, code:%.*s", pCreate->name, pCreate->path, pCreate->codeLen, pCreate->code); - - return code; -} - - - bool mnodeCheckIsMonitorDB(char *db, char *monitordb) { char dbName[TSDB_DB_NAME_LEN] = {0}; extractDBName(db, dbName); @@ -707,41 +687,6 @@ static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn return 0; } -static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { - int32_t cols = 0; - - SSchema *pSchema = pMeta->schema; - - pShow->bytes[cols] = (TSDB_FUNC_NAME_LEN - 1) + VARSTR_HEADER_SIZE; - pSchema[cols].type = TSDB_DATA_TYPE_BINARY; - strcpy(pSchema[cols].name, "name"); - pSchema[cols].bytes = htons(pShow->bytes[cols]); - cols++; - - pShow->bytes[cols] = PATH_MAX + VARSTR_HEADER_SIZE; - pSchema[cols].type = TSDB_DATA_TYPE_BINARY; - strcpy(pSchema[cols].name, "path"); - pSchema[cols].bytes = htons(pShow->bytes[cols]); - cols++; - - pMeta->numOfColumns = htons(cols); - pShow->numOfColumns = cols; - - pShow->offset[0] = 0; - for (int32_t i = 1; i < cols; ++i) { - pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1]; - } - - pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; - - //TODO GET ROWS NUM - - pShow->numOfRows = 1; - - return 0; -} - - char *mnodeGetDbStr(char *src) { char *pos = strstr(src, TS_PATH_DELIMITER); if (pos != NULL) ++pos; @@ -889,36 +834,6 @@ static int32_t mnodeRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void return numOfRows; } - -static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn) { - int32_t numOfRows = 0; - char * pWrite; - int32_t cols = 0; - - while (numOfRows < rows) { - cols = 0; - - pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - - STR_WITH_MAXSIZE_TO_VARSTR(pWrite, "aaa", pShow->bytes[cols]); - - cols++; - - pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - STR_WITH_MAXSIZE_TO_VARSTR(pWrite, "/tmp/abc", pShow->bytes[cols]); - cols++; - - numOfRows++; - } - - pShow->numOfReads += numOfRows; - mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow); - - return numOfRows; -} - - - void mnodeAddSuperTableIntoDb(SDbObj *pDb) { atomic_add_fetch_32(&pDb->numOfSuperTables, 1); } @@ -980,23 +895,6 @@ static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg) { return code; } -static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg) { - SCreateFuncMsg *pCreate = pMsg->rpcMsg.pCont; - pCreate->codeLen = htonl(pCreate->codeLen); - - int32_t code; - if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_GRANT_EXPIRED; - } else if (!pMsg->pUser->writeAuth) { - code = TSDB_CODE_MND_NO_RIGHTS; - } else { - code = mnodeCreateFunc(pMsg->pUser->pAcct, pCreate, pMsg); - } - - return code; -} - - static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SAlterDbMsg *pAlter) { SDbCfg newCfg = pDb->cfg; int32_t maxTables = htonl(pAlter->maxTables); @@ -1290,15 +1188,6 @@ static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg) { return mnodeDropDb(pMsg); } -static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg) { - SDropFuncMsg *pDrop = pMsg->rpcMsg.pCont; - - mError("drop function:%s", pDrop->name); - - return TSDB_CODE_SUCCESS; -} - - void mnodeDropAllDbs(SAcctObj *pAcct) { int32_t numOfDbs = 0; SDbObj *pDb = NULL; diff --git a/src/mnode/src/mnodeFunc.c b/src/mnode/src/mnodeFunc.c new file mode 100644 index 0000000000000000000000000000000000000000..47e45871cff508746c17a75401d1642e7e35a258 --- /dev/null +++ b/src/mnode/src/mnodeFunc.c @@ -0,0 +1,388 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#define _DEFAULT_SOURCE +#include "os.h" +#include "trpc.h" +#include "tutil.h" +#include "tglobal.h" +#include "tgrant.h" +#include "tdataformat.h" +#include "tkey.h" +#include "mnode.h" +#include "dnode.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeAcct.h" +#include "mnodeUser.h" +#include "mnodeMnode.h" +#include "mnodeSdb.h" +#include "mnodeShow.h" +#include "mnodeFunc.h" +#include "mnodeWrite.h" +#include "mnodePeer.h" + +int64_t tsFuncRid = -1; +static void * tsFuncSdb = NULL; +static int32_t tsFuncUpdateSize = 0; +static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); +static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn); +static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg); +static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg); + +static int32_t mnodeFuncActionDestroy(SSdbRow *pRow) { + tfree(pRow->pObj); + return TSDB_CODE_SUCCESS; +} + +static int32_t mnodeFuncActionInsert(SSdbRow *pRow) { + SFuncObj *pFunc = pRow->pObj; + + mTrace("func:%s, length: %d, insert into sdb", pFunc->name, pFunc->codeLen); + + return TSDB_CODE_SUCCESS; +} + +static int32_t mnodeFuncActionDelete(SSdbRow *pRow) { + SFuncObj *pFunc = pRow->pObj; + + mTrace("func:%s, length: %d, delete from sdb", pFunc->name, pFunc->codeLen); + + return TSDB_CODE_SUCCESS; +} + +static int32_t mnodeFuncActionUpdate(SSdbRow *pRow) { + SFuncObj *pFunc = pRow->pObj; + + SFuncObj *pSaved = mnodeGetFunc(pFunc->name); + if (pFunc != pSaved) { + memcpy(pSaved, pFunc, tsFuncUpdateSize); + free(pFunc); + } + mnodeDecFuncRef(pSaved); + + return TSDB_CODE_SUCCESS; +} + +static int32_t mnodeFuncActionEncode(SSdbRow *pRow) { + SFuncObj *pFunc = pRow->pObj; + + memcpy(pRow->rowData, pFunc, tsFuncUpdateSize); + pRow->rowSize = tsFuncUpdateSize; + + return TSDB_CODE_SUCCESS; +} + +static int32_t mnodeFuncActionDecode(SSdbRow *pRow) { + SFuncObj *pFunc = (SFuncObj *)calloc(1, sizeof(SFuncObj)); + if (pFunc == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY; + + memcpy(pFunc, pRow->rowData, tsFuncUpdateSize); + pRow->pObj = pFunc; + + return TSDB_CODE_SUCCESS; +} + +static int32_t mnodeFuncActionRestored() { + int64_t numOfRows = sdbGetNumOfRows(tsFuncSdb); + + if (numOfRows <= 0 && dnodeIsFirstDeploy()) { + mInfo("dnode first deploy, func restored."); + } + + return TSDB_CODE_SUCCESS; +} + +int32_t mnodeInitFuncs() { + SFuncObj tObj; + tsFuncUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj); + + SSdbTableDesc desc = { + .id = SDB_TABLE_FUNC, + .name = "funcs", + .hashSessions = TSDB_DEFAULT_USERS_HASH_SIZE, + .maxRowSize = tsFuncUpdateSize, + .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj), + .keyType = SDB_KEY_STRING, + .fpInsert = mnodeFuncActionInsert, + .fpDelete = mnodeFuncActionDelete, + .fpUpdate = mnodeFuncActionUpdate, + .fpEncode = mnodeFuncActionEncode, + .fpDecode = mnodeFuncActionDecode, + .fpDestroy = mnodeFuncActionDestroy, + .fpRestored = mnodeFuncActionRestored + }; + + tsFuncRid = sdbOpenTable(&desc); + tsFuncSdb = sdbGetTableByRid(tsFuncRid); + if (tsFuncSdb == NULL) { + mError("table:%s, failed to create hash", desc.name); + return -1; + } + + mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_FUNCTION, mnodeProcessCreateFuncMsg); + mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_FUNCTION, mnodeProcessDropFuncMsg); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeGetFuncMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeRetrieveFuncs); + mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeCancelGetNextFunc); + + mDebug("table:%s, hash is created", desc.name); + + return 0; +} + +void mnodeCleanupFuncs() { + sdbCloseTable(tsFuncRid); + tsFuncSdb = NULL; +} + +SFuncObj *mnodeGetFunc(char *name) { + return (SFuncObj *)sdbGetRow(tsFuncSdb, name); +} + +void *mnodeGetNextFunc(void *pIter, SFuncObj **pFunc) { + return sdbFetchRow(tsFuncSdb, pIter, (void **)pFunc); +} + +void mnodeCancelGetNextFunc(void *pIter) { + sdbFreeIter(tsFuncSdb, pIter); +} + +void mnodeIncFuncRef(SFuncObj *pFunc) { + sdbIncRef(tsFuncSdb, pFunc); +} + +void mnodeDecFuncRef(SFuncObj *pFunc) { + sdbDecRef(tsFuncSdb, pFunc); +} +/* +static int32_t mnodeUpdateFunc(SFuncObj *pFunc, void *pMsg) { + SSdbRow row = { + .type = SDB_OPER_GLOBAL, + .pTable = tsFuncSdb, + .pObj = pFunc, + .pMsg = pMsg + }; + + int32_t code = sdbUpdateRow(&row); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { + mError("func:%s, failed to alter by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code)); + } else { + mLInfo("func:%s, is altered by %s", pFunc->name, mnodeGetUserFromMsg(pMsg)); + } + + return code; +} +*/ +int32_t mnodeCreateFunc(SAcctObj *pAcct, char *name, int32_t codeLen, char *codeScript, char *path, SMnodeMsg *pMsg) { + if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { + return TSDB_CODE_GRANT_EXPIRED; + } + + if (!pMsg->pUser->writeAuth) { + return TSDB_CODE_MND_NO_RIGHTS; + } + + int32_t code = acctCheck(pAcct, ACCT_GRANT_USER); + if (code != TSDB_CODE_SUCCESS) { + return code; + } + + code = grantCheck(TSDB_GRANT_USER); + if (code != TSDB_CODE_SUCCESS) { + return code; + } + + if (name[0] == 0) { + return TSDB_CODE_MND_INVALID_FUNC_NAME; + } + + if (codeScript[0] == 0) { + return TSDB_CODE_MND_INVALID_FUNC_CODE; + } + + if (codeLen < 0 || codeLen > TSDB_FUNC_CODE_LEN - 1) { + return TSDB_CODE_MND_INVALID_FUNC_LEN; + } + + SFuncObj *pFunc = mnodeGetFunc(name); + if (pFunc != NULL) { + mDebug("func:%s, is already there", name); + mnodeDecFuncRef(pFunc); + return TSDB_CODE_MND_FUNC_ALREADY_EXIST; + } + + pFunc = calloc(1, sizeof(SFuncObj)); + tstrncpy(pFunc->name, name, TSDB_FUNC_NAME_LEN); + tstrncpy(pFunc->path, path, PATH_MAX); + tstrncpy(pFunc->code, codeScript, TSDB_FUNC_CODE_LEN); + pFunc->codeLen = codeLen; + pFunc->createdTime = taosGetTimestampMs(); + + SSdbRow row = { + .type = SDB_OPER_GLOBAL, + .pTable = tsFuncSdb, + .pObj = pFunc, + .rowSize = sizeof(SFuncObj), + .pMsg = pMsg + }; + + code = sdbInsertRow(&row); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { + mError("func:%s, failed to create by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code)); + tfree(pFunc); + } else { + mLInfo("func:%s, is created by %s", pFunc->name, mnodeGetUserFromMsg(pMsg)); + } + + return code; +} + +static int32_t mnodeDropFunc(SFuncObj *pFunc, void *pMsg) { + SSdbRow row = { + .type = SDB_OPER_GLOBAL, + .pTable = tsFuncSdb, + .pObj = pFunc, + .pMsg = pMsg + }; + + int32_t code = sdbDeleteRow(&row); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { + mError("func:%s, failed to drop by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code)); + } else { + mLInfo("func:%s, is dropped by %s", pFunc->name, mnodeGetUserFromMsg(pMsg)); + } + + return code; +} + +static int32_t mnodeGetFuncsNum() { + return (int32_t)sdbGetNumOfRows(tsFuncSdb); +} + +static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { + SUserObj *pUser = mnodeGetUserFromConn(pConn); + if (pUser == NULL) { + return TSDB_CODE_MND_NO_USER_FROM_CONN; + } + + int32_t cols = 0; + SSchema *pSchema = pMeta->schema; + + pShow->bytes[cols] = TSDB_FUNC_NAME_LEN + VARSTR_HEADER_SIZE; + pSchema[cols].type = TSDB_DATA_TYPE_BINARY; + strcpy(pSchema[cols].name, "name"); + pSchema[cols].bytes = htons(pShow->bytes[cols]); + cols++; + + pShow->bytes[cols] = PATH_MAX + VARSTR_HEADER_SIZE; + pSchema[cols].type = TSDB_DATA_TYPE_BINARY; + strcpy(pSchema[cols].name, "path"); + pSchema[cols].bytes = htons(pShow->bytes[cols]); + cols++; + + pShow->bytes[cols] = 8; + pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP; + strcpy(pSchema[cols].name, "create_time"); + pSchema[cols].bytes = htons(pShow->bytes[cols]); + cols++; + + pShow->bytes[cols] = 4; + pSchema[cols].type = TSDB_DATA_TYPE_INT; + strcpy(pSchema[cols].name, "code_len"); + pSchema[cols].bytes = htons(pShow->bytes[cols]); + cols++; + + pShow->bytes[cols] = TSDB_FUNC_CODE_LEN + VARSTR_HEADER_SIZE; + pSchema[cols].type = TSDB_DATA_TYPE_BINARY; + strcpy(pSchema[cols].name, "code"); + pSchema[cols].bytes = htons(pShow->bytes[cols]); + cols++; + + pMeta->numOfColumns = htons(cols); + strcpy(pMeta->tableFname, "show funcs"); + pShow->numOfColumns = cols; + + pShow->offset[0] = 0; + for (int32_t i = 1; i < cols; ++i) { + pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1]; + } + + pShow->numOfRows = mnodeGetFuncsNum(); + pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; + + mnodeDecUserRef(pUser); + + return 0; +} + +static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn) { + int32_t numOfRows = 0; + SFuncObj *pFunc = NULL; + int32_t cols = 0; + char *pWrite; + + while (numOfRows < rows) { + pShow->pIter = mnodeGetNextFunc(pShow->pIter, &pFunc); + if (pFunc == NULL) break; + + cols = 0; + + pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; + STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->name, pShow->bytes[cols]); + cols++; + + pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; + STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->path, pShow->bytes[cols]); + cols++; + + pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; + *(int64_t *)pWrite = pFunc->createdTime; + cols++; + + pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; + *(int32_t *)pWrite = pFunc->codeLen; + cols++; + + pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; + STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->code, pShow->bytes[cols]); + cols++; + + numOfRows++; + mnodeDecFuncRef(pFunc); + } + + mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow); + pShow->numOfReads += numOfRows; + return numOfRows; +} + +static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg) { + SCreateFuncMsg *pCreate = pMsg->rpcMsg.pCont; + pCreate->codeLen = htonl(pCreate->codeLen); + + return mnodeCreateFunc(pMsg->pUser->pAcct, pCreate->name, pCreate->codeLen, pCreate->code, pCreate->path, pMsg); +} + +static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg) { + SDropFuncMsg *pDrop = pMsg->rpcMsg.pCont; + + SFuncObj *pFunc = mnodeGetFunc(pDrop->name); + if (pFunc == NULL) { + return TSDB_CODE_MND_INVALID_FUNC; + } + + return mnodeDropFunc(pFunc, pMsg); +} diff --git a/src/mnode/src/mnodeMain.c b/src/mnode/src/mnodeMain.c index 7ef0488c420dd470c3afc5d7ca8ac7a518ccdc73..fca502391c26152f6d1c9394c4f5cb46d18b8679 100644 --- a/src/mnode/src/mnodeMain.c +++ b/src/mnode/src/mnodeMain.c @@ -32,6 +32,7 @@ #include "mnodeSdb.h" #include "mnodeVgroup.h" #include "mnodeUser.h" +#include "mnodeFunc.h" #include "mnodeTable.h" #include "mnodeCluster.h" #include "mnodeShow.h" @@ -46,6 +47,7 @@ static SStep tsMnodeSteps[] = { {"cluster", mnodeInitCluster, mnodeCleanupCluster}, {"accts", mnodeInitAccts, mnodeCleanupAccts}, {"users", mnodeInitUsers, mnodeCleanupUsers}, + {"funcs", mnodeInitFuncs, mnodeCleanupFuncs}, {"dnodes", mnodeInitDnodes, mnodeCleanupDnodes}, {"dbs", mnodeInitDbs, mnodeCleanupDbs}, {"vgroups", mnodeInitVgroups, mnodeCleanupVgroups}, diff --git a/src/util/src/terror.c b/src/util/src/terror.c index 221e6183909682680b68c7a0debb2a90eca34c37..0c88c9fc8bc35f337ba865ad8c6f9814d937cd99 100644 --- a/src/util/src/terror.c +++ b/src/util/src/terror.c @@ -185,6 +185,12 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_NOT_EXIST, "Field does not exist" TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STABLE_NAME, "Super table does not exist") TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG, "Invalid create table message") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_NAME, "Invalid func name") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_LEN, "Invalid func length") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_CODE, "Invalid func code") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_FUNC_ALREADY_EXIST, "Func already exists") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC, "Invalid func") + TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_SELECTED, "Database not specified or available") TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_ALREADY_EXIST, "Database already exists") TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION, "Invalid database options")