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

enh: return error code

This commit is contained in:
kailixu 2024-07-19 18:10:43 +08:00
parent 41198c554b
commit b2c60945d7
7 changed files with 184 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/util/tutil.h
View File

@ -172,18 +172,6 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
} \
} while (0)
#define TAOS_CHECK_EXEC_GOTO(CMD, LINO, EXEC, LABEL) \
do { \
code = (CMD); \
if (code != TSDB_CODE_SUCCESS) { \
if (LINO) { \
*((int32_t *)(LINO)) = __LINE__; \
} \
(EXEC); \
goto LABEL; \
} \
} while (0)
#define TAOS_UNUSED(expr) (void)(expr)
#ifdef __cplusplus

28
source/dnode/mnode/impl/inc/mndUser.h
View File

@ -27,22 +27,22 @@ enum {
IP_WHITE_ADD,
IP_WHITE_DROP,
};
int32_t mndInitUser(SMnode *pMnode);
void mndCleanupUser(SMnode *pMnode);
int32_t mndAcquireUser(SMnode *pMnode, const char *userName, SUserObj **ppUser);
void mndReleaseUser(SMnode *pMnode, SUserObj *pUser);
int32_t mndInitUser(SMnode *pMnode);
void mndCleanupUser(SMnode *pMnode);
int32_t mndAcquireUser(SMnode *pMnode, const char *userName, SUserObj **ppUser);
void mndReleaseUser(SMnode *pMnode, SUserObj *pUser);
// for trans test
SSdbRaw *mndUserActionEncode(SUserObj *pUser);
int32_t mndDupDbHash(SHashObj *pOld, SHashObj **ppNew);
int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew);
int32_t mndDupTopicHash(SHashObj *pOld, SHashObj **ppNew);
int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp,
int32_t *pRspLen, int64_t ipWhiteListVer);
int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db);
int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb);
int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view);
int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic);
SSdbRaw *mndUserActionEncode(SUserObj *pUser);
int32_t mndDupDbHash(SHashObj *pOld, SHashObj **ppNew);
int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew);
int32_t mndDupTopicHash(SHashObj *pOld, SHashObj **ppNew);
int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp,
int32_t *pRspLen, int64_t ipWhiteListVer);
int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db);
int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb);
int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view);
int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic);
int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew);
void mndUserFreeObj(SUserObj *pUser);

169
source/dnode/mnode/impl/src/mndUser.c
View File

@ -95,11 +95,11 @@
#define ALTER_USER_DEL_SUBSCRIBE_TOPIC_PRIV(_type, _priv) \
(ALTER_USER_DEL_PRIVS(_type) && ALTER_USER_SUBSCRIBE_PRIV(_priv))
static SIpWhiteList *createDefaultIpWhiteList();
SIpWhiteList *createIpWhiteList(void *buf, int32_t len);
static bool updateIpWhiteList(SIpWhiteList *pOld, SIpWhiteList *pNew);
static bool isIpWhiteListEqual(SIpWhiteList *a, SIpWhiteList *b);
static bool isIpRangeEqual(SIpV4Range *a, SIpV4Range *b);
static int32_t createDefaultIpWhiteList(SIpWhiteList **ppWhiteList);
SIpWhiteList *createIpWhiteList(void *buf, int32_t len);
static bool updateIpWhiteList(SIpWhiteList *pOld, SIpWhiteList *pNew);
static bool isIpWhiteListEqual(SIpWhiteList *a, SIpWhiteList *b);
static bool isIpRangeEqual(SIpV4Range *a, SIpV4Range *b);
void destroyIpWhiteTab(SHashObj *pIpWhiteTab);
@ -645,20 +645,24 @@ SIpWhiteList *createIpWhiteList(void *buf, int32_t len) {
return p;
}
static SIpWhiteList *createDefaultIpWhiteList() {
SIpWhiteList *pWhiteList = taosMemoryCalloc(1, sizeof(SIpWhiteList) + sizeof(SIpV4Range) * 1);
pWhiteList->num = 1;
SIpV4Range *range = &(pWhiteList->pIpRange[0]);
static int32_t createDefaultIpWhiteList(SIpWhiteList **ppWhiteList) {
*ppWhiteList = taosMemoryCalloc(1, sizeof(SIpWhiteList) + sizeof(SIpV4Range) * 1);
if (*ppWhiteList == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
(*ppWhiteList)->num = 1;
SIpV4Range *range = &((*ppWhiteList)->pIpRange[0]);
struct in_addr addr;
if (uv_inet_pton(AF_INET, "127.0.0.1", &addr) == 0) {
range->ip = addr.s_addr;
range->mask = 32;
}
return pWhiteList;
return 0;
}
static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char *pass) {
int32_t code = 0;
SUserObj userObj = {0};
taosEncryptPass_c((uint8_t *)pass, strlen(pass), userObj.pass);
tstrncpy(userObj.user, user, TSDB_USER_LEN);
@ -668,7 +672,7 @@ static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char
userObj.sysInfo = 1;
userObj.enable = 1;
userObj.ipWhiteListVer = taosGetTimestampMs();
userObj.pIpWhiteList = createDefaultIpWhiteList();
TAOS_CHECK_RETURN(createDefaultIpWhiteList(&userObj.pIpWhiteList));
if (strcmp(user, TSDB_DEFAULT_USER) == 0) {
userObj.superUser = 1;
userObj.createdb = 1;
@ -830,7 +834,10 @@ SSdbRaw *mndUserActionEncode(SUserObj *pUser) {
}
SSdbRaw *pRaw = sdbAllocRaw(SDB_USER, USER_VER_NUMBER, size);
if (pRaw == NULL) goto _OVER;
if (pRaw == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
int32_t dataPos = 0;
SDB_SET_BINARY(pRaw, dataPos, pUser->user, TSDB_USER_LEN, _OVER)
@ -973,6 +980,10 @@ SSdbRaw *mndUserActionEncode(SUserObj *pUser) {
int32_t num = pUser->pIpWhiteList->num;
int32_t tlen = sizeof(SIpWhiteList) + num * sizeof(SIpV4Range) + 4;
char *buf = taosMemoryCalloc(1, tlen);
if (buf == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
int32_t len = tSerializeIpWhiteList(buf, tlen, pUser->pIpWhiteList);
SDB_SET_INT32(pRaw, dataPos, len, _OVER);
@ -1306,12 +1317,11 @@ static int32_t mndUserActionInsert(SSdb *pSdb, SUserObj *pUser) {
}
int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew) {
int32_t code = 0;
*ppNew =
taosHashInit(taosHashGetSize(pOld), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
if (*ppNew == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
TAOS_CHECK_RETURN(NULL);
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
char *tb = taosHashIterate(pOld, NULL);
@ -1320,24 +1330,24 @@ int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew) {
char *key = taosHashGetKey(tb, &keyLen);
int32_t valueLen = strlen(tb) + 1;
if (taosHashPut(pNew, key, keyLen, tb, valueLen) != 0) {
if ((code = taosHashPut(*ppNew, key, keyLen, tb, valueLen)) != 0) {
taosHashCancelIterate(pOld, tb);
taosHashCleanup(pNew);
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
taosHashCleanup(*ppNew);
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line after terrno is removed
TAOS_RETURN(code);
}
tb = taosHashIterate(pOld, tb);
}
return pNew;
TAOS_RETURN(code);
}
SHashObj *mndDupUseDbHash(SHashObj *pOld) {
SHashObj *pNew =
int32_t mndDupUseDbHash(SHashObj *pOld, SHashObj **ppNew) {
int32_t code = 0;
*ppNew =
taosHashInit(taosHashGetSize(pOld), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
if (pNew == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
if (*ppNew == NULL) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
int32_t *db = taosHashIterate(pOld, NULL);
@ -1345,42 +1355,43 @@ SHashObj *mndDupUseDbHash(SHashObj *pOld) {
size_t keyLen = 0;
char *key = taosHashGetKey(db, &keyLen);
if (taosHashPut(pNew, key, keyLen, db, sizeof(*db)) != 0) {
if ((code = taosHashPut(*ppNew, key, keyLen, db, sizeof(*db))) != 0) {
taosHashCancelIterate(pOld, db);
taosHashCleanup(pNew);
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
taosHashCleanup(*ppNew);
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line after terrno is removed
TAOS_RETURN(code);
}
db = taosHashIterate(pOld, db);
}
return pNew;
TAOS_RETURN(code);
}
int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) {
int32_t code = 0;
memcpy(pNew, pUser, sizeof(SUserObj));
pNew->authVersion++;
pNew->updateTime = taosGetTimestampMs();
taosRLockLatch(&pUser->lock);
pNew->readDbs = mndDupDbHash(pUser->readDbs);
pNew->writeDbs = mndDupDbHash(pUser->writeDbs);
pNew->readTbs = mndDupTableHash(pUser->readTbs);
pNew->writeTbs = mndDupTableHash(pUser->writeTbs);
pNew->alterTbs = mndDupTableHash(pUser->alterTbs);
pNew->readViews = mndDupTableHash(pUser->readViews);
pNew->writeViews = mndDupTableHash(pUser->writeViews);
pNew->alterViews = mndDupTableHash(pUser->alterViews);
pNew->topics = mndDupTopicHash(pUser->topics);
pNew->useDbs = mndDupUseDbHash(pUser->useDbs);
TAOS_CHECK_GOTO(mndDupDbHash(pUser->readDbs, &pNew->readDbs), NULL, _OVER);
TAOS_CHECK_GOTO(mndDupDbHash(pUser->writeDbs, &pNew->writeDbs), NULL, _OVER);
TAOS_CHECK_GOTO(mndDupTableHash(pUser->readTbs, &pNew->readTbs), NULL, _OVER);
TAOS_CHECK_GOTO(mndDupTableHash(pUser->writeTbs, &pNew->writeTbs), NULL, _OVER);
TAOS_CHECK_GOTO(mndDupTableHash(pUser->alterTbs, &pNew->alterTbs), NULL, _OVER);
TAOS_CHECK_GOTO(mndDupTableHash(pUser->readViews, &pNew->readViews), NULL, _OVER);
TAOS_CHECK_GOTO(mndDupTableHash(pUser->writeViews, &pNew->writeViews), NULL, _OVER);
TAOS_CHECK_GOTO(mndDupTableHash(pUser->alterViews, &pNew->alterViews), NULL, _OVER);
TAOS_CHECK_GOTO(mndDupTopicHash(pUser->topics, &pNew->topics), NULL, _OVER);
TAOS_CHECK_GOTO(mndDupUseDbHash(pUser->useDbs, &pNew->useDbs), NULL, _OVER);
pNew->pIpWhiteList = cloneIpWhiteList(pUser->pIpWhiteList);
taosRUnLockLatch(&pUser->lock);
if (pNew->readDbs == NULL || pNew->writeDbs == NULL || pNew->topics == NULL) {
return -1;
if (pNew->pIpWhiteList == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
return 0;
_OVER:
taosRUnLockLatch(&pUser->lock);
TAOS_RETURN(code);
}
void mndUserFreeObj(SUserObj *pUser) {
@ -1436,6 +1447,10 @@ static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOld, SUserObj *pNew) {
int32_t sz = sizeof(SIpWhiteList) + pNew->pIpWhiteList->num * sizeof(SIpV4Range);
pOld->pIpWhiteList = taosMemoryRealloc(pOld->pIpWhiteList, sz);
if (pOld->pIpWhiteList == NULL) {
taosWUnLockLatch(&pOld->lock);
return TSDB_CODE_OUT_OF_MEMORY;
}
memcpy(pOld->pIpWhiteList, pNew->pIpWhiteList, sz);
pOld->ipWhiteListVer = pNew->ipWhiteListVer;
@ -1464,6 +1479,7 @@ void mndReleaseUser(SMnode *pMnode, SUserObj *pUser) {
}
static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate, SRpcMsg *pReq) {
int32_t code = 0;
SUserObj userObj = {0};
if (pCreate->isImport != 1) {
taosEncryptPass_c((uint8_t *)pCreate->pass, strlen(pCreate->pass), userObj.pass);
@ -1481,14 +1497,16 @@ static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate
userObj.createdb = pCreate->createDb;
if (pCreate->numIpRanges == 0) {
userObj.pIpWhiteList = createDefaultIpWhiteList();
TAOS_CHECK_RETURN(createDefaultIpWhiteList(&userObj.pIpWhiteList));
} else {
SHashObj *pUniqueTab = taosHashInit(64, MurmurHash3_32, false, HASH_NO_LOCK);
if(pUniqueTab == NULL){
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
int32_t dummpy = 0;
for (int i = 0; i < pCreate->numIpRanges; i++) {
SIpV4Range range = {.ip = pCreate->pIpRanges[i].ip, .mask = pCreate->pIpRanges[i].mask};
taosHashPut(pUniqueTab, &range, sizeof(range), &dummpy, sizeof(dummpy));
if(code = taosHashPut(pUniqueTab, &range, sizeof(range), &dummpy, sizeof(dummpy));
}
taosHashPut(pUniqueTab, &defaultIpRange, sizeof(defaultIpRange), &dummpy, sizeof(dummpy));
@ -2575,6 +2593,7 @@ static void mndLoopHash(SHashObj *hash, char *priType, SSDataBlock *pBlock, int3
}
static int32_t mndRetrievePrivileges(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
int32_t code = 0;
SMnode *pMnode = pReq->info.node;
SSdb *pSdb = pMnode->pSdb;
int32_t numOfRows = 0;
@ -2806,15 +2825,15 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
SUserAuthBatchRsp batchRsp = {0};
batchRsp.pArray = taosArrayInit(numOfUses, sizeof(SGetUserAuthRsp));
if (batchRsp.pArray == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return -1;
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
int32_t code = 0;
for (int32_t i = 0; i < numOfUses; ++i) {
SUserObj *pUser = mndAcquireUser(pMnode, pUsers[i].user);
SUserObj *pUser = NULL;
code = mndAcquireUser(pMnode, pUsers[i].user, &pUser);
if (pUser == NULL) {
if (TSDB_CODE_MND_USER_NOT_EXIST == terrno) {
if (TSDB_CODE_MND_USER_NOT_EXIST == code) {
SGetUserAuthRsp rsp = {.dropped = 1};
memcpy(rsp.user, pUsers[i].user, TSDB_USER_LEN);
taosArrayPush(batchRsp.pArray, &rsp);
@ -2837,7 +2856,7 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
goto _OVER;
}
taosArrayPush(batchRsp.pArray, &rsp);
(void)taosArrayPush(batchRsp.pArray, &rsp);
mndReleaseUser(pMnode, pUser);
}
@ -2852,9 +2871,7 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
int32_t rspLen = tSerializeSUserAuthBatchRsp(NULL, 0, &batchRsp);
void *pRsp = taosMemoryMalloc(rspLen);
if (pRsp == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
tFreeSUserAuthBatchRsp(&batchRsp);
return -1;
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _OVER);
}
tSerializeSUserAuthBatchRsp(pRsp, rspLen, &batchRsp);
@ -2870,7 +2887,7 @@ _OVER:
*pRspLen = 0;
tFreeSUserAuthBatchRsp(&batchRsp);
return code;
TAOS_RETURN(code);
}
int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
@ -2885,8 +2902,7 @@ int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser);
if (pIter == NULL) break;
code = -1;
if (mndUserDupObj(pUser, &newUser) != 0) {
if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
break;
}
@ -2897,7 +2913,8 @@ int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
(void)taosHashRemove(newUser.writeDbs, db, len);
SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line when terrno is removed
break;
}
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@ -2905,13 +2922,12 @@ int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
mndUserFreeObj(&newUser);
sdbRelease(pSdb, pUser);
code = 0;
}
if (pUser != NULL) sdbRelease(pSdb, pUser);
if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
mndUserFreeObj(&newUser);
return code;
TAOS_RETURN(code);
}
int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
@ -2926,8 +2942,7 @@ int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser);
if (pIter == NULL) break;
code = -1;
if (mndUserDupObj(pUser, &newUser) != 0) {
if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
break;
}
@ -2940,7 +2955,8 @@ int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
(void)taosHashRemove(newUser.alterTbs, stb, len);
SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line when terrno is removed
break;
}
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@ -2948,13 +2964,12 @@ int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
mndUserFreeObj(&newUser);
sdbRelease(pSdb, pUser);
code = 0;
}
if (pUser != NULL) sdbRelease(pSdb, pUser);
if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
mndUserFreeObj(&newUser);
return code;
TAOS_RETURN(code);
}
int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
@ -2969,8 +2984,7 @@ int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser);
if (pIter == NULL) break;
code = -1;
if (mndUserDupObj(pUser, &newUser) != 0) {
if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
break;
}
@ -2983,7 +2997,8 @@ int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
(void)taosHashRemove(newUser.alterViews, view, len);
SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line when terrno is removed
break;
}
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@ -2991,13 +3006,12 @@ int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
mndUserFreeObj(&newUser);
sdbRelease(pSdb, pUser);
code = 0;
}
if (pUser != NULL) sdbRelease(pSdb, pUser);
if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
mndUserFreeObj(&newUser);
return code;
TAOS_RETURN(code);
}
int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
@ -3014,8 +3028,7 @@ int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
break;
}
code = -1;
if (mndUserDupObj(pUser, &newUser) != 0) {
if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
break;
}
@ -3023,7 +3036,8 @@ int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
if (inTopic) {
(void)taosHashRemove(newUser.topics, topic, len);
SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line when terrno is removed
break;
}
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@ -3031,13 +3045,12 @@ int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
mndUserFreeObj(&newUser);
sdbRelease(pSdb, pUser);
code = 0;
}
if (pUser != NULL) sdbRelease(pSdb, pUser);
if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
mndUserFreeObj(&newUser);
return code;
TAOS_RETURN(code);
}
int64_t mndGetUserIpWhiteListVer(SMnode *pMnode, SUserObj *pUser) {

14
source/libs/tfs/inc/tfsInt.h
View File

@ -74,16 +74,16 @@ typedef struct STfs {
SHashObj *hash; // name to did map
} STfs;
STfsDisk *tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *dir);
int32_t tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *dir, STfsDisk **ppDisk);
STfsDisk *tfsFreeDisk(STfsDisk *pDisk);
int32_t tfsUpdateDiskSize(STfsDisk *pDisk);
int32_t tfsInitTier(STfsTier *pTier, int32_t level);
void tfsDestroyTier(STfsTier *pTier);
STfsDisk *tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg);
void tfsUpdateTierSize(STfsTier *pTier);
int32_t tfsAllocDiskOnTier(STfsTier *pTier);
void tfsPosNextId(STfsTier *pTier);
int32_t tfsInitTier(STfsTier *pTier, int32_t level);
void tfsDestroyTier(STfsTier *pTier);
int32_t tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg, STfsDisk **ppDisk);
void tfsUpdateTierSize(STfsTier *pTier);
int32_t tfsAllocDiskOnTier(STfsTier *pTier);
void tfsPosNextId(STfsTier *pTier);
#define tfsLockTier(pTier) taosThreadSpinLock(&(pTier)->lock)
#define tfsUnLockTier(pTier) taosThreadSpinUnlock(&(pTier)->lock)

46
source/libs/tfs/src/tfs.c
View File

@ -495,7 +495,9 @@ static int32_t tfsMount(STfs *pTfs, SDiskCfg *pCfg) {
}
SDiskID did = {.level = pCfg->level};
STfsDisk *pDisk = tfsMountDiskToTier(TFS_TIER_AT(pTfs, did.level), pCfg);
STfsDisk *pDisk = NULL;
tfsMountDiskToTier(TFS_TIER_AT(pTfs, did.level), pCfg, &pDisk);
if (pDisk == NULL) {
fError("failed to mount disk %s to level %d since %s", pCfg->dir, pCfg->level, terrstr());
return -1;
@ -515,33 +517,28 @@ static int32_t tfsCheckAndFormatCfg(STfs *pTfs, SDiskCfg *pCfg) {
if (pCfg->level < 0 || pCfg->level >= TFS_MAX_TIERS) {
fError("failed to mount %s to FS since invalid level %d", pCfg->dir, pCfg->level);
terrno = TSDB_CODE_FS_INVLD_CFG;
return -1;
TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
}
if (pCfg->primary < 0 || pCfg->primary > 1) {
fError("failed to mount %s to FS since invalid primary %d", pCfg->dir, pCfg->primary);
terrno = TSDB_CODE_FS_INVLD_CFG;
return -1;
TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
}
if (pCfg->disable < 0 || pCfg->disable > 1) {
fError("failed to mount %s to FS since invalid disable %" PRIi8, pCfg->dir, pCfg->disable);
terrno = TSDB_CODE_FS_INVLD_CFG;
return -1;
TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
}
if (pCfg->primary) {
if (pCfg->level != 0) {
fError("failed to mount %s to FS since disk is primary but level %d not 0", pCfg->dir, pCfg->level);
terrno = TSDB_CODE_FS_INVLD_CFG;
return -1;
TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
}
if (TFS_PRIMARY_DISK(pTfs) != NULL) {
fError("failed to mount %s to FS since duplicate primary mount", pCfg->dir);
terrno = TSDB_CODE_FS_DUP_PRIMARY;
return -1;
TAOS_RETURN(TSDB_CODE_FS_DUP_PRIMARY);
}
}
@ -578,15 +575,14 @@ static int32_t tfsFormatDir(char *idir, char *odir) {
int32_t code = wordexp(idir, &wep, 0);
if (code != 0) {
terrno = TAOS_SYSTEM_ERROR(code);
return -1;
TAOS_RETURN(TAOS_SYSTEM_ERROR(code));
}
char tmp[PATH_MAX] = {0};
if (taosRealPath(wep.we_wordv[0], tmp, PATH_MAX) != 0) {
terrno = TAOS_SYSTEM_ERROR(errno);
code = TAOS_SYSTEM_ERROR(errno);
wordfree(&wep);
return -1;
TAOS_RETURN(code);
}
strcpy(odir, tmp);
@ -597,23 +593,20 @@ static int32_t tfsFormatDir(char *idir, char *odir) {
static int32_t tfsCheck(STfs *pTfs) {
if (TFS_PRIMARY_DISK(pTfs) == NULL) {
fError("no primary disk is set");
terrno = TSDB_CODE_FS_NO_PRIMARY_DISK;
return -1;
TAOS_RETURN(TSDB_CODE_FS_NO_PRIMARY_DISK);
}
for (int32_t level = 0; level < pTfs->nlevel; level++) {
if (TFS_TIER_AT(pTfs, level)->ndisk == 0) {
fError("no disk at level %d", level);
terrno = TSDB_CODE_FS_NO_MOUNT_AT_TIER;
return -1;
TAOS_RETURN(TSDB_CODE_FS_NO_MOUNT_AT_TIER);
}
if (level == 0) {
tfsUpdateTierSize(TFS_TIER_AT(pTfs, level));
if (TFS_TIER_AT(pTfs, level)->nAvailDisks == 0) {
fError("no disk to create new file at level %d", level);
terrno = TSDB_CODE_FS_NO_VALID_DISK;
return -1;
TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
}
}
}
@ -684,7 +677,9 @@ static STfsDisk *tfsNextDisk(STfs *pTfs, SDiskIter *pIter) {
int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo) {
pInfo->datadirs = taosArrayInit(32, sizeof(SMonDiskDesc));
if (pInfo->datadirs == NULL) return -1;
if (pInfo->datadirs == NULL) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
tfsUpdateSize(pTfs);
@ -697,7 +692,12 @@ int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo) {
dinfo.size = pDisk->size;
dinfo.level = pDisk->level;
tstrncpy(dinfo.name, pDisk->path, sizeof(dinfo.name));
taosArrayPush(pInfo->datadirs, &dinfo);
if (taosArrayPush(pInfo->datadirs, &dinfo) == NULL) {
tfsUnLock(pTfs);
taosArrayDestroy(pInfo->datadirs);
pInfo->datadirs = NULL;
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
}
}
tfsUnLock(pTfs);

40
source/libs/tfs/src/tfsDisk.c
View File

@ -16,25 +16,34 @@
#define _DEFAULT_SOURCE
#include "tfsInt.h"
STfsDisk *tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *path) {
STfsDisk *pDisk = taosMemoryCalloc(1, sizeof(STfsDisk));
if (pDisk == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
int32_t tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *path, STfsDisk **ppDisk) {
int32_t code = 0;
int32_t lino = 0;
STfsDisk *pDisk = NULL;
if ((pDisk = taosMemoryCalloc(1, sizeof(STfsDisk))) == NULL) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
}
pDisk->path = taosStrdup(path);
if (pDisk->path == NULL) {
taosMemoryFree(pDisk);
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
if ((pDisk->path = taosStrdup(path)) == NULL) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
}
pDisk->level = level;
pDisk->id = id;
pDisk->disable = disable;
taosGetDiskSize(pDisk->path, &pDisk->size);
return pDisk;
if (taosGetDiskSize(pDisk->path, &pDisk->size) < 0) {
code = TAOS_SYSTEM_ERROR(errno); // TODO: refactor this line
TAOS_CHECK_GOTO(code, &lino, _OVER);
}
_OVER:
if (code != 0) {
pDisk = tfsFreeDisk(pDisk);
fError("%s failed at line %d since %s, disk:%s level:%d id:%d ", __func__, lino, tstrerror(code), path, level, id);
}
*ppDisk = pDisk;
TAOS_RETURN(code);
}
STfsDisk *tfsFreeDisk(STfsDisk *pDisk) {
@ -48,9 +57,10 @@ STfsDisk *tfsFreeDisk(STfsDisk *pDisk) {
int32_t tfsUpdateDiskSize(STfsDisk *pDisk) {
if (taosGetDiskSize(pDisk->path, &pDisk->size) < 0) {
terrno = TAOS_SYSTEM_ERROR(errno);
fError("failed to get disk:%s size, level:%d id:%d since %s", pDisk->path, pDisk->level, pDisk->id, terrstr());
return -1;
int32_t code = TAOS_SYSTEM_ERROR(errno); // TODO: refactor this line
fError("failed to get disk:%s size, level:%d id:%d since %s", pDisk->path, pDisk->level, pDisk->id,
tstrerror(code));
TAOS_RETURN(code);
}
return 0;

38
source/libs/tfs/src/tfsTier.c
View File

@ -22,8 +22,7 @@ int32_t tfsInitTier(STfsTier *pTier, int32_t level) {
memset(pTier, 0, sizeof(STfsTier));
if (taosThreadSpinInit(&pTier->lock, 0) != 0) {
terrno = TAOS_SYSTEM_ERROR(errno);
return -1;
TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
pTier->level = level;
@ -39,10 +38,13 @@ void tfsDestroyTier(STfsTier *pTier) {
taosThreadSpinDestroy(&pTier->lock);
}
STfsDisk *tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg) {
int32_t tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg, STfsDisk **ppDisk) {
int32_t code = 0;
int32_t lino = 0;
STfsDisk *pDisk = NULL;
if (pTier->ndisk >= TFS_MAX_DISKS_PER_TIER) {
terrno = TSDB_CODE_FS_TOO_MANY_MOUNT;
return NULL;
TAOS_CHECK_GOTO(TSDB_CODE_FS_TOO_MANY_MOUNT, &lino, _OVER);
}
int32_t id = 0;
@ -61,18 +63,25 @@ STfsDisk *tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg) {
}
if (id >= TFS_MAX_DISKS_PER_TIER) {
terrno = TSDB_CODE_FS_TOO_MANY_MOUNT;
return NULL;
TAOS_CHECK_GOTO(TSDB_CODE_FS_TOO_MANY_MOUNT, &lino, _OVER);
}
STfsDisk *pDisk = tfsNewDisk(pCfg->level, id, pCfg->disable, pCfg->dir);
if (pDisk == NULL) return NULL;
TAOS_CHECK_GOTO(tfsNewDisk(pCfg->level, id, pCfg->disable, pCfg->dir, &pDisk), &lino, _OVER);
pTier->disks[id] = pDisk;
pTier->ndisk++;
fDebug("disk %s is mounted to tier level %d id %d", pCfg->dir, pCfg->level, id);
return pTier->disks[id];
_OVER:
if (code != 0) {
pDisk = tfsFreeDisk(pDisk);
fError("%s failed at line %d since %s, disk:%s level:%d id:%d", __func__, lino, tstrerror(code), pCfg->dir,
pCfg->level, id);
} else {
*ppDisk = pTier->disks[id];
fDebug("disk %s is mounted to tier level %d id %d", pCfg->dir, pCfg->level, id);
}
TAOS_RETURN(code);
}
void tfsUpdateTierSize(STfsTier *pTier) {
@ -100,13 +109,11 @@ void tfsUpdateTierSize(STfsTier *pTier) {
// Round-Robin to allocate disk on a tier
int32_t tfsAllocDiskOnTier(STfsTier *pTier) {
terrno = TSDB_CODE_FS_NO_VALID_DISK;
tfsLockTier(pTier);
if (pTier->ndisk <= 0 || pTier->nAvailDisks <= 0) {
tfsUnLockTier(pTier);
return -1;
TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
}
int32_t retId = -1;
@ -149,6 +156,9 @@ int32_t tfsAllocDiskOnTier(STfsTier *pTier) {
}
tfsUnLockTier(pTier);
if (retId < 0) {
TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
}
return retId;
}