OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  8.1.0
API documentation
RdiHandlerImpl.cpp
Go to the documentation of this file.
1 /*
2 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
3 *
4 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
5 * and international copyright treaties.
6 *
7 * Access to and use of the software is governed by the terms of the applicable ONIXS Software
8 * Services Agreement (the Agreement) and Customer end user license agreements granting
9 * a non-assignable, non-transferable and non-exclusive license to use the software
10 * for it's own data processing purposes under the terms defined in the Agreement.
11 *
12 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
13 * of this source code or associated reference material to any other location for further reproduction
14 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
15 *
16 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
17 * the terms of the Agreement is a violation of copyright law.
18 */
19 
20 #include <boost/format.hpp>
21 
23 
24 #include "RdiHandlerImpl.h"
25 #include "Formatting.h"
26 #include <boost/foreach.hpp>
27 #include "FeedEngineImpl.h"
28 #include "Version.h"
29 
30 #include <system/File.h>
31 
32 #include <util/String.h>
34 
35 namespace OnixS {
36 namespace Eurex {
37 namespace MarketData {
38 namespace Implementation {
39 
40 using namespace HandlerCore::MarketData;
41 using namespace HandlerCore::Common;
42 using namespace Networking;
43 
44 
46  : base ("RDI", nullptr, settings.maxPacketSize, settings.licenseDirectory)
47  , logger_(nullptr)
48  , listenerHolder_(nullptr)
49  , settings_(settings)
50  , incrementalPacketProcessor_(nullptr)
51  , snapshotPacketProcessor_(nullptr)
52  , logFacilityForSnapshots_("Snapshot", this, Logging::LOG_LEVEL_DEBUG)
53  , logFacilityForIncrementals_("Incremental", this, Logging::LOG_LEVEL_DEBUG)
54  , incrementalFixDecoder_(nullptr)
55  , snapshotFixDecoder_(nullptr)
56  , dataRepository_(nullptr)
57  , incrementalMessagesPool_(settings.messagePoolSize)
58 {
59  initLogger(settings);
60 
61  forceLog (ONIXS_LOG_INFO[this] << "OnixS Eurex T7 Rdi Handler, version " << OnixS::Eurex::MarketData::Implementation::version() << ", " << os());
62  forceLog (ONIXS_LOG_INFO[this] << settings.toString());
63 
64  initListenerHolder();
65 
66  try
67  {
68  checkXmlFile();
69 
70  const std::string xml(removeInvalidTemplateNodes(System::File::readTextFile(settings.fastTemplatesFile), "RDPacketHeader"));
71  incrementalFixDecoder_.reset(new FixDecoder(xml, false, InputDataTraits::CompleteMessagesOnly));
72 
73  snapshotFixDecoder_.reset(new FixDecoder(xml, false, InputDataTraits::CompleteMessagesOnly));
74 
75  RdiDataRepositoryConfig repositoryConfig;
76  repositoryConfig.name = "DataRepository";
77  repositoryConfig.parent = this;
78  repositoryConfig.logger = logger_.get();
79  repositoryConfig.listenerHolder = listenerHolder_.get();
80  repositoryConfig.settings = settings;
81 
82  if(settings_.useFullSnapshotCycle)
83  {
84  dataRepository_.reset(new RdiDataRepository(repositoryConfig));
85  }
86  else
87  {
88  dataRepository_.reset(new RdiDataRepositoryEx(repositoryConfig));
89  }
90 
91  dataRepository_->subscribeOnSnapshotStartRequest(boost::bind(&RdiHandlerImpl::onSnapshotStartRequest, this));
92  dataRepository_->subscribeOnSnapshotStopRequest(boost::bind(&RdiHandlerImpl::onSnapshotStopRequest, this));
93 
94  incrementalPacketProcessor_.reset(
96  settings.lostPacketWaitTime,
97  settings.heartbeatInterval,
99  lock())
100  );
101  incrementalPacketProcessor_->subscribeOnPacketData(boost::bind(&RdiHandlerImpl::onIncrementalPacketData, this, _1, _2, _3, _4));
102  incrementalPacketProcessor_->subscribeOnGap(boost::bind(&RdiHandlerImpl::onIncrementalPacketGap, this));
103  incrementalPacketProcessor_->subscribeOnSenderCompIdChange(boost::bind(&RdiHandlerImpl::onIncrementalSenderCompIdChange, this, _1, _2, _3, _4));
104  incrementalPacketProcessor_->subscribeOnInactivity(boost::bind(&RdiHandlerImpl::onIncrementalInactivity, this));
105  incrementalPacketProcessor_->subscribeOnFeedInactivity(boost::bind(&RdiHandlerImpl::onIncrementalFeedInactivity, this, _1));
106 
107  snapshotPacketProcessor_.reset(
108  new RdiPacketProcessor(
109  settings.lostPacketWaitTime,
110  settings.heartbeatInterval,
112  lock())
113  );
114  snapshotPacketProcessor_->subscribeOnPacketData(boost::bind(&RdiHandlerImpl::onSnapshotPacketData, this, _1, _2, _3, _4));
115  snapshotPacketProcessor_->subscribeOnGap(boost::bind(&RdiHandlerImpl::onSnapshotPacketGap, this));
116  snapshotPacketProcessor_->subscribeOnSenderCompIdChange(boost::bind(&RdiHandlerImpl::onSnapshotSenderCompIdChange, this, _1, _2, _3, _4));
117  snapshotPacketProcessor_->subscribeOnInactivity(boost::bind(&RdiHandlerImpl::onSnapshotInactivity, this));
118  snapshotPacketProcessor_->subscribeOnFeedInactivity(boost::bind(&RdiHandlerImpl::onSnapshotFeedInactivity, this, _1));
119  }
120  catch (const std::exception& ex)
121  {
122  reportError(TextBuilder() << "Exception in RdiHandlerImpl constructor: " << ex.what());
123  throw;
124  }
125  catch (...)
126  {
127  reportError("Unknown exception in RdiHandlerImpl constructor");
128  throw;
129  }
130 }
131 
133 {
134  incrementalMessagesPool_.reset();
135  stop();
136 }
137 
138 void RdiHandlerImpl::checkXmlFile()
139 {
140  std::string detectedXmlVersion;
141  if (!checkXmlVersion(settings_.fastTemplatesFile, detectedXmlVersion, RdiXmlMajorVersion, RdiXmlMinorVersion))
142  {
143  reportWarning("Can not extract template file version.");
144  }
145  else
146  forceLog(ONIXS_LOG_INFO[this] << "Detected template file version: " << detectedXmlVersion);
147 }
148 
150 {
151  setFeedEngine(FeedEngineImpl::getFeedEngine(feedEngine));
152 
153  forceLog(ONIXS_LOG_INFO[this] << "Bound FeedEngine");
154  forceLog(ONIXS_LOG_INFO[this] << feedEngine.settings().toString());
155  forceLog(ONIXS_LOG_INFO[this] << feedEngine.info());
156 }
157 
159 {
160  base::start();
161 }
162 
164 {
165  incrementalPacketProcessor_->activateReplayMode();
166  snapshotPacketProcessor_->activateReplayMode();
167 
168  LogPlayerLinks links;
169  links.push_back(LogPlayerLink("Incremental", incrementalPacketProcessor_.get()));
170  links.push_back(LogPlayerLink("Snapshot", snapshotPacketProcessor_.get()));
171 
172  BaseHandlerImp::start(options, links, "RDI");
173 }
174 
176 {
177  base::stop();
178 }
179 
180 void RdiHandlerImpl::onStarting()
181 {
182  incrementalPacketProcessor_->reset();
183  snapshotPacketProcessor_->reset();
184 
185  FE::ConnectionInfo connectionA;
186  FE::ConnectionInfo connectionB;
187 
188  connectionA.role(FE::NetFeedRole::A);
189  connectionB.role(FE::NetFeedRole::B);
190 
191  FE::MulticastFeedLayout::Enum layout = FE::MulticastFeedLayout::Both;
192  if (!settings_.useFeedA)
193  layout = FE::MulticastFeedLayout::BOnly;
194  else if (!settings_.useFeedB)
195  layout = FE::MulticastFeedLayout::AOnly;
196 
197  FE::NifsByFeedRole nifs;
198  nifs.A(settings_.networkInterfaceA.empty() ? settings_.networkInterface : settings_.networkInterfaceA);
199  nifs.B(settings_.networkInterfaceB.empty() ? settings_.networkInterface : settings_.networkInterfaceB);
200 
201  ///
202  connectionA.type(FE::NetFeedType::Incremental);
203  connectionB.type(FE::NetFeedType::Incremental);
204 
205  connectionA.id("IncrementalA");
206  connectionB.id("IncrementalB");
207 
208  connectionA.ip(settings_.interfaceDescriptor.incrementalFeed.serviceA.address);
209  connectionB.ip(settings_.interfaceDescriptor.incrementalFeed.serviceB.address);
210 
211  connectionA.port(settings_.interfaceDescriptor.incrementalFeed.serviceA.port);
212  connectionB.port(settings_.interfaceDescriptor.incrementalFeed.serviceB.port);
213 
214  FE::ConnectionInfoList incrementalConnections;
215  incrementalConnections.push_back(connectionA);
216  incrementalConnections.push_back(connectionB);
217 
218  incrementalFeeds_.reset(
219  constructCluster(
220  FE::NetFeedType::Incremental,
221  layout,
222  incrementalConnections,
223  nifs,
224  FE::TimeSpan(0, 0, 0, settings_.lostPacketWaitTime * FE::TimeTraits::nanosecondsPerMillisecond()),
225  *incrementalPacketProcessor_
226  )
227  );
228 
229  ///
230  connectionA.type(FE::NetFeedType::Snapshot);
231  connectionB.type(FE::NetFeedType::Snapshot);
232 
233  connectionA.id("SnapshotA");
234  connectionB.id("SnapshotB");
235 
236  connectionA.ip(settings_.interfaceDescriptor.snapshotFeed.serviceA.address);
237  connectionB.ip(settings_.interfaceDescriptor.snapshotFeed.serviceB.address);
238 
239  connectionA.port(settings_.interfaceDescriptor.snapshotFeed.serviceA.port);
240  connectionB.port(settings_.interfaceDescriptor.snapshotFeed.serviceB.port);
241 
242  FE::ConnectionInfoList snapshotConnections;
243  snapshotConnections.push_back(connectionA);
244  snapshotConnections.push_back(connectionB);
245 
246  snapshotFeeds_.reset(
247  constructCluster(
248  FE::NetFeedType::Snapshot,
249  layout,
250  snapshotConnections,
251  nifs,
252  FE::TimeSpan(0, 0, 0, settings_.lostPacketWaitTime * FE::TimeTraits::nanosecondsPerMillisecond()),
253  *snapshotPacketProcessor_
254  )
255  );
256 
257  incrementalFeeds_->connect(FE::CanThrowNow());
258  snapshotFeeds_->connect(FE::CanThrowNow());
259 }
260 
261 void RdiHandlerImpl::onStopping()
262 {
263  if(incrementalFeeds_)
264  incrementalFeeds_->disconnect();
265 
266  if(snapshotFeeds_)
267  snapshotFeeds_->disconnect();
268 }
269 
270 void RdiHandlerImpl::onSnapshotStartRequest()
271 {
272  if (!isBacktrestingMode())
273  {
274  log( ONIXS_LOG_DEBUG[this] << "Reseting snapshot packet processor");
275  snapshotPacketProcessor_->reset();
276 
277  snapshotFeeds_->connectSwallowException();
278  }
279  else
280  log( ONIXS_LOG_DEBUG[this] << "Starting snapshot feed");
281 }
282 
283 void RdiHandlerImpl::onSnapshotStopRequest()
284 {
285  if (!isBacktrestingMode())
286  snapshotFeeds_->disconnect();
287 
288  log( ONIXS_LOG_DEBUG[this] << "Reseting snapshot packet processor");
289  snapshotPacketProcessor_->reset();
290 }
291 
292 void RdiHandlerImpl::onIncrementalPacketData(DataSource& dataSource, const char* data, size_t length, size_t headerSize)
293 {
294  if(settings_.logSettings & LogSettings::LogPackets)
295  log( ONIXS_LOG_INFO[&logFacilityForIncrementals_] << dataSource.packetSeqNum << " Packet received (" << Base64Wrapper(data, length) << ").");
296  else
297  log(ONIXS_LOG_DEBUG[&logFacilityForIncrementals_] << "Packet " << dataSource.packetSeqNum);
298 
299  try
300  {
301  PacketHeaderForRDI* packetHeader = (PacketHeaderForRDI*)(data);
302  const UInt32 packetHeaderTemplateId = PacketHeaderHelper::getTemplateId(packetHeader);
303 
304  if(packetHeaderTemplateId != PacketHeaderForRDI::TemplateIdValue)
305  {
306  throw OperationException (
307  BOOST_CURRENT_FUNCTION,
308  format("Wrong packet header id: expected %d, but received %d", PacketHeaderForRDI::TemplateIdValue, packetHeaderTemplateId).c_str()
309  );
310  }
311 
312  size_t offset = headerSize;
313  bool result = false;
314  size_t chunkLength;
315  unsigned int templateId;
316 
317  while(offset < length)
318  {
319  CORE::Message* msg = incrementalMessagesPool_.create();
320 
321  try
322  {
323  result = incrementalFixDecoder_->decode(reinterpret_cast<const uint8*>(data), offset, length - offset, msg, &chunkLength, &templateId);
324  }
325  catch (const std::exception& ex)
326  {
327  reportWarning(
328  TextBuilder()
329  << "Exception while message decoding: "
330  << ex.what()
331  << ", Packet ("
332  << Base64Wrapper(data, length) << ")."
333  );
334 
335  break;
336  }
337  catch (...)
338  {
339  reportWarning(
340  TextBuilder()
341  << "Unknown exception while message decoding"
342  << ", Packet ("
343  << Base64Wrapper(data, length) << ")."
344  );
345 
346  break;
347  }
348 
349 
350  if(chunkLength == 0)
351  break;
352 
353  if(!result)
354  break;
355 
356  offset += chunkLength;
357 
358  ++dataSource.packetMessageSeqNum;
359  dataSource.isLastInPacket = offset >= length;
360 
361  if (templateId == ResetTemplateId)
362  continue;
363 
364  dataRepository_->onIncrementalMessage(dataSource, *msg, templateId);
365  }
366  }
367  catch (const std::exception& ex)
368  {
369  reportWarning(
370  TextBuilder()
371  << "Exception while message processing: "
372  << ex.what()
373  );
374  }
375  catch (...)
376  {
377  reportWarning(
378  TextBuilder()
379  << "Unknown exception while message processing"
380  );
381  }
382 
383  if(incrementalMessagesPool_.recommendReset())
384  {
385  if(!dataRepository_->hasCashedIncrementals())
386  {
387  incrementalMessagesPool_.reset();
388  log( ONIXS_LOG_DEBUG[&logFacilityForIncrementals_] << "Resetting incremental Messages Pool");
389  }
390  else
391  log( ONIXS_LOG_DEBUG[&logFacilityForIncrementals_] << "Unable to Reset incremental Messages Pool : cashed messages exist");
392  }
393 }
394 
395 void RdiHandlerImpl::onIncrementalPacketGap()
396 {
397  dataRepository_->onIncrementalPacketGap();
398 }
399 
400 void RdiHandlerImpl::onIncrementalSenderCompIdChange(unsigned int lastSenderCompId, unsigned int newSenderCompId, SequenceNumber lastSeqNum, SequenceNumber newSeqNum)
401 {
402  log( ONIXS_LOG_DEBUG[&logFacilityForIncrementals_] << "SenderCompIdChange: " << lastSenderCompId << "->" << newSenderCompId << ", packetSeqNum "<< lastSeqNum << "->" << newSeqNum);
403 }
404 
405 void RdiHandlerImpl::onIncrementalInactivity()
406 {
407  reportWarning(
408  TextBuilder()
409  << "No " << LogFacility::name() << " incremental data"
410  );
411 }
412 
413 void RdiHandlerImpl::onIncrementalFeedInactivity(FE::NetFeedRole::Enum id)
414 {
415  reportWarning(
416  TextBuilder()
417  << "No " << LogFacility::name() << " incremental data on " << FE::toStr(id)
418  );
419 }
420 
421 void RdiHandlerImpl::onSnapshotPacketData(DataSource& dataSource, const char* data, size_t length, size_t headerSize)
422 {
423  if(settings_.logSettings & LogSettings::LogPackets)
424  log( ONIXS_LOG_INFO[&logFacilityForSnapshots_] << dataSource.packetSeqNum << " Packet received (" << Base64Wrapper(data, length) << ").");
425  else
426  log(ONIXS_LOG_DEBUG[&logFacilityForSnapshots_] << "Packet " << dataSource.packetSeqNum);
427 
428  try
429  {
430  PacketHeaderForRDI* packetHeader = (PacketHeaderForRDI*)(data);
431  const UInt32 packetHeaderTemplateId = PacketHeaderHelper::getTemplateId(packetHeader);
432 
433  if(packetHeaderTemplateId != PacketHeaderForRDI::TemplateIdValue)
434  {
435  throw OperationException (
436  BOOST_CURRENT_FUNCTION,
437  format("Wrong packet header id: expected %d, but received %d", PacketHeaderForRDI::TemplateIdValue, packetHeaderTemplateId).c_str()
438  );
439  }
440 
441  size_t offset = headerSize;
442  bool result = false;
443  size_t chunkLength = 0;
444  TemplateId templateId = 0;
445 
446  while(offset < length)
447  {
448  snapShotContentAllocator_.reset();
449  CORE::Message msg(snapShotContentAllocator_);
450 
451  try
452  {
453  result = snapshotFixDecoder_->decode(
454  reinterpret_cast<const uint8*>(data),
455  offset,
456  length - offset,
457  &msg,
458  &chunkLength,
459  &templateId);
460  }
461  catch (const std::exception& ex)
462  {
463  reportWarning(
464  TextBuilder()
465  << "Exception while message decoding: "
466  << ex.what()
467  << ", Packet ("
468  << Base64Wrapper(data, length) << ")."
469  );
470 
471  break;
472  }
473  catch (...)
474  {
475  reportWarning(
476  TextBuilder()
477  << "Unknown exception while message decoding"
478  << ", Packet ("
479  << Base64Wrapper(data, length) << ")."
480  );
481 
482  break;
483  }
484 
485 
486  if (!result)
487  break;
488 
489  if(chunkLength == 0)
490  break;
491 
492  offset += chunkLength;
493 
494  ++dataSource.packetMessageSeqNum;
495  dataSource.isLastInPacket = offset >= length;
496 
497  bool skipRestOfPacket = false;
498 
499  if (templateId == ResetTemplateId)
500  continue;
501 
502  dataRepository_->onSnapshotMessage(dataSource, msg, templateId, &skipRestOfPacket);
503 
504  if(skipRestOfPacket)
505  {
506  log( ONIXS_LOG_DEBUG[&logFacilityForSnapshots_] << "Rest of packet skipped");
507  break;
508  }
509  }
510  }
511  catch (const std::exception& ex)
512  {
513  reportWarning(
514  TextBuilder()
515  << "Exception while message processing: "
516  << ex.what()
517  << ", Packet ("
518  << Base64Wrapper(data, length) << ")."
519  );
520  }
521  catch (...)
522  {
523  reportWarning(
524  TextBuilder()
525  << "Unknown exception while message processing"
526  << ", Packet ("
527  << Base64Wrapper(data, length) << ")."
528  );
529  }
530 }
531 
532 void RdiHandlerImpl::onSnapshotPacketGap()
533 {
534  log( ONIXS_LOG_DEBUG[&logFacilityForSnapshots_] << "Packet gap detected");
535 }
536 
537 void RdiHandlerImpl::onSnapshotSenderCompIdChange(
538  unsigned int lastSenderCompId, unsigned int newSenderCompId, SequenceNumber lastSeqNum, SequenceNumber newSeqNum)
539 {
540  log(
541  ONIXS_LOG_DEBUG[&logFacilityForSnapshots_]
542  << "SenderCompIdChange: "
543  << lastSenderCompId
544  << "->"
545  << newSenderCompId
546  << ", packetSeqNum "
547  << lastSeqNum
548  << "->"
549  << newSeqNum);
550 }
551 
552 void RdiHandlerImpl::onSnapshotInactivity()
553 {
554  reportWarning(
555  TextBuilder()
556  << "No " << LogFacility::name() << " snapshot data"
557  );
558 }
559 
560 void RdiHandlerImpl::onSnapshotFeedInactivity(FE::NetFeedRole::Enum id)
561 {
562  reportWarning(
563  TextBuilder()
564  << "No " << LogFacility::name() << " snapshot data on " << FE::toStr(id)
565  );
566 }
567 
569 {
570  if(productNames.empty())
571  return dataRepository_->findAllEmdiDescriptors();
572 
573  return dataRepository_->findEmdiDescriptors(productNames);
574 }
575 
577 {
578  return dataRepository_->findAllEmdiDescriptors();
579 }
580 
582 {
583  if (productNames.empty())
584  return dataRepository_->findAllMdiDescriptors();
585 
586  return dataRepository_->findMdiDescriptors(productNames);
587 }
588 
590 {
591  return dataRepository_->findAllMdiDescriptors();
592 }
593 
595 {
596  if (productNames.empty())
597  return dataRepository_->findAllEobiDescriptors();
598 
599  return dataRepository_->findEobiDescriptors(productNames);
600 }
601 
603 {
604  return dataRepository_->findAllEobiDescriptors();
605 }
606 
607 void RdiHandlerImpl::initLogger(const HandlerSettings &settings)
608 {
609  logger_.reset(new HandlerLogger(convertLogSettings(settings)));
610 
611  setLogger(&logger_->getLogger());
612 }
613 
614 void RdiHandlerImpl::initListenerHolder()
615 {
616  try
617  {
618  listenerHolder_.reset(new ListenerHolder(this, logger_.get()));
619  }
620  catch (const std::exception& ex)
621  {
622  log(ONIXS_LOG_ERROR[this] << "Exception while constructing ListenerHolder: " << ex.what());
623  throw;
624  }
625  catch (...)
626  {
627  log(ONIXS_LOG_WARN[this] << "Unknown exception while constructing ListenerHolder");
628  throw;
629  }
630 }
631 
632 void RdiHandlerImpl::onStateChanged(HandlerCore::MarketData::MulticastFeedHandler::State::Enum newState)
633 {
634  listenerHolder_->invokeStateChanged(static_cast<HandlerState::Enum>(newState));
635 }
636 
637 void RdiHandlerImpl::invokeError(const std::string& description)
638 {
640 }
641 
642 void RdiHandlerImpl::invokeWarning(const std::string& description)
643 {
644  listenerHolder().invokeWarning(description);
645 }
646 
647 }}}}
648 
unsigned int SequenceNumber
Alias for sequence numbers.
std::string toString() const
Returns the string representation.
Manages processing machinery for market data received from feeds.
Definition: FeedEngine.h:287
EobiDescriptors findEobiDescriptors(const MarketSegments &productNames) const
Returns list of descriptors of EOB interfaces for given product name list.
ListenerHolder & listenerHolder()
Returns commons services as shared object.
void invokeWarning(const std::string &description) override
ServiceDescriptor serviceA
Service A.
std::string info() const
Feed engine info.
Definition: FeedEngine.cpp:64
EobiDescriptor::Collection EobiDescriptors
EmdiDescriptors findAllEmdiDescriptors() const
Returns list of descriptors of EMDI interfaces for all products.
ServiceDescriptor serviceB
Service B.
static UInt32 getTemplateId(TPacketHeader *packetHeader)
Definition: PacketHeader.h:117
Handler base configuration settings.
Util::TextBuilder TextBuilder
Definition: Formatting.h:43
EobiDescriptors findAllEobiDescriptors() const
Returns list of descriptors of EOB interfaces for all products.
void invokeError(ErrorCode::Enum code, const std::string &description) ONIXS_NOEXCEPT
unsigned int UInt32
Definition: Numeric.h:41
void invokeError(const std::string &description) override
Invoke helpers.
Definition: Defines.h:30
Defines params which affect logs replay.
Definition: Replay.h:77
SequenceNumber packetSeqNum
Packet sequence number.
Definition: Defines.h:66
static HandlerCore::MarketData::FE::MulticastFeedEngine * getFeedEngine(FeedEngine &feedEngine)
MdiDescriptors findAllMdiDescriptors() const
Returns list of descriptors of MDI interfaces for all products.
LogSettings::Enum logSettings
Combine LogSettings enum values to configure the logger.
const FeedEngineSettings & settings() const
Settings used define behavior of given instance.
Definition: FeedEngine.cpp:59
Log binary data of received packets, applied only for Info log level and below.
Definition: LogSettings.h:75
RDI handler configuration settings.
EmdiDescriptor::Collection EmdiDescriptors
MdiDescriptor::Collection MdiDescriptors
EmdiDescriptors findEmdiDescriptors(const MarketSegments &productNames) const
Returns list of descriptors of EMDI interfaces for given product name list.
bool checkXmlVersion(const std::string &filename, std::string &detectedVersion, UInt32 expectedXmlMajorVersion, UInt32 expectedEmlMinorVersion)
Definition: Utils.cpp:37
bool isLastInPacket
Indicates whether a message is last in the packet.
Definition: Defines.h:72
MdiDescriptors findMdiDescriptors(const MarketSegments &productNames) const
Returns list of descriptors of MDI interfaces for given product name list.
RdiHandlerImpl(const RdiHandlerSettings &settings)
Initialize new instance.
Identifiers errors of generic nature.
Definition: ErrorListener.h:38
SequenceNumber packetMessageSeqNum
Packet message number.
Definition: Defines.h:69
OnixS::FIX::Core::FAST::TemplateId TemplateId
IInterfaceDescriptorProvider::MarketSegments MarketSegments
void invokeWarning(const std::string &description) ONIXS_NOEXCEPT
std::string toString() const
Returns the string representation.
InterfaceDescriptor interfaceDescriptor
Sets data interface technical configuration.
std::string removeInvalidTemplateNodes(std::string xml, const std::string &node)
Definition: Utils.cpp:120