ClRcT clMsgMessageCancel(SaMsgQueueHandleT qHandle) { ClRcT rc; ClRcT retCode; ClMsgQueueInfoT *pQInfo; CL_OSAL_MUTEX_LOCK(&gClLocalQsLock); rc = clHandleCheckout(gClMsgQDatabase, qHandle, (void**)&pQInfo); if(rc != CL_OK) { CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); clLogError("MSG", "CANL", "Failed to checkout the passed handle. error code [0x%x].", rc); goto error_out; } CL_OSAL_MUTEX_LOCK(&pQInfo->qLock); CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); rc = clMsgUnblockThreadsOfQueue(pQInfo); CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock); retCode = clHandleCheckin(gClMsgQDatabase, qHandle); if(retCode != CL_OK) clLogError("QUE", "CANL", "Failed to checkin queue handle. error code [0x%x].", retCode); error_out: return rc; }
static ClRcT clMsgDebugCliQueueInfo(ClUint32T argc, ClCharT **argv, ClCharT **ret) { ClRcT rc = CL_OK; ClDebugPrintHandleT dbgHdl = 0; clDebugPrintInitialize(&dbgHdl); CL_OSAL_MUTEX_LOCK(&gClLocalQsLock); rc = clHandleWalk(gClMsgQDatabase, clMsgQueueInfoCb, (ClPtrT)dbgHdl); if (rc != CL_OK) { clLogError("MSG", "CLI", "Handle walk failed, error [%#x]", rc); CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); goto out; } CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); clDebugPrintFinalize(&dbgHdl, ret); return CL_OK; out: return rc; }
ClRcT clMsgQueueStatusGet_4_0_0( SaNameT *pQName, SaMsgQueueStatusT *pQueueStatus) { ClRcT rc = CL_OK; ClMsgQueueRecordT *pQEntry; SaMsgQueueHandleT qHandle; CL_MSG_INIT_CHECK(rc); if( rc != CL_OK) { goto error_out; } CL_OSAL_MUTEX_LOCK(&gClQueueDbLock); if(clMsgQNameEntryExists(pQName, &pQEntry) == CL_FALSE) { CL_OSAL_MUTEX_UNLOCK(&gClQueueDbLock); rc = CL_MSG_RC(CL_ERR_DOESNT_EXIST); clLogError("QUE", "STAT", "Queue [%.*s] does not exist. error code [0x%x].", pQName->length, pQName->value, rc); goto error_out; } qHandle = pQEntry->qHandle; CL_OSAL_MUTEX_UNLOCK(&gClQueueDbLock); rc = clMsgQueueStatusGet(qHandle, pQueueStatus); if(rc != CL_OK) clLogTrace("QUE", "STAT", "Failed to get the status of the queue [%.*s]. error code [0x%x].", pQName->length, pQName->value, rc); error_out: return rc; }
ClRcT clMsgQueueFreeByHandle(SaMsgQueueHandleT qHandle) { ClRcT rc; ClMsgQueueInfoT *pQInfo; CL_OSAL_MUTEX_LOCK(&gClLocalQsLock); rc = clHandleCheckout(gClMsgQDatabase, qHandle, (ClPtrT *)&pQInfo); if(rc != CL_OK) { CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); clLogError("QUE", "FREE", "Failed at checkout the passed queue handle. error code [0x%x].", rc); goto error_out; } clMsgQueueFree(pQInfo); clLogDebug("QUE", "FREE", "Queue is freed through its handle."); CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); rc = clHandleCheckin(gClMsgQDatabase, qHandle); if(rc != CL_OK) clLogError("QUE", "FREE", "Failed to checkin a queue handle. error code [0x%x].", rc); rc = clHandleDestroy(gClMsgQDatabase, qHandle); if(rc != CL_OK) clLogError("QUE", "FREE", "Failed to destroy a queue handle. error code [0x%x].", rc); error_out: return rc; }
static void clMsgEventCallbackFunc(ClEventSubscriptionIdT subscriptionId, ClEventHandleT eventHandle, ClSizeT eventDataSize) { ClRcT rc; ClCpmEventNodePayLoadT nodePayload = {{0}}; rc = clCpmEventPayLoadExtract(eventHandle, eventDataSize, CL_CPM_NODE_EVENT, (void *)&nodePayload); if(rc != CL_OK) { clLogError("EVT", "Cbk", "Failed to get event payload data. error code [0x%x].", rc); goto error_out; } if(nodePayload.operation != CL_CPM_NODE_DEPARTURE) goto out; clLogDebug("EVT", "Cbk", "Node [0x%x] is going down. Message queues are going to be failed over.", nodePayload.nodeIocAddress); if(nodePayload.nodeIocAddress == gLocalAddress) { CL_OSAL_MUTEX_LOCK(&gFinBlockMutex); rc = clMsgFinBlockStatusSet(MSG_MOVE_FIN_BLOCKED); CL_OSAL_MUTEX_UNLOCK(&gFinBlockMutex); if(rc != CL_OK) clLogError("EVT", "Cbk", "Failed at block the message finalize on this node. error code [0x%x].", rc); } error_out: out: clEventFree(eventHandle); return; }
ClRcT clMsgQueueRetentionTimeSet(SaMsgQueueHandleT qHandle, SaTimeT *pRetenTime) { ClRcT rc; ClRcT retCode; ClMsgQueueInfoT *pQInfo; CL_OSAL_MUTEX_LOCK(&gClLocalQsLock); rc = clHandleCheckout(gClMsgQDatabase, qHandle, (void **)&pQInfo); if(rc != CL_OK) { CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); clLogError("QUE", "RET", "Failed to checkout the queue handle. error code [0x%x].", rc); goto error_out; } CL_OSAL_MUTEX_LOCK(&pQInfo->qLock); CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); if(pQInfo->state == CL_MSG_QUEUE_CLOSED) { rc = CL_MSG_RC(CL_ERR_INVALID_HANDLE); clLogError("QUE", "RET", "Queue [%.*s] is in closed state. Cannot change retention time. error code [0x%x].", pQInfo->pQueueEntry->qName.length, pQInfo->pQueueEntry->qName.value, rc); goto error_out_1; } if(pQInfo->creationFlags != 0) { rc = CL_MSG_RC(CL_ERR_BAD_OPERATION); clLogError("QUE", "RET", "Retention time can be set for only for non-persistent queues. error code [0x%x].", rc); goto error_out_1; } pQInfo->retentionTime = *pRetenTime; error_out_1: CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock); retCode = clHandleCheckin(gClMsgQDatabase, qHandle); if(retCode != CL_OK) clLogError("QUE", "RET", "Failed to checkin queue handle. error code [0x%x].", retCode); error_out: return rc; }
void * clMsgClosedQueueMoveThread(void *pParam) { ClRcT rc; CL_OSAL_MUTEX_LOCK(&gFinBlockMutex); rc = clMsgFinBlockStatusSet(MSG_MOVE_FIN_BLOCKED); CL_OSAL_MUTEX_UNLOCK(&gFinBlockMutex); if(rc != CL_OK) clLogError("MOV", "Thd", "Failed at block the message finalize on this node. error code [0x%x].", rc); return NULL; }
void clMsgQueueFree(ClMsgQueueInfoT *pQInfo) { ClRcT rc = CL_OK; SaNameT qName = {strlen("--Unknow--"), "--Unknow--"}; ClUint32T i; CL_OSAL_MUTEX_LOCK(&pQInfo->qLock); (void)clMsgUnblockThreadsOfQueue(pQInfo); if(pQInfo->unlinkFlag == CL_FALSE && pQInfo->pQueueEntry != NULL) { saNameCopy(&qName, &pQInfo->pQueueEntry->qName); } if(pQInfo->timerHandle != 0) { rc = clTimerDelete(&pQInfo->timerHandle); if(rc != CL_OK) clLogError("QUE", "FREE", "Failed to delete [%.*s]'s timer handle. error code [0x%x].", qName.length, qName.value, rc); } clMsgQueueEmpty(pQInfo); for(i = 0; i < CL_MSG_QUEUE_PRIORITIES ; i++) { rc = clCntDelete(pQInfo->pPriorityContainer[i]); if(rc != CL_OK) clLogError("QUE", "FREE", "Failed to delete the [%.*s]'s [%d] priority container. error code [0x%x].", qName.length, qName.value, i, rc); else pQInfo->pPriorityContainer[i] = 0; } rc = clOsalCondDelete(pQInfo->qCondVar); if(rc != CL_OK) clLogError("QUE", "FREE", "Failed to delete the [%.*s]'s condtional variable. error code [0x%x].", qName.length, qName.value, rc); pQInfo->qCondVar = 0; CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock); rc = clOsalMutexDestroy(&pQInfo->qLock); if(rc != CL_OK) clLogError("QUE", "FREE", "Failed to delete the [%.*s]'s lock. error code [0x%x].", qName.length, qName.value, rc); clLogDebug("QUE", "FREE", "Freed the queue [%.*s].", qName.length, qName.value); return; }
ClRcT clMsgQueueStatusGet(SaMsgQueueHandleT qHandle, SaMsgQueueStatusT *pQueueStatus) { ClRcT rc, retCode; ClMsgQueueInfoT *pQInfo; ClUint32T i = 0; CL_OSAL_MUTEX_LOCK(&gClLocalQsLock); rc = clHandleCheckout(gClMsgQDatabase, qHandle, (void **)&pQInfo); if(rc != CL_OK) { CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); clLogError("QUE", "STAT", "Failed to checkout the queue handle. error code [0x%x].", rc); goto error_out; } CL_OSAL_MUTEX_LOCK(&pQInfo->qLock); CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); pQueueStatus->creationFlags = pQInfo->creationFlags; pQueueStatus->retentionTime = pQInfo->retentionTime; pQueueStatus->closeTime = pQInfo->closeTime * 1000 ; for(i = 0; i < CL_MSG_QUEUE_PRIORITIES; ++i) { pQueueStatus->saMsgQueueUsage[i].queueSize = pQInfo->size[i]; pQueueStatus->saMsgQueueUsage[i].queueUsed = pQInfo->usedSize[i]; pQueueStatus->saMsgQueueUsage[i].numberOfMessages = pQInfo->numberOfMessages[i]; } CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock); retCode = clHandleCheckin(gClMsgQDatabase, qHandle); if(retCode != CL_OK) clLogError("QUE", "STAT", "Failed to check-in the queue handle. error code [0x%x].", retCode); error_out: return rc; }
ClRcT clMsgQueueOpen(SaMsgQueueHandleT qHandle, SaMsgQueueOpenFlagsT openFlags) { ClRcT rc = CL_OK, retCode; ClMsgQueueInfoT *pQInfo; CL_OSAL_MUTEX_LOCK(&gClLocalQsLock); rc = clHandleCheckout(gClMsgQDatabase, qHandle, (void**)&pQInfo); if(rc != CL_OK) { CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); clLogError("QUE", "OPN", "Failed to checkout a queue handle. error code [0x%x].", rc); goto error_out; } CL_OSAL_MUTEX_LOCK(&pQInfo->qLock); CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock); if(pQInfo->timerHandle) clTimerDelete(&pQInfo->timerHandle); if(openFlags & SA_MSG_QUEUE_EMPTY) clMsgQueueEmpty(pQInfo); pQInfo->openFlags = openFlags; pQInfo->state = CL_MSG_QUEUE_OPEN; pQInfo->closeTime = 0; CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock); retCode = clHandleCheckin(gClMsgQDatabase, qHandle); if(retCode != CL_OK) clLogError("QUE", "OPN", "Failed to check-in queue handle. error code [0x%x].", retCode); error_out: return rc; }
ClRcT clMsgFinalizeBlocker(void) { ClRcT rc = CL_OK; SaTimeT timeout = (SaTimeT)(CL_MSG_FIN_BLOCK_TIME * 1000000000LL); ClTimerTimeOutT tempTime = {0}; CL_OSAL_MUTEX_LOCK(&gFinBlockMutex); if(gMsgMoveStatus == MSG_MOVE_DONE) goto out; clLogDebug("FIN", "BLOCK", "Message service finalize will be blocked for [%llu ns].", timeout); if(gMsgMoveStatus == MSG_MOVE_FIN_UNINIT) { rc = clOsalTaskCreateDetached("allClosedQueueMoverThread", CL_OSAL_SCHED_OTHER, CL_OSAL_THREAD_PRI_NOT_APPLICABLE, 0, clMsgClosedQueueMoveThread, NULL); if(rc != CL_OK) { clLogError("FIN", "BLOCK", "Failed to create a Queue mover thread. error code [0x%x].", rc); goto error_out; } clMsgTimeConvert(&tempTime, timeout); rc = clOsalCondWait(gFinBlockCond, &gFinBlockMutex, tempTime); if(CL_GET_ERROR_CODE(rc) == CL_ERR_TIMEOUT) { clLogError("FIN", "BLOCK", "Finalize blocking timed out. Timeout is [%lld ns]. error code [0x%x].", timeout, rc); } else if(rc != CL_OK) { clLogError("FIN", "BLOCK", "Failed at Conditional Wait. error code [0x%x].", rc); } else { clLogDebug("FIN", "BLOCK", "Message queues are failed over to [0x%x] node.", gQMoveDestNode); } } gMsgMoveStatus = MSG_MOVE_DONE; goto out; error_out: out: CL_OSAL_MUTEX_UNLOCK(&gFinBlockMutex); return rc; }
static ClRcT clMsgQueueInfoCb(ClHandleDatabaseHandleT hdlDb, ClHandleT hdl, ClPtrT pCookie) { ClRcT rc = CL_OK; ClMsgQueueInfoT *pQInfo = NULL; ClDebugPrintHandleT dbgHdl = (ClDebugPrintHandleT)pCookie; ClNameT *qName = NULL; ClUint32T i = 0; rc = clHandleCheckout(hdlDb, hdl, (void **)&pQInfo); if (rc != CL_OK) { clLogError("MSG", "CLI", "Handle checkout failed, error [%#x]", rc); goto out; } CL_OSAL_MUTEX_LOCK(&(pQInfo->qLock)); qName = &(pQInfo->pQueueEntry->qName); clDebugPrint(dbgHdl, "Name : [%.*s]\n", qName->length, qName->value); clDebugPrint(dbgHdl, "Open flags : "); if (pQInfo->openFlags & SA_MSG_QUEUE_CREATE) { clDebugPrint(dbgHdl, "CREATE"); } if (pQInfo->openFlags & SA_MSG_QUEUE_RECEIVE_CALLBACK) { clDebugPrint(dbgHdl, " | RECEIVE_CALLBACK"); } if (pQInfo->openFlags & SA_MSG_QUEUE_EMPTY) { clDebugPrint(dbgHdl, " | EMPTY"); } clDebugPrint(dbgHdl, "\n"); clDebugPrint(dbgHdl, "Persistent : %s\n", (pQInfo->creationFlags & SA_MSG_QUEUE_PERSISTENT) ? "Yes": "No"); if (pQInfo->creationFlags & SA_MSG_QUEUE_PERSISTENT) { clDebugPrint(dbgHdl, "Retention time : -\n"); } else { clDebugPrint(dbgHdl, "Retention time : %lld\n", pQInfo->retentionTime); } clDebugPrint(dbgHdl, "%5s %10s %10s %10s %10s\n", "Priority", " Size (bytes)", " Used (bytes)", " Avail (bytes)", " Number of messages"); for (i = 0; i < CL_MSG_QUEUE_PRIORITIES; ++i) { clDebugPrint(dbgHdl, "%3d %15lld %15lld %10lld %15d\n", i, pQInfo->size[i], pQInfo->usedSize[i], (pQInfo->size[i]-pQInfo->usedSize[i]), pQInfo->numberOfMessages[i]); } clDebugPrint(dbgHdl, "State : %s", (pQInfo->state == CL_MSG_QUEUE_CREATED) ? "CREATED" : (pQInfo->state == CL_MSG_QUEUE_OPEN) ? "OPEN" : (pQInfo->state == CL_MSG_QUEUE_CLOSED) ? "CLOSED" : "INVALID STATE"); clDebugPrint(dbgHdl, "\n"); CL_OSAL_MUTEX_UNLOCK(&(pQInfo->qLock)); return CL_OK; out: return rc; }