void rsslReactorChannel(ReactorChannel rsslReactorChannel) { _rsslReactorChannel = rsslReactorChannel; _majorVersion = rsslReactorChannel.majorVersion(); _minorVersion = rsslReactorChannel.minorVersion(); }
void channel(ReactorChannel rsslReactorChannel) { _rsslReactorChannel = rsslReactorChannel; _majorVersion = rsslReactorChannel.majorVersion(); _minorVersion = rsslReactorChannel.minorVersion(); }
private int minorVersion() { if (!_consPerfConfig.useReactor() && !_consPerfConfig.useWatchlist()) // use UPA Channel for sending and receiving { return _channel.minorVersion(); } else // use UPA VA Reactor for sending and receiving { return _reactorChannel.minorVersion(); } }
int processUpdateMsg(Msg rsslMsg, ReactorChannel reactorChannel, DataDictionary dataDictionary) { _updateMsg.decode(rsslMsg, reactorChannel.majorVersion(), reactorChannel.minorVersion(), dataDictionary); if (_eventImpl._item.type() == Item.ItemType.BATCH_ITEM) { _eventImpl._item = ((BatchItem<T>) _eventImpl._item).singleItem(rsslMsg.streamId()); if (_eventImpl._item == null) { if (_baseImpl.loggerClient().isErrorEnabled()) { StringBuilder temp = _baseImpl.strBuilder(); temp.append("Received an item event with invalid message stream").append(OmmLoggerClient.CR) .append("Instance Name ").append(_baseImpl.instanceName()).append(OmmLoggerClient.CR) .append("RsslReactor ").append(Integer.toHexString(reactorChannel.hashCode())) .append(OmmLoggerClient.CR); _baseImpl.loggerClient().error(_baseImpl.formatLogMessage(ItemCallbackClient.CLIENT_NAME, temp.toString(), Severity.ERROR)); } return ReactorCallbackReturnCodes.FAILURE; } } _updateMsg.service(_eventImpl._item.directory().serviceName()); notifyOnAllMsg(_updateMsg); notifyOnUpdateMsg(); return ReactorCallbackReturnCodes.SUCCESS; }
int processGenericMsg(Msg rsslMsg, ReactorChannel rsslReactorChannel, RDMLoginMsgEvent event) { if (_loginItemList == null) return ReactorCallbackReturnCodes.SUCCESS; if (_genericMsg == null) _genericMsg = new GenericMsgImpl(); _genericMsg.decode(rsslMsg, rsslReactorChannel.majorVersion(), rsslReactorChannel.minorVersion(), ((ChannelInfo)event.reactorChannel().userSpecObj()).rsslDictionary()); _loginItemLock.lock(); int itemSize = _loginItemList.size(); for (int idx = 0; idx < itemSize; ++idx) { _eventImpl._item = _loginItemList.get(idx); notifyOnAllMsg(_genericMsg); notifyOnGenericMsg(); } _loginItemLock.unlock(); return ReactorCallbackReturnCodes.SUCCESS; }
int decodeYieldCurveDataBody(ReactorChannel channel, Msg msg) { if (!isDictionaryLoaded()) { System.out.println(" (Dictionary not loaded).\n"); return CodecReturnCodes.FAILURE; } if (msg.containerType() != DataTypes.FIELD_LIST) { System.out.println(" Incorrect container type: " + msg.containerType()); return CodecReturnCodes.FAILURE; } displayStr.setLength(0); dIter.clear(); dIter.setBufferAndRWFVersion(msg.encodedDataBody(), channel.majorVersion(), channel.minorVersion()); int ret = decodeFieldListForYieldCurve(dIter, dictionary, fieldList, fieldEntry); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeFieldList() failed with return code: " + ret); return ret; } return CodecReturnCodes.SUCCESS; }
/** * Encode. * * @param reactorChannel the reactor channel * @return the buffer */ Buffer encode(ReactorChannel reactorChannel) { _eIter.clear(); _tempBuffer.data().clear(); _eIter.setBufferAndRWFVersion(_tempBuffer, reactorChannel.majorVersion(), reactorChannel.minorVersion()); if (encode(_eIter) == CodecReturnCodes.SUCCESS) { return _tempBuffer; } else { return null; } }
@Override public int defaultMsgCallback(ReactorMsgEvent event) { Msg msg = event.msg(); _dIter.clear(); _dIter.setBufferAndRWFVersion(msg.encodedDataBody(), _reactorChannel.majorVersion(), _reactorChannel.minorVersion()); processMarketPriceResp(msg, _dIter); return ReactorCallbackReturnCodes.SUCCESS; }
@Override public void handleTimeoutEvent() { LoginCallbackClient<T> loginCallbackClient = _baseImpl.loginCallbackClient(); if (_loginChannelList.isEmpty()) return; ReactorChannel rsslReactorChannel = _loginChannelList.get(0).rsslReactorChannel(); RefreshMsgImpl refreshMsg = loginCallbackClient.refreshMsg(); refreshMsg.decode(loginCallbackClient.rsslRefreshMsg(), rsslReactorChannel.majorVersion(), rsslReactorChannel.minorVersion(), null); loginCallbackClient._eventImpl._item = this; loginCallbackClient._eventImpl._channel = rsslReactorChannel; loginCallbackClient.notifyOnAllMsg(refreshMsg); loginCallbackClient.notifyOnRefreshMsg(); if (refreshMsg.state().streamState() != OmmState.StreamState.OPEN) { loginCallbackClient.loginItemList().remove(this); remove(); } }
private int closeStream(ReactorChannel chnl, int streamId, ReactorErrorInfo errorInfo) { /* get a buffer for the item close */ TransportBuffer msgBuf = chnl.getBuffer(TRANSPORT_BUFFER_SIZE_CLOSE, false, errorInfo); if (msgBuf == null) return CodecReturnCodes.FAILURE; /* encode item close */ closeMessage.clear(); closeMessage.streamId(streamId); closeMessage.domainType(domainType); encIter.clear(); encIter.setBufferAndRWFVersion(msgBuf, chnl.majorVersion(), chnl.minorVersion()); int ret = closeMessage.encode(encIter); if (ret < CodecReturnCodes.SUCCESS) { System.out.println("encodeYieldCurveClose(): Failed <" + CodecReturnCodes.toString(ret) + ">"); } return chnl.submit(msgBuf, submitOptions, errorInfo); }
protected int closeStream(ReactorChannel chnl, int streamId, ReactorErrorInfo errorInfo) { /* get a buffer for the item close */ TransportBuffer msgBuf = chnl.getBuffer(TRANSPORT_BUFFER_SIZE_CLOSE, false, errorInfo); if (msgBuf == null) return ReactorReturnCodes.FAILURE; /* encode item close */ closeMessage.clear(); closeMessage.streamId(streamId); closeMessage.domainType(domainType); encIter.clear(); encIter.setBufferAndRWFVersion(msgBuf, chnl.majorVersion(), chnl.minorVersion()); int ret = closeMessage.encode(encIter); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("encodeMarketPriceClose(): Failed <" + CodecReturnCodes.toString(ret) + ">"); } return chnl.submit(msgBuf, submitOptions, errorInfo); }
@Override public int rdmDictionaryMsgCallback(RDMDictionaryMsgEvent event) { Msg msg = event.msg(); _dIter.clear(); _dIter.setBufferAndRWFVersion(event.msg().encodedDataBody(), event.reactorChannel().majorVersion(), event.reactorChannel().minorVersion()); processDictionaryResp(msg, _dIter); return ReactorCallbackReturnCodes.SUCCESS; }
private int closeStream(ReactorChannel chnl, int streamId, ReactorErrorInfo errorInfo) { if(chnl.state() == State.UP) { //get a buffer for the item close TransportBuffer msgBuf = chnl.getBuffer(TRANSPORT_BUFFER_SIZE_CLOSE, false, errorInfo); if (msgBuf == null) return ReactorReturnCodes.FAILURE; //encode item close closeMessage.clear(); closeMessage.streamId(streamId); encIter.clear(); encIter.setBufferAndRWFVersion(msgBuf, chnl.majorVersion(), chnl.minorVersion()); int ret = closeMessage.encode(encIter); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("encodeMarketByOrderClose(): Failed <" + CodecReturnCodes.toString(ret) + ">"); } return chnl.submit(msgBuf, submitOptions, errorInfo); } return ReactorReturnCodes.SUCCESS; }
private int encodeAndSendRequest(ReactorChannel chnl, YieldCurveRequest yieldCurveRequest, ReactorErrorInfo errorInfo) { // get a buffer for the item request TransportBuffer msgBuf = chnl.getBuffer(TRANSPORT_BUFFER_SIZE_REQUEST, false, errorInfo); if (msgBuf == null) { return CodecReturnCodes.FAILURE; } encIter.clear(); encIter.setBufferAndRWFVersion(msgBuf, chnl.majorVersion(), chnl.minorVersion()); int ret = yieldCurveRequest.encode(encIter); if (ret < CodecReturnCodes.SUCCESS) { errorInfo.error().text("YieldCurveRequest.encode() failed"); errorInfo.error().errorId(ret); return ret; } System.out.println(yieldCurveRequest.toString()); return chnl.submit(msgBuf, submitOptions, errorInfo); }
private int encodeAndSendRequest(ReactorChannel chnl, MarketPriceRequest marketPriceRequest, ReactorErrorInfo errorInfo) { //get a buffer for the item request TransportBuffer msgBuf = chnl.getBuffer(TRANSPORT_BUFFER_SIZE_REQUEST, false, errorInfo); if (msgBuf == null) { return CodecReturnCodes.FAILURE; } encIter.clear(); encIter.setBufferAndRWFVersion(msgBuf, chnl.majorVersion(), chnl.minorVersion()); int ret = marketPriceRequest.encode(encIter); if (ret < CodecReturnCodes.SUCCESS) { errorInfo.error().text("MarketPriceRequest.encode() failed"); errorInfo.error().errorId(ret); return ret; } System.out.println(marketPriceRequest.toString()); return chnl.submit(msgBuf, submitOptions, errorInfo); }
private int closeStream(ReactorChannel chnl, int streamId, ReactorErrorInfo errorInfo) { if(chnl.state() == State.UP) { //get a buffer for the item close TransportBuffer msgBuf = chnl.getBuffer(TRANSPORT_BUFFER_SIZE_CLOSE, false, errorInfo); if (msgBuf == null) return ReactorReturnCodes.FAILURE; //encode item close closeMessage.clear(); closeMessage.streamId(streamId); closeMessage.domainType(domainType); encIter.clear(); encIter.setBufferAndRWFVersion(msgBuf, chnl.majorVersion(), chnl.minorVersion()); int ret = closeMessage.encode(encIter); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("encodeMarketPriceClose(): Failed <" + CodecReturnCodes.toString(ret) + ">"); } return chnl.submit(msgBuf, submitOptions, errorInfo); } return ReactorReturnCodes.SUCCESS; }
int closeStream(ReactorChannel chnl, ReactorErrorInfo errorInfo) { /* * we only want to close a stream if it was not already closed (e.g. * rejected by provider, closed via refresh or status, or redirected) */ if (state.streamState() != StreamStates.OPEN && state.dataState() != DataStates.OK) return CodecReturnCodes.SUCCESS; //get a buffer for the item close TransportBuffer msgBuf = chnl.getBuffer(TRANSPORT_BUFFER_SIZE_CLOSE, false, errorInfo); if (msgBuf == null) { return CodecReturnCodes.FAILURE; } //encode item close closeMessage.clear(); closeMessage.streamId(SYMBOL_LIST_STREAM_ID_START); closeMessage.domainType(DomainTypes.SYMBOL_LIST); encIter.clear(); encIter.setBufferAndRWFVersion(msgBuf, chnl.majorVersion(), chnl.minorVersion()); int ret = closeMessage.encode(encIter); if (ret != CodecReturnCodes.SUCCESS) { errorInfo.error().text("encodeSymbolListClose(): Failed <" + CodecReturnCodes.toString(ret) + ">"); return ret; } return chnl.submit(msgBuf, submitOptions, errorInfo); }
@Override public int defaultMsgCallback(ReactorMsgEvent event) { ReactorChannel reactorChannel = event.reactorChannel(); ProviderSession provSession = (ProviderSession)reactorChannel.userSpecObj(); ProviderThread providerThread = provSession.providerThread(); Msg msg = event.msg(); _decodeIter.clear(); if (msg.encodedDataBody() != null && msg.encodedDataBody().data() != null) { _decodeIter.setBufferAndRWFVersion(msg.encodedDataBody(), reactorChannel.majorVersion(), reactorChannel.minorVersion()); } switch (msg.domainType()) { case DomainTypes.MARKET_PRICE: if (_xmlMsgData.marketPriceUpdateMsgCount() > 0) _itemRequestHandler.processMsg(providerThread, provSession, msg, _directoryProvider.openLimit(), _directoryProvider.serviceId(), _directoryProvider.qos(), _decodeIter, event.errorInfo().error()); else _itemRequestHandler.sendRequestReject(providerThread, provSession, msg, ItemRejectReason.DOMAIN_NOT_SUPPORTED, event.errorInfo().error()); break; default: _itemRequestHandler.sendRequestReject(providerThread, provSession, msg, ItemRejectReason.DOMAIN_NOT_SUPPORTED, event.errorInfo().error()); break; } return ReactorCallbackReturnCodes.SUCCESS; }
private int encodeBatchCloseStatus(ReactorChannel chnl, int domainType, TransportBuffer msgBuf, int streamId, int dataState, ReactorErrorInfo errorInfo) { _statusMsg.clear(); /* set-up message */ _statusMsg.msgClass(MsgClasses.STATUS); _statusMsg.streamId(streamId); _statusMsg.domainType(domainType); _statusMsg.containerType(DataTypes.NO_DATA); _statusMsg.flags(StatusMsgFlags.HAS_STATE); _statusMsg.state().streamState(StreamStates.CLOSED); _statusMsg.state().dataState(dataState); _statusMsg.state().code(StateCodes.NONE); _statusMsg.state().text().data("Stream closed for batch"); /* clear encode iterator */ _encodeIter.clear(); /* encode message */ int ret = _encodeIter.setBufferAndRWFVersion(msgBuf, chnl.majorVersion(), chnl.minorVersion()); if (ret != CodecReturnCodes.SUCCESS) { errorInfo.error().text("EncodeIterator.setBufferAndRWFVersion() failed with return code: " + CodecReturnCodes.toString(ret)); return ret; } ret = _statusMsg.encode(_encodeIter); if (ret != CodecReturnCodes.SUCCESS) { errorInfo.error().text("StatusMsg.encode() failed"); return ret; } return CodecReturnCodes.SUCCESS; }
int ret = _encodeIter.setBufferAndRWFVersion(msgBuf, channel.majorVersion(), channel.minorVersion()); if (ret != CodecReturnCodes.SUCCESS)