RsslReactorCallbackRet channelEventCallback(RsslReactor *pReactor, RsslReactorChannel *pReactorChannel, RsslReactorChannelEvent *pChannelEvent) { ProviderSession *pProvSession = (ProviderSession *)pReactorChannel->userSpecPtr; ProviderThread *pProviderThread = pProvSession->pProviderThread; RsslErrorInfo rsslErrorInfo; RsslReactorChannelInfo reactorChannelInfo; RsslUInt32 count; RsslRet ret; switch(pChannelEvent->channelEventType) { case RSSL_RC_CET_CHANNEL_UP: { /* A channel that we have requested via rsslReactorAccept() has come up. Set our * file descriptor sets so we can be notified to start calling rsslReactorDispatch() for * this channel. */ FD_SET(pReactorChannel->socketId, &pProviderThread->readfds); FD_SET(pReactorChannel->socketId, &pProviderThread->exceptfds); #ifdef ENABLE_XML_TRACE RsslTraceOptions traceOptions; rsslClearTraceOptions(&traceOptions); traceOptions.traceMsgFileName = "upacProvPerf"; traceOptions.traceMsgMaxFileSize = 1000000000; traceOptions.traceFlags |= RSSL_TRACE_TO_FILE_ENABLE | RSSL_TRACE_WRITE | RSSL_TRACE_READ; rsslIoctl(pChannelInfo->pChannel, (RsslIoctlCodes)RSSL_TRACE, (void *)&traceOptions, &error); #endif if (provPerfConfig.highWaterMark > 0) { if (rsslReactorChannelIoctl(pReactorChannel, RSSL_HIGH_WATER_MARK, &provPerfConfig.highWaterMark, &rsslErrorInfo) != RSSL_RET_SUCCESS) { printf("rsslReactorChannelIoctl() of RSSL_HIGH_WATER_MARK failed <%s>\n", rsslErrorInfo.rsslError.text); exit(-1); } } if ((ret = rsslReactorGetChannelInfo(pReactorChannel, &reactorChannelInfo, &rsslErrorInfo)) != RSSL_RET_SUCCESS) { printf("rsslReactorGetChannelInfo() failed: %d\n", ret); return RSSL_RC_CRET_SUCCESS; } printf( "Channel %d active. Channel Info:\n" " maxFragmentSize: %u\n" " maxOutputBuffers: %u\n" " guaranteedOutputBuffers: %u\n" " numInputBuffers: %u\n" " pingTimeout: %u\n" " clientToServerPings: %s\n" " serverToClientPings: %s\n" " sysSendBufSize: %u\n" " sysSendBufSize: %u\n" " compressionType: %s\n" " compressionThreshold: %u\n" " ComponentInfo: ", pReactorChannel->socketId, reactorChannelInfo.rsslChannelInfo.maxFragmentSize, reactorChannelInfo.rsslChannelInfo.maxOutputBuffers, reactorChannelInfo.rsslChannelInfo.guaranteedOutputBuffers, reactorChannelInfo.rsslChannelInfo.numInputBuffers, reactorChannelInfo.rsslChannelInfo.pingTimeout, reactorChannelInfo.rsslChannelInfo.clientToServerPings == RSSL_TRUE ? "true" : "false", reactorChannelInfo.rsslChannelInfo.serverToClientPings == RSSL_TRUE ? "true" : "false", reactorChannelInfo.rsslChannelInfo.sysSendBufSize, reactorChannelInfo.rsslChannelInfo.sysRecvBufSize, reactorChannelInfo.rsslChannelInfo.compressionType == RSSL_COMP_ZLIB ? "zlib" : "none", reactorChannelInfo.rsslChannelInfo.compressionThreshold ); if (reactorChannelInfo.rsslChannelInfo.componentInfoCount == 0) printf("(No component info)"); else for(count = 0; count < reactorChannelInfo.rsslChannelInfo.componentInfoCount; ++count) { printf("%.*s", reactorChannelInfo.rsslChannelInfo.componentInfo[count]->componentVersion.length, reactorChannelInfo.rsslChannelInfo.componentInfo[count]->componentVersion.data); if (count < reactorChannelInfo.rsslChannelInfo.componentInfoCount - 1) printf(", "); } printf ("\n\n"); /* Check that we can successfully pack, if packing messages. */ if (providerThreadConfig.totalBuffersPerPack > 1 && providerThreadConfig.packingBufferLength > reactorChannelInfo.rsslChannelInfo.maxFragmentSize) { printf("Error(Channel %d): MaxFragmentSize %u is too small for packing buffer size %u\n", pReactorChannel->socketId, reactorChannelInfo.rsslChannelInfo.maxFragmentSize, providerThreadConfig.packingBufferLength); exit(-1); } pProvSession->pChannelInfo->pChannel = pReactorChannel->pRsslChannel; pProvSession->pChannelInfo->pReactorChannel = pReactorChannel; pProvSession->pChannelInfo->pReactor = pReactor; rsslQueueAddLinkToBack(&pProviderThread->channelHandler.activeChannelList, &pProvSession->pChannelInfo->queueLink); pProvSession->timeActivated = getTimeNano(); return RSSL_RC_CRET_SUCCESS; } case RSSL_RC_CET_CHANNEL_READY: { if (ret = (printEstimatedMsgSizes(pProviderThread, pProvSession)) != RSSL_RET_SUCCESS) { printf("printEstimatedMsgSizes() failed: %d\n", ret); return RSSL_RC_CRET_SUCCESS; } return RSSL_RC_CRET_SUCCESS; } case RSSL_RC_CET_FD_CHANGE: { /* The file descriptor representing the RsslReactorChannel has been changed. * Update our file descriptor sets. */ printf("Fd change: %d to %d\n", pReactorChannel->oldSocketId, pReactorChannel->socketId); FD_CLR(pReactorChannel->oldSocketId, &pProviderThread->readfds); FD_CLR(pReactorChannel->oldSocketId, &pProviderThread->exceptfds); FD_SET(pReactorChannel->socketId, &pProviderThread->readfds); FD_SET(pReactorChannel->socketId, &pProviderThread->exceptfds); return RSSL_RC_CRET_SUCCESS; } case RSSL_RC_CET_WARNING: { /* We have received a warning event for this channel. Print the information and continue. */ printf("Received warning for Channel fd=%d.\n", pReactorChannel->socketId); printf(" Error text: %s\n", pChannelEvent->pError->rsslError.text); return RSSL_RC_CRET_SUCCESS; } case RSSL_RC_CET_CHANNEL_DOWN: { pProviderThread->stats.inactiveTime = getTimeNano(); printf("Channel Closed.\n"); FD_CLR(pReactorChannel->socketId, &pProviderThread->readfds); FD_CLR(pReactorChannel->socketId, &pProviderThread->exceptfds); --pProviderThread->clientSessionsCount; if (pProvSession->pChannelInfo->pReactorChannel && rsslQueueGetElementCount(&pProviderThread->channelHandler.activeChannelList) > 0) { rsslQueueRemoveLink(&pProviderThread->channelHandler.activeChannelList, &pProvSession->pChannelInfo->queueLink); } if (pProvSession) { free(pProvSession->pChannelInfo); providerSessionDestroy(pProviderThread, pProvSession); } if (rsslReactorCloseChannel(pReactor, pReactorChannel, &rsslErrorInfo) != RSSL_RET_SUCCESS) { printf("rsslReactorCloseChannel() failed: %s\n", rsslErrorInfo.rsslError.text); cleanUpAndExit(); } return RSSL_RC_CRET_SUCCESS; } default: printf("Unknown channel event!\n"); cleanUpAndExit(); } return RSSL_RC_CRET_SUCCESS; }
RsslRet processActiveChannel(ChannelHandler *pChanHandler, ChannelInfo *pChannelInfo) { ProviderThread *pProvThread = (ProviderThread*)pChanHandler->pUserSpec; ProviderSession *pProvSession = (ProviderSession*)pChannelInfo->pUserSpec; RsslError error; RsslRet ret; RsslChannelInfo channelInfo; RsslUInt32 count; #ifdef ENABLE_XML_TRACE RsslTraceOptions traceOptions; rsslClearTraceOptions(&traceOptions); traceOptions.traceMsgFileName = "upacProvPerf"; traceOptions.traceMsgMaxFileSize = 1000000000; traceOptions.traceFlags |= RSSL_TRACE_TO_FILE_ENABLE | RSSL_TRACE_WRITE | RSSL_TRACE_READ; rsslIoctl(pChannelInfo->pChannel, (RsslIoctlCodes)RSSL_TRACE, (void *)&traceOptions, &error); #endif if (provPerfConfig.highWaterMark > 0) { if (rsslIoctl(pChannelInfo->pChannel, RSSL_HIGH_WATER_MARK, &provPerfConfig.highWaterMark, &error) != RSSL_RET_SUCCESS) { printf("rsslIoctl() of RSSL_HIGH_WATER_MARK failed <%s>\n", error.text); exit(-1); } } if ((ret = rsslGetChannelInfo(pChannelInfo->pChannel, &channelInfo, &error)) != RSSL_RET_SUCCESS) { printf("rsslGetChannelInfo() failed: %d\n", ret); return 0; } printf( "Channel %d active. Channel Info:\n" " maxFragmentSize: %u\n" " maxOutputBuffers: %u\n" " guaranteedOutputBuffers: %u\n" " numInputBuffers: %u\n" " pingTimeout: %u\n" " clientToServerPings: %s\n" " serverToClientPings: %s\n" " sysSendBufSize: %u\n" " sysSendBufSize: %u\n" " compressionType: %s\n" " compressionThreshold: %u\n" " ComponentInfo: ", pChannelInfo->pChannel->socketId, channelInfo.maxFragmentSize, channelInfo.maxOutputBuffers, channelInfo.guaranteedOutputBuffers, channelInfo.numInputBuffers, channelInfo.pingTimeout, channelInfo.clientToServerPings == RSSL_TRUE ? "true" : "false", channelInfo.serverToClientPings == RSSL_TRUE ? "true" : "false", channelInfo.sysSendBufSize, channelInfo.sysRecvBufSize, channelInfo.compressionType == RSSL_COMP_ZLIB ? "zlib" : "none", channelInfo.compressionThreshold ); if (channelInfo.componentInfoCount == 0) printf("(No component info)"); else for(count = 0; count < channelInfo.componentInfoCount; ++count) { printf("%.*s", channelInfo.componentInfo[count]->componentVersion.length, channelInfo.componentInfo[count]->componentVersion.data); if (count < channelInfo.componentInfoCount - 1) printf(", "); } printf ("\n\n"); /* Check that we can successfully pack, if packing messages. */ if (providerThreadConfig.totalBuffersPerPack > 1 && providerThreadConfig.packingBufferLength > channelInfo.maxFragmentSize) { printf("Error(Channel %d): MaxFragmentSize %u is too small for packing buffer size %u\n", pChannelInfo->pChannel->socketId, channelInfo.maxFragmentSize, providerThreadConfig.packingBufferLength); exit(-1); } if (ret = (printEstimatedMsgSizes(pProvThread, pProvSession)) != RSSL_RET_SUCCESS) return RSSL_RET_FAILURE; pProvSession->timeActivated = getTimeNano(); return RSSL_RET_SUCCESS; }
RsslRet processActiveChannel(ChannelHandler *pChanHandler, ChannelInfo *pChannelInfo) { ProviderThread *pProviderThread = (ProviderThread*)pChanHandler->pUserSpec; ProviderSession *pProvSession = (ProviderSession*)pChannelInfo->pUserSpec; RsslRet ret; RsslError error; RsslChannelInfo channelInfo; RsslUInt32 count; if (niProvPerfConfig.highWaterMark > 0) { if (rsslIoctl(pChannelInfo->pChannel, RSSL_HIGH_WATER_MARK, &niProvPerfConfig.highWaterMark, &error) != RSSL_RET_SUCCESS) { printf("rsslIoctl() of RSSL_HIGH_WATER_MARK failed <%s>\n", error.text); exit(-1); } } if ((ret = rsslGetChannelInfo(pChannelInfo->pChannel, &channelInfo, &error)) != RSSL_RET_SUCCESS) { printf("rsslGetChannelInfo() failed: %d\n", ret); return 0; } printf( "Channel %d active. Channel Info:\n" " maxFragmentSize: %u\n" " maxOutputBuffers: %u\n" " guaranteedOutputBuffers: %u\n" " numInputBuffers: %u\n" " pingTimeout: %u\n" " clientToServerPings: %s\n" " serverToClientPings: %s\n" " sysSendBufSize: %u\n" " sysSendBufSize: %u\n" " compressionType: %s\n" " compressionThreshold: %u\n" " ComponentInfo: ", pChannelInfo->pChannel->socketId, channelInfo.maxFragmentSize, channelInfo.maxOutputBuffers, channelInfo.guaranteedOutputBuffers, channelInfo.numInputBuffers, channelInfo.pingTimeout, channelInfo.clientToServerPings == RSSL_TRUE ? "true" : "false", channelInfo.serverToClientPings == RSSL_TRUE ? "true" : "false", channelInfo.sysSendBufSize, channelInfo.sysRecvBufSize, channelInfo.compressionType == RSSL_COMP_ZLIB ? "zlib" : "none", channelInfo.compressionThreshold ); if (channelInfo.componentInfoCount == 0) printf("(No component info)"); else for(count = 0; count < channelInfo.componentInfoCount; ++count) { printf("%.*s", channelInfo.componentInfo[count]->componentVersion.length, channelInfo.componentInfo[count]->componentVersion.data); if (count < channelInfo.componentInfoCount - 1) printf(", "); } printf ("\n\n"); /* Check that we can successfully pack, if packing messages. */ if (providerThreadConfig.totalBuffersPerPack > 1 && providerThreadConfig.packingBufferLength > channelInfo.maxFragmentSize) { printf("Error(Channel %d): MaxFragmentSize %u is too small for packing buffer size %u\n", pChannelInfo->pChannel->socketId, channelInfo.maxFragmentSize, providerThreadConfig.packingBufferLength); exit(-1); } if (ret = (printEstimatedMsgSizes(pProviderThread, pProvSession)) != RSSL_RET_SUCCESS) return RSSL_RET_FAILURE; pProvSession->timeActivated = getTimeNano(); /* Send Login Request */ ret = sendLoginRequest(pChanHandler, pChannelInfo, 1, &error); if (ret < RSSL_RET_SUCCESS) { printf("sendLoginRequest() failed: %d\n", ret); exit(-1); } else if (ret > RSSL_RET_SUCCESS) { /* Need to flush */ providerThreadRequestChannelFlush(pProviderThread, pChannelInfo); } return RSSL_RET_SUCCESS; }