OnixS C++ CME iLink 3 Binary Order Entry Handler  1.9.0
API Documentation
SessionSettings.h
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 #pragma once
21 
22 #include <OnixS/CME/iLink3/ABI.h>
25 
26 #include <climits>
27 #include <set>
28 #include <string>
29 #include <vector>
30 
31 namespace OnixS {
32 namespace CME {
33 namespace iLink3 {
34 
35 /**
36  * Session settings.
37  */
39 {
40 public:
43 
44  /// \return the session id that was assigned by the exchange.
45  ///
46  /// The default value is empty.
48  const std::string & sessionId() const {
49  return sessionId_;
50  }
51 
52  /// Sets the session id that was assigned by the exchange.
54  SessionSettings& sessionId(const std::string & value);
55 
56  /// \return the firm id that was assigned by the exchange.
57  ///
58  /// The default value is empty.
60  const std::string & firmId() const {
61  return firmId_;
62  }
63 
64  /// Sets the firm id that was assigned by the exchange.
66  SessionSettings& firmId(const std::string & value);
67 
68  /// \return the access key that was assigned by the exchange.
69  ///
70  /// The default value is empty.
72  const std::string & accessKey() const {
73  return accessKey_;
74  }
75 
76  /// Sets the access key that was assigned by the exchange.
78  SessionSettings& accessKey(const std::string & value);
79 
80  /// \return the secret key that was assigned by the exchange.
81  ///
82  /// The default value is empty.
84  const std::string & secretKey() const {
85  return secretKey_;
86  }
87 
88  /// Sets the secret key that was assigned by the exchange.
90  SessionSettings& secretKey(const std::string & value);
91 
92  /// \return the trading system name.
93  ///
94  /// The default value is empty.
96  const std::string & tradingSystemName() const {
97  return tradingSystemName_;
98  }
99 
100  /// Sets the trading system name.
102  SessionSettings& tradingSystemName(const std::string & value);
103 
104  /// \return the trading system version.
105  ///
106  /// The default value is empty.
108  const std::string & tradingSystemVersion() const {
109  return tradingSystemVersion_;
110  }
111 
112  /// Sets the trading system version.
114  SessionSettings& tradingSystemVersion(const std::string & value);
115 
116  /// \return the trading system vendor.
117  ///
118  /// The default value is empty.
120  const std::string & tradingSystemVendor() const {
121  return tradingSystemVendor_;
122  }
123 
124  /// Sets the trading system vendor.
126  SessionSettings& tradingSystemVendor(const std::string & value);
127 
128  /// \return the threading model.
129  ///
130  /// The defaul value is Default::ThreadingModelValue.
133  return threadingModel_;
134  }
135 
136  /// Sets the threading model.
138  SessionSettings& threadingModel(ThreadingModel::Enum value);
139 
140  /// The maximum spinning timeout (microseconds).
141  static const unsigned MaxSpinningTimeoutUsec = 1000000; //1 sec
142 
143  /// \return the receive spinning timeout (microseconds).
144  ///
145  /// The defaul value is Default::ReceiveSpinningTimeout.
147  unsigned receiveSpinningTimeout() const {
148  return receiveSpinningTimeout_;
149  }
150 
151  /// Sets the receive spinning timeout (microseconds).
153  SessionSettings& receiveSpinningTimeout(unsigned usecTimeout);
154 
155  /// \return the send spinning timeout (microseconds).
156  ///
157  /// The defaul value is Default::SendSpinningTimeout.
159  unsigned sendSpinningTimeout() const
160  {
161  return sendSpinningTimeout_;
162  }
163 
164  /// Sets the send spinning timeout (microseconds).
166  SessionSettings& sendSpinningTimeout(unsigned usecTimeout);
167 
168  /// \return the message grouping mode.
169  ///
170  /// - `0` means default grouping - the messages are sent immediately, and pending messages (if any) are grouped till reaching of TCP buffer size.
171  /// - `1` means the messages are sent immediately and never grouped.
172  /// - `2` (or higher) means the messages are sent immediately, and pending messages are grouped by 2 (or higher).
173  ///
174  /// The defaul value is Default::MessageGrouping.
176  unsigned messageGrouping() const {
177  return messageGrouping_;
178  }
179 
180  /// Sets the message grouping mode.
182  SessionSettings& messageGrouping(unsigned value);
183 
184  /// Resets the settings to the default values.
185  SessionSettings& resetToDefaults();
186 
187  /// Adds the path to the folder that contains license file(s).
189  SessionSettings& addLicenseStore(const std::string& value);
190 
191  /// Sets the path to the folder that contains license file(s).
193  SessionSettings& licenseStore(const std::string & value);
194 
195  /// Folders that contain license file(s).
196  typedef std::vector<std::string> LicenseStores;
197 
198  /// \return path(s) to the folder that contains license file(s).
199  ///
200  /// The default value is '.'.
202  const LicenseStores& licenseStores() const
203  {
204  return licenseStores_;
205  }
206 
207  /// \return the number of days to alert before the license expiration.
208  ///
209  /// The defaul value is Default::LicenseAlertingDaysBeforeExpiration.
212  return licenseAlertingDaysBeforeExpiration_;
213  }
214 
215  /// Sets the number of days to alert before the license expiration.
216  ///
217  /// If the amount of remaining license days is less or equal to this number,
218  /// then the warning is reported to the Handler's log.
219  ///
220  /// The verification is performed during the Session::connect call.
222  SessionSettings& licenseAlertingDaysBeforeExpiration(unsigned days) {
223  licenseAlertingDaysBeforeExpiration_ = days;
224  return *this;
225  }
226 
227  /// \return The interface name or IP-address from which the Handler connects to the counterparty.
228  ///
229  /// The default value is empty.
231  const std::string & localNetworkInterface() const {
232  return localNetworkInterface_;
233  }
234 
235  /// Specifies the local interface from which the Handler connects to the counterparty.
236  ///
237  /// Each local interface specification could specify the local IP address and port.
238  /// For instance, `localhost` and `192.168.0.1:4501` are valid values.
240  SessionSettings& localNetworkInterface(const std::string & value);
241 
242  /// \return the Handler log file name.
243  ///
244  /// The default value is `HandlerLog.txt`.
246  const std::string & logFileName() const {
247  return logFileName_;
248  }
249 
250  /// Specifies the Handler log file name.
252  SessionSettings& logFileName(const std::string & value);
253 
254  /// \return the Session Storage directory.
255  ///
256  /// Inbound and outbound messages, session's state data and the Handler log file are stored in this directory.
257  ///
258  /// The default value is `MsgStorage`.
260  const std::string & storageDirectory() const {
261  return storageDirectory_;
262  }
263 
264  /// Sets the Session Storage directory.
265  ///
266  /// Inbound and outbound messages, session's state data and the Handler log file are stored in this directory.
268  SessionSettings& storageDirectory(const std::string & value);
269 
270  /// \return the usage of the local time in Handler events and log files.
271  ///
272  /// The defaul value is Default::LocalTimeUsage.
274  bool localTimeUsage() const {
275  return localTimeUsage_;
276  }
277 
278  /// Specifies the usage of the local time in Handler events and log files.
279  ///
280  /// If it is `true`, then the local time is used, otherwise - UTC.
282  SessionSettings& localTimeUsage(bool);
283 
284  /// \return the segment size for the file-based session storage.
285  ///
286  /// The defaul value is Default::FileBasedStorageSegmentSize.
289  return fileBasedStorageSegmentSize_;
290  }
291 
292  /// Sets the segment size for file-based session storage.
294  SessionSettings& fileBasedStorageSegmentSize(Messaging::UInt64 value);
295 
296  /// \return the maximum size of the asynchronous session storage queue.
297  ///
298  /// By default, the size is unlimited.
301  return asyncFileBasedStorageQueueMaxSize_;
302  }
303 
304  /// Sets the maximum size of the asynchronous session storage queue.
306  SessionSettings& asyncFileBasedStorageQueueMaxSize(unsigned value);
307 
308  /// \return the CPU index(es) for affinity of the asynchronous session storage threads.
309  ///
310  /// By default, the affinity is not set.
313  return asyncFileBasedStorageThreadAffinity_;
314  }
315 
316  /// Specifies the CPU index(es) for affinity of the asynchronous session storage threads.
318  SessionSettings& asyncFileBasedStorageThreadAffinity(const CpuIndexes & cpuIndexes);
319 
320  /// \return The file-based storage integrity errors checking mode:
321  ///
322  /// - `true` - ignore errors and create a new storage
323  /// - `false` - throw an exception
324  ///
325  /// The defaul value is Default::IgnoreFileBasedStorageIntegrityErrors.
328  return ignoreFileBasedStorageIntegrityErrors_;
329  }
330 
331  /// Sets the file-based storage integrity errors checking mode.
333  SessionSettings& ignoreFileBasedStorageIntegrityErrors(bool);
334 
335  /// \return `true` if outbound messages are logged before sending, 'false' otherwise.
336  ///
337  /// The defaul value is Default::LogBeforeSending.
339  bool logBeforeSending() const {
340  return logBeforeSending_;
341  }
342 
343  /// Controls the order of logging and sending outbound messages.
344  ///
345  /// \param before if 'true' then outbound messages are logged before sending.
347  SessionSettings& logBeforeSending(bool before);
348 
349  /// \return the maximum number of tries to restore the telecommunications link.
350  ///
351  /// The defaul value is Default::ReconnectAttempts.
353  unsigned reconnectAttempts() const {
354  return reconnectAttempts_;
355  }
356 
357  /// Sets the maximum number of tries to restore the telecommunications link.
359  SessionSettings& reconnectAttempts(unsigned reconnectAttempts);
360 
361  /// \return the time interval between retries to restore the telecommunications link (seconds).
362  ///
363  /// The defaul value is Default::ReconnectInterval.
365  unsigned reconnectInterval() const {
366  return reconnectInterval_;
367  }
368 
369  /// Sets the time interval between retries to restore the telecommunications link (seconds).
371  SessionSettings& reconnectInterval(unsigned value);
372 
373  /// Specifies the usage of the operating system default socket buffer size.
374  static const int UseOsDefaultSocketBufferSize = -1;
375 
376  /// \return the socket receive buffer size.
377  ///
378  /// The default value is Default::SocketReceiveBufferSize.
381  return socketReceiveBufferSize_;
382  }
383 
384  /// Sets the socket receive buffer size.
385  ///
386  /// \param bufferSize the size of the socket receive buffer size.
387  /// If SessionSettings::UseOsDefaultSocketBufferSize then the default operating system value is used.
389  SessionSettings& socketReceiveBufferSize(int bufferSize);
390 
391  /// \return the reasonable transmission time - as the percentage from the `KeepAliveInterval` value.
392  ///
393  /// The defaul value is Default::ReasonableTransmissionTime.
395  unsigned reasonableTransmissionTime() const {
396  return reasonableTransmissionTime_;
397  }
398 
399  /// Sets the reasonable transmission time - as the percentage from the `KeepAliveInterval` value.
401  SessionSettings& reasonableTransmissionTime(unsigned percentage);
402 
403  /// \return the size of the socket send buffer size.
404  ///
405  /// The default value is Default::SocketSedndBufferSize.
407  int socketSendBufferSize() const {
408  return socketSendBufferSize_;
409  }
410 
411  /// Sets the size of the socket send buffer size.
412  ///
413  /// \param bufferSize the size of the socket send buffer size.
414  /// If SessionSettings::UseOsDefaultSocketBufferSize then the default operating system value is used.
416  SessionSettings& socketSendBufferSize(int bufferSize);
417 
418  /// \return the thread pool affinity.
420  const CpuIndexes & threadPoolAffinity() const {
421  return threadPoolAffinity_;
422  }
423 
424  /// Sets the thread pool affinity.
426  SessionSettings& threadPoolAffinity(const CpuIndexes & cpuIndexes);
427 
428  /// \return the thread pool priority.
430  int threadPoolPriority() const {
431  return threadPoolPriority_;
432  }
433 
434  /// Sets the thread pool priority.
436  SessionSettings& threadPoolPriority(int priority);
437 
438  /// \return the thread pool policy.
440  int threadPoolPolicy() const {
441  return threadPoolPolicy_;
442  }
443 
444  /// Sets the thread pool policy.
446  SessionSettings& threadPoolPolicy(int policy);
447 
448  /// \return the value of the option to improve latency at the expense of message throughput (the `TCP_NODELAY` socket option).
449  ///
450  /// The default value is Default::TcpNoDelayOption.
452  bool tcpNoDelayOption() const {
453  return tcpNoDelayOption_;
454  }
455 
456  /// Sets the value of the option to improve latency at the expense of message throughput (the `TCP_NODELAY` socket option).
458  SessionSettings& tcpNoDelayOption(bool value);
459 
460  /// \return the size of the shared thread pool.
461  ///
462  /// The default value is Default::ThreadPoolSize.
464  unsigned threadPoolSize() const {
465  return threadPoolSize_;
466  }
467 
468  /// Sets the size of the shared thread pool.
470  SessionSettings& threadPoolSize(unsigned numberOfThreads);
471 
472  /// \return the longest time in milliseconds the client system can remain silent before sending a message.
473  ///
474  /// The default value is Default::KeepAliveInterval.
476  unsigned keepAliveInterval() const
477  {
478  return keepAliveInterval_;
479  }
480 
481  /// Sets the longest time in milliseconds the client system can remain silent before sending
482  /// a message.
483  ///
484  /// \note Allowed range is between `5000` - `60000`. Any value outside this range will be rejected.
486  SessionSettings& keepAliveInterval(unsigned milliseconds);
487 
488  /// \return `true` if new messages are reported even when the message gap is detected,
489  /// and the reply on the [Retransmit Request](https://www.cmegroup.com/confluence/display/EPICSANDBOX/Retransmit+Request)
490  /// message is expected, otherwise - `false`.
491  ///
492  /// The default value is Default::ReportNewMessagesWhileWaitingForMissedMessages.
495  return reportNewMessagesWhileWaitingForMissedMessages_;
496  }
497 
498  /// Sets the option to report new messages even when the message gap is detected,
499  /// and the reply on the [Retransmit Request](https://www.cmegroup.com/confluence/display/EPICSANDBOX/Retransmit+Request)
500  /// message is expected.
502  SessionSettings& reportNewMessagesWhileWaitingForMissedMessages(bool report);
503 
504  /// Loads the settings from the given configuration file.
505  ///
506  /// \see Key
508  SessionSettings& load(const std::string& configFile);
509 
510  /// \return the human-friendly description.
512  std::string toString() const;
513 
514  /// Default session settings.
516  static const ThreadingModel::Enum ThreadingModelValue = ThreadingModel::DedicatedThreads;
517  static const bool CreateLogFile = true;
518  static const int KeepAliveInterval = 30000;
519  static const bool LogBeforeSending = true;
520  static const int SocketSendBufferSize = UseOsDefaultSocketBufferSize;
521  static const int SocketReceiveBufferSize = UseOsDefaultSocketBufferSize;
522  static const bool TcpNoDelayOption = true;
523  static const int ReceiveSpinningTimeout = 0;
524  static const int SendSpinningTimeout = 0;
525  static const char LicenseStore[] ;
526  static const unsigned LicenseAlertingDaysBeforeExpiration = 0;
527  static const char LogDir[];
528  static const char LogFileName[];
529  static const bool LocalTimeUsage = false;
530  static const unsigned MessageGrouping = 0;
531  static const int ReasonableTransmissionTime = 20;
532  static const int ReconnectAttempts = 3;
533  static const int ReconnectInterval = 180;
534  static const unsigned long long FileBasedStorageSegmentSize = 0;
535  static const bool IgnoreFileBasedStorageIntegrityErrors = false;
536  static const int ThreadPoolSize = 0;
537  static const bool ReportNewMessagesWhileWaitingForMissedMessages = false;
538  static const unsigned AsyncFileBasedStorageQueueMaxSize = UINT_MAX;
539  };
540 
541  /// The keys that are used to load settings from the configuration file.
543  static const char * SessionId; ///< = "SessionId"
544  static const char * FirmId; ///< = "FirmId"
545  static const char * AccessKey; ///< = "AccessKey"
546  static const char * SecretKey; ///< = "SecretKey"
547  static const char * TradingSystemName; ///< = "TradingSystem.Name"
548  static const char * TradingSystemVersion; ///< = "TradingSystem.Version"
549  static const char * TradingSystemVendor; ///< = "TradingSystem.Vendor"
550 
551  static const char * AsyncFileBasedStorageQueueMaxSize; ///< = "AsyncFileBasedStorage.QueueMaxSize"
552  static const char * AsyncFileBasedStorageThreadAffinity; ///< = "AsyncFileBasedStorage.ThreadAffinity"
553  static const char * ThreadingModel; ///< = "ThreadingModel"
554  static const char * TcpNoDelayOption; ///< = "TcpNoDelayOption"
555  static const char * MessageGrouping; ///< = "MessageGrouping"
556  static const char * FileBasedStorageSegmentSize; ///< = "FileBasedStorageSegmentSize"
557  static const char * IgnoreFileBasedStorageIntegrityErrors; ///< = "IgnoreFileBasedStorageIntegrityErrors"
558  static const char * KeepAliveInterval; ///< = "KeepAliveInterval"
559  static const char * LicenseFile; ///< = "LicenseFile"
560  static const char * LicenseStore; ///< = "LicenseStore"
561  static const char * LicenseAlertingDaysBeforeExpiration; ///< = "LicenseAlertingDaysBeforeExpiration"
562  static const char * LocalNetworkInterface; ///< = "LocalNetworkInterface"
563  static const char * LogFileName; ///< = "Log.FileName"
564  static const char * LocalTimeUsage; ///< = "LocalTimeUsage"
565  static const char * LogBeforeSending; ///< = "Log.BeforeSending"
566  static const char * ReasonableTransmissionTime; ///< = "ReasonableTransmissionTime"
567  static const char * ReceiveSpinningTimeout; ///< = "ReceiveSpinningTimeout"
568  static const char * ReconnectAttempts; ///< = "Reconnect.Attempts"
569  static const char * ReconnectInterval; ///< = "Reconnect.Interval"
570  static const char * SendSpinningTimeout; ///< = "SendSpinningTimeout"
571  static const char * ThreadPoolAffinity; ///< = "ThreadPool.Affinity"
572  static const char * ThreadPoolSize; ///< = "ThreadPool.Size"
573  static const char * ThreadPoolPriority; ///< = "ThreadPool.Priority"
574  static const char * ThreadPoolPolicy; ///< = "ThreadPool.Policy"
575  static const char * SocketReceiveBufferSize; ///< = "Socket.ReceiveBufferSize"
576  static const char * SocketSendBufferSize; ///< = "Socket.SendBufferSize"
577  static const char * StorageDirectory; ///< = "Log.Directory"
578  static const char * ReportNewMessagesWhileWaitingForMissedMessages; ///< = "ReportNewMessagesWhileWaitingForMissedMessages"
579  };
580 
581 private:
582  void processLicenseStores(const std::string& licenseStore);
583 
584  std::string accessKey_;
585 
586  unsigned asyncFileBasedStorageQueueMaxSize_;
587 
588  CpuIndexes asyncFileBasedStorageThreadAffinity_;
589 
590  bool createEngineLogFile_;
591 
592  Messaging::UInt64 fileBasedStorageSegmentSize_;
593 
594  std::string firmId_;
595 
596  bool ignoreFileBasedStorageIntegrityErrors_;
597 
598  unsigned keepAliveInterval_;
599 
600  unsigned licenseAlertingDaysBeforeExpiration_;
601 
602  std::string licenseFilePath_;
603 
604  LicenseStores licenseStores_;
605 
606  std::string localNetworkInterface_;
607 
608  bool localTimeUsage_;
609 
610  bool logBeforeSending_;
611 
612  std::string logFileName_;
613 
614  unsigned messageGrouping_;
615 
616  unsigned reasonableTransmissionTime_;
617 
618  int receiveSpinningTimeout_;
619 
620  unsigned reconnectAttempts_;
621 
622  unsigned reconnectInterval_;
623 
624  bool reportNewMessagesWhileWaitingForMissedMessages_;
625 
626  std::string secretKey_;
627 
628  int sendSpinningTimeout_;
629 
630  std::string sessionId_;
631 
632  int socketReceiveBufferSize_;
633 
634  int socketSendBufferSize_;
635 
636  std::string storageDirectory_;
637 
638  bool tcpNoDelayOption_;
639 
640  ThreadingModel::Enum threadingModel_;
641 
642  CpuIndexes threadPoolAffinity_;
643 
644  int threadPoolPolicy_;
645 
646  int threadPoolPriority_;
647 
648  unsigned threadPoolSize_;
649 
650  std::string tradingSystemName_;
651 
652  std::string tradingSystemVendor_;
653 
654  std::string tradingSystemVersion_;
655 };
656 
657 }
658 }
659 }
static const char * ReceiveSpinningTimeout
= "ReceiveSpinningTimeout"
static const char * LogFileName
= "Log.FileName"
ThreadingModel::Enum threadingModel() const
const std::string & firmId() const
static const char * LocalTimeUsage
= "LocalTimeUsage"
Each session has a sender thread and a receiving thread.
static const char * ReportNewMessagesWhileWaitingForMissedMessages
= "ReportNewMessagesWhileWaitingForMissedMessages"
static const char * ThreadPoolPolicy
= "ThreadPool.Policy"
std::vector< std::string > LicenseStores
Folders that contain license file(s).
static const char * LocalNetworkInterface
= "LocalNetworkInterface"
static const char * AccessKey
= "AccessKey"
static const char * ReconnectInterval
= "Reconnect.Interval"
static const char * FirmId
= "FirmId"
unsigned reasonableTransmissionTime() const
static const unsigned MaxSpinningTimeoutUsec
The maximum spinning timeout (microseconds).
static const char * LicenseFile
= "LicenseFile"
static const char * FileBasedStorageSegmentSize
= "FileBasedStorageSegmentSize"
static const char * KeepAliveInterval
= "KeepAliveInterval"
static const char * SocketReceiveBufferSize
= "Socket.ReceiveBufferSize"
static const char * StorageDirectory
= "Log.Directory"
const std::string & tradingSystemVendor() const
static const char * LicenseAlertingDaysBeforeExpiration
= "LicenseAlertingDaysBeforeExpiration"
SessionSettings & licenseStore(const std::string &value)
Sets the path to the folder that contains license file(s).
static const char * ThreadPoolAffinity
= "ThreadPool.Affinity"
static const char * ThreadingModel
= "ThreadingModel"
static const char * SecretKey
= "SecretKey"
const std::string & accessKey() const
std::set< CpuIndex > CpuIndexes
Definition: Defines.h:74
Messaging::UInt64 fileBasedStorageSegmentSize() const
Definition: Defines.h:40
const std::string & tradingSystemVersion() const
The keys that are used to load settings from the configuration file.
SessionSettings & licenseAlertingDaysBeforeExpiration(unsigned days)
Sets the number of days to alert before the license expiration.
bool reportNewMessagesWhileWaitingForMissedMessages() const
static const char * TradingSystemVendor
= "TradingSystem.Vendor"
static const char * LogBeforeSending
= "Log.BeforeSending"
unsigned licenseAlertingDaysBeforeExpiration() const
const CpuIndexes & asyncFileBasedStorageThreadAffinity() const
const std::string & tradingSystemName() const
static const char * SocketSendBufferSize
= "Socket.SendBufferSize"
const std::string & logFileName() const
static const char * SendSpinningTimeout
= "SendSpinningTimeout"
static const char * IgnoreFileBasedStorageIntegrityErrors
= "IgnoreFileBasedStorageIntegrityErrors"
const CpuIndexes & threadPoolAffinity() const
const std::string & sessionId() const
static const char * ThreadPoolPriority
= "ThreadPool.Priority"
#define ONIXS_ILINK3_EXPORTED
Definition: Compiler.h:162
const std::string & storageDirectory() const
unsigned asyncFileBasedStorageQueueMaxSize() const
static const char * MessageGrouping
= "MessageGrouping"
static const char * AsyncFileBasedStorageThreadAffinity
= "AsyncFileBasedStorage.ThreadAffinity"
static const int UseOsDefaultSocketBufferSize
Specifies the usage of the operating system default socket buffer size.
static const char * TcpNoDelayOption
= "TcpNoDelayOption"
static const char * ThreadPoolSize
= "ThreadPool.Size"
UInt64 UInt64
uInt64.
Definition: Fields.h:276
static const char * TradingSystemVersion
= "TradingSystem.Version"
static const char * SessionId
= "SessionId"
SessionSettings & load(const std::string &configFile)
Loads the settings from the given configuration file.
SessionSettings & addLicenseStore(const std::string &value)
Adds the path to the folder that contains license file(s).
static const char * ReconnectAttempts
= "Reconnect.Attempts"
const std::string & secretKey() const
#define ONIXS_ILINK3_NODISCARD
Definition: Compiler.h:173
static const char * TradingSystemName
= "TradingSystem.Name"
const LicenseStores & licenseStores() const
static const char * LicenseStore
= "LicenseStore"
SessionSettings & resetToDefaults()
Resets the settings to the default values.
static const char * AsyncFileBasedStorageQueueMaxSize
= "AsyncFileBasedStorage.QueueMaxSize"
const std::string & localNetworkInterface() const
static const char * ReasonableTransmissionTime
= "ReasonableTransmissionTime"