#ifndef INCLUDE_CCAPI_CPP_SERVICE_CCAPI_FIX_SERVICE_H_ #define INCLUDE_CCAPI_CPP_SERVICE_CCAPI_FIX_SERVICE_H_ #ifdef CCAPI_ENABLE_SERVICE_FIX #ifndef CCAPI_FIX_READ_BUFFER_SIZE #define CCAPI_FIX_READ_BUFFER_SIZE (1 << 20) #endif #ifndef CCAPI_FIX_WRITE_BUFFER_SIZE #define CCAPI_FIX_WRITE_BUFFER_SIZE (1 << 20) #endif #include "ccapi_cpp/service/ccapi_service.h" #include "hffix.hpp" namespace hff = hffix; namespace ccapi { /** * Defines a service which provides access to exchange API and normalizes them. This is a base class that implements generic functionalities for dealing with * exchange FIX APIs. The Session object is responsible for routing requests and subscriptions to the desired concrete service. */ class FixService : public Service { public: FixService(std::function*)> eventHandler, SessionOptions sessionOptions, SessionConfigs sessionConfigs, ServiceContextPtr serviceContextPtr) : Service(eventHandler, sessionOptions, sessionConfigs, serviceContextPtr) {} virtual ~FixService() {} #ifndef CCAPI_EXPOSE_INTERNAL protected: #endif static std::string printableString(const char* s, size_t n) { std::string output(s, n); std::replace(output.begin(), output.end(), '\x01', '|'); return output; } static std::string printableString(const std::string& s) { std::string output(s); std::replace(output.begin(), output.end(), '\x01', '|'); return output; } void setHostFixFromUrlFix(std::string& aHostFix, std::string& aPortFix, const std::string& baseUrlFix) { auto hostPort = this->extractHostFromUrl(baseUrlFix); aHostFix = hostPort.first; aPortFix = hostPort.second; } // each subscription creates a unique FIX connection void subscribe(std::vector& subscriptionList) override { CCAPI_LOGGER_FUNCTION_ENTER; if (this->shouldContinue.load()) { for (auto& subscription : subscriptionList) { boost::asio::post(*this->serviceContextPtr->ioContextPtr, [that = shared_from_base(), subscription]() mutable { auto now = UtilTime::now(); subscription.setTimeSent(now); auto credential = subscription.getCredential(); if (credential.empty()) { credential = that->credentialDefault; } const auto& fieldSet = subscription.getFieldSet(); if (fieldSet.find(CCAPI_FIX_MARKET_DATA) != fieldSet.end()) { auto fixConnectionPtr = std::make_shared(that->baseUrlFixMarketData, subscription, credential); that->setFixConnectionStream(fixConnectionPtr); CCAPI_LOGGER_WARN("about to subscribe with new fixConnectionPtr " + toString(*fixConnectionPtr)); that->connect(fixConnectionPtr); } else { auto fixConnectionPtr = std::make_shared(that->baseUrlFix, subscription, credential); that->setFixConnectionStream(fixConnectionPtr); CCAPI_LOGGER_WARN("about to subscribe with new fixConnectionPtr " + toString(*fixConnectionPtr)); that->connect(fixConnectionPtr); } }); } } CCAPI_LOGGER_FUNCTION_EXIT; } virtual void onFail(std::shared_ptr fixConnectionPtr) { CCAPI_LOGGER_FUNCTION_ENTER; this->clearStates(fixConnectionPtr); this->onFail_(fixConnectionPtr); CCAPI_LOGGER_FUNCTION_EXIT; } void clearStates(std::shared_ptr fixConnectionPtr) { CCAPI_LOGGER_INFO("clear states for fixConnectionPtr " + toString(*fixConnectionPtr)); auto& connectionId = fixConnectionPtr->id; this->readMessageBufferByConnectionIdMap.erase(connectionId); this->readMessageBufferReadLengthByConnectionIdMap.erase(connectionId); this->writeMessageBufferByConnectionIdMap.erase(connectionId); this->writeMessageBufferWrittenLengthByConnectionIdMap.erase(connectionId); this->fixConnectionPtrByIdMap.erase(connectionId); auto urlBase = fixConnectionPtr->url; this->fixMsgSeqNumByConnectionIdMap.erase(fixConnectionPtr->id); } void onFail_(std::shared_ptr fixConnectionPtr) { fixConnectionPtr->status = FixConnection::Status::FAILED; this->onError(Event::Type::FIX_STATUS, Message::Type::FIX_FAILURE_DUE_TO_CONNECTION_FAILURE, "connection " + toString(*fixConnectionPtr) + " has failed before opening", {fixConnectionPtr->subscription.getCorrelationId()}); auto urlBase = fixConnectionPtr->url; CCAPI_LOGGER_TRACE("urlBase = " + urlBase); CCAPI_LOGGER_TRACE("this->connectNumRetryOnFailByConnectionUrlMap = " + toString(this->connectNumRetryOnFailByConnectionUrlMap)); long seconds = std::round(UtilAlgorithm::exponentialBackoff(1, 1, 2, std::min(this->connectNumRetryOnFailByConnectionUrlMap[urlBase], 6))); CCAPI_LOGGER_INFO("about to set timer for " + toString(seconds) + " seconds"); if (this->connectRetryOnFailTimerByConnectionIdMap.find(fixConnectionPtr->id) != this->connectRetryOnFailTimerByConnectionIdMap.end()) { this->connectRetryOnFailTimerByConnectionIdMap.at(fixConnectionPtr->id)->cancel(); } auto timerPtr = std::make_shared(*this->serviceContextPtr->ioContextPtr, std::chrono::milliseconds(seconds * 1000)); timerPtr->async_wait([fixConnectionPtr, that = shared_from_base(), urlBase](ErrorCode const& ec) { if (that->fixConnectionPtrByIdMap.find(fixConnectionPtr->id) == that->fixConnectionPtrByIdMap.end()) { if (ec) { if (ec != boost::asio::error::operation_aborted) { CCAPI_LOGGER_ERROR("fixConnectionPtr = " + toString(*fixConnectionPtr) + ", connect retry on fail timer error: " + ec.message()); that->onError(Event::Type::FIX_STATUS, Message::Type::GENERIC_ERROR, ec, "timer"); } } else { CCAPI_LOGGER_INFO("about to retry"); that->connect(fixConnectionPtr); that->connectNumRetryOnFailByConnectionUrlMap[urlBase] += 1; } } }); this->connectRetryOnFailTimerByConnectionIdMap[fixConnectionPtr->id] = timerPtr; } void setFixConnectionStream(std::shared_ptr fixConnectionPtr) { if (fixConnectionPtr->isSecure) { fixConnectionPtr->streamPtr = std::make_shared>(*this->serviceContextPtr->ioContextPtr, *this->serviceContextPtr->sslContextPtr); } else { fixConnectionPtr->streamPtr = std::make_shared(*this->serviceContextPtr->ioContextPtr); } } virtual void connect(std::shared_ptr fixConnectionPtr) { fixConnectionPtr->status = FixConnection::Status::CONNECTING; CCAPI_LOGGER_DEBUG("fixConnectionPtr = " + fixConnectionPtr->toString()); this->startResolveFix(fixConnectionPtr); } void startResolveFix(std::shared_ptr fixConnectionPtr) { auto newResolverPtr = std::make_shared(*this->serviceContextPtr->ioContextPtr); newResolverPtr->async_resolve(fixConnectionPtr->host, fixConnectionPtr->port, beast::bind_front_handler(&FixService::onResolveFix, shared_from_base(), fixConnectionPtr, newResolverPtr)); } void onResolveFix(std::shared_ptr fixConnectionPtr, std::shared_ptr newResolverPtr, beast::error_code ec, tcp::resolver::results_type tcpNewResolverResultsFix) { if (ec) { CCAPI_LOGGER_TRACE("dns resolve fail"); this->onFail(fixConnectionPtr); return; } this->startConnectFix(fixConnectionPtr, this->sessionOptions.fixConnectTimeoutMilliseconds, tcpNewResolverResultsFix); } void startConnectFix(std::shared_ptr fixConnectionPtr, long timeoutMilliseconds, tcp::resolver::results_type tcpResolverResults) { std::visit( [&](auto& streamPtr) { using StreamType = std::decay_t; if (timeoutMilliseconds > 0) { beast::get_lowest_layer(*streamPtr).expires_after(std::chrono::milliseconds(timeoutMilliseconds)); } if constexpr (std::is_same_v>) { if (!SSL_set_tlsext_host_name(streamPtr->native_handle(), fixConnectionPtr->host.c_str())) { beast::error_code ec{static_cast(::ERR_get_error()), net::error::get_ssl_category()}; CCAPI_LOGGER_DEBUG("error SSL_set_tlsext_host_name: " + ec.message()); this->onError(Event::Type::FIX_STATUS, Message::Type::FIX_FAILURE, ec, "set SNI Hostname", {fixConnectionPtr->subscription.getCorrelationId()}); return; } } CCAPI_LOGGER_TRACE("before async_connect"); beast::get_lowest_layer(*streamPtr) .async_connect(tcpResolverResults, beast::bind_front_handler(&FixService::onConnectFix, shared_from_base(), fixConnectionPtr)); CCAPI_LOGGER_TRACE("after async_connect"); }, fixConnectionPtr->streamPtr); } void onConnectFix(std::shared_ptr fixConnectionPtr, beast::error_code ec, tcp::resolver::results_type::endpoint_type) { CCAPI_LOGGER_TRACE("async_connect callback start"); auto now = UtilTime::now(); if (ec) { CCAPI_LOGGER_TRACE("fail"); this->onFail(fixConnectionPtr); return; } CCAPI_LOGGER_TRACE("fixConnectionPtr = " + toString(*fixConnectionPtr)); CCAPI_LOGGER_TRACE("connected"); std::visit( [&](auto& streamPtr) { using StreamType = std::decay_t; if constexpr (std::is_same_v>) { CCAPI_LOGGER_TRACE("before ssl async_handshake"); streamPtr->async_handshake(ssl::stream_base::client, beast::bind_front_handler(&FixService::onSslHandshakeFix, shared_from_base(), fixConnectionPtr)); CCAPI_LOGGER_TRACE("after ssl async_handshake"); } else { this->onSslHandshakeFix(fixConnectionPtr, {}); } }, fixConnectionPtr->streamPtr); } void onSslHandshakeFix(std::shared_ptr fixConnectionPtr, beast::error_code ec) { CCAPI_LOGGER_TRACE("async_handshake callback start"); if (ec) { CCAPI_LOGGER_TRACE("fail"); this->onFail(fixConnectionPtr); return; } CCAPI_LOGGER_TRACE("handshaked"); std::visit( [&](auto& streamPtr) { auto& stream = *streamPtr; beast::get_lowest_layer(stream).expires_never(); }, fixConnectionPtr->streamPtr); this->onOpen(fixConnectionPtr); } void onOpen(std::shared_ptr fixConnectionPtr) { auto now = UtilTime::now(); auto& connectionId = fixConnectionPtr->id; fixConnectionPtr->status = FixConnection::Status::OPEN; CCAPI_LOGGER_INFO("connection " + toString(*fixConnectionPtr) + " established"); this->connectNumRetryOnFailByConnectionUrlMap[fixConnectionPtr->url] = 0; { Event event; event.setType(Event::Type::SESSION_STATUS); Message message; message.setTimeReceived(now); message.setType(Message::Type::SESSION_CONNECTION_UP); message.setCorrelationIdList({fixConnectionPtr->subscription.getCorrelationId()}); Element element(true); element.insert(CCAPI_CONNECTION_ID, connectionId); element.insert(CCAPI_CONNECTION_URL, fixConnectionPtr->url); message.setElementList({element}); event.setMessageList({message}); this->eventHandler(event, nullptr); } this->fixConnectionPtrByCorrelationIdMap.insert({fixConnectionPtr->subscription.getCorrelationId(), fixConnectionPtr}); this->fixConnectionPtrByIdMap.insert({connectionId, fixConnectionPtr}); auto nowFixTimeStr = UtilTime::convertTimePointToFIXTime(now); auto credential = fixConnectionPtr->subscription.getCredential(); if (credential.empty()) { credential = this->credentialDefault; } auto& readMessageBuffer = this->readMessageBufferByConnectionIdMap[connectionId]; auto& readMessageBufferReadLength = this->readMessageBufferReadLengthByConnectionIdMap[connectionId]; CCAPI_LOGGER_TRACE("about to start read"); CCAPI_LOGGER_TRACE("readMessageBufferReadLength = " + toString(readMessageBufferReadLength)); this->startReadFix(fixConnectionPtr, readMessageBuffer.data() + readMessageBufferReadLength, std::min(readMessageBuffer.size() - readMessageBufferReadLength, this->readMessageChunkSize)); std::map logonOptionMap; for (const auto& x : fixConnectionPtr->subscription.getOptionMap()) { if (UtilString::isNumber(x.first)) { logonOptionMap.insert({std::stoi(x.first), x.second}); } } auto param = this->createLogonParam(fixConnectionPtr, nowFixTimeStr, logonOptionMap); this->writeMessage(fixConnectionPtr, nowFixTimeStr, {param}); } void startReadFix(std::shared_ptr fixConnectionPtr, void* data, size_t requestedNumBytesToRead) { std::visit( [&](auto& streamPtr) { CCAPI_LOGGER_TRACE("before async_read"); CCAPI_LOGGER_TRACE("requestedNumBytesToRead = " + toString(requestedNumBytesToRead)); streamPtr->async_read_some(boost::asio::buffer(data, requestedNumBytesToRead), beast::bind_front_handler(&FixService::onReadFix, shared_from_base(), fixConnectionPtr)); CCAPI_LOGGER_TRACE("after async_read"); }, fixConnectionPtr->streamPtr); } void onReadFix(std::shared_ptr fixConnectionPtr, const boost::system::error_code& ec, std::size_t n) { CCAPI_LOGGER_FUNCTION_ENTER; CCAPI_LOGGER_TRACE("n = " + toString(n)); auto now = UtilTime::now(); auto nowFixTimeStr = UtilTime::convertTimePointToFIXTime(now); if (ec) { CCAPI_LOGGER_TRACE("fail"); // this->close(fixConnectionPtr); this->onClose(fixConnectionPtr, ec); return; } if (fixConnectionPtr->status != FixConnection::Status::OPEN) { CCAPI_LOGGER_WARN("should not process remaining message on closing"); return; } auto& connectionId = fixConnectionPtr->id; auto& readMessageBuffer = this->readMessageBufferByConnectionIdMap[connectionId]; auto& readMessageBufferReadLength = this->readMessageBufferReadLengthByConnectionIdMap[connectionId]; readMessageBufferReadLength += n; CCAPI_LOGGER_TRACE("readMessageBufferReadLength = " + toString(readMessageBufferReadLength)); hff::message_reader reader(readMessageBuffer.data(), readMessageBuffer.data() + readMessageBufferReadLength); std::vector correlationIdList{fixConnectionPtr->subscription.getCorrelationId()}; for (; reader.is_complete(); reader = reader.next_message_reader()) { Event event; bool shouldEmitEvent = true; Message message; Element element(true); message.setTimeReceived(now); message.setCorrelationIdList({fixConnectionPtr->subscription.getCorrelationId()}); if (reader.is_valid()) { try { CCAPI_LOGGER_DEBUG("received " + printableString(reader.message_begin(), reader.message_end() - reader.message_begin())); auto it = reader.message_type(); auto messageType = it->value().as_string_view(); CCAPI_LOGGER_DEBUG("received a " + std::string(messageType) + " message"); element.insert(it->tag(), messageType); if (messageType == "0") { shouldEmitEvent = false; CCAPI_LOGGER_DEBUG("Heartbeat: " + toString(*fixConnectionPtr)); } else if (messageType == "1") { shouldEmitEvent = false; CCAPI_LOGGER_DEBUG("Test Request: " + toString(*fixConnectionPtr)); if (reader.find_with_hint(hff::tag::TestReqID, it)) { this->writeMessage(fixConnectionPtr, nowFixTimeStr, {{ {hff::tag::MsgType, "0"}, {hff::tag::TestReqID, std::string(it->value().as_string_view())}, }}); } } else { it = it + 5; while (it->tag() != hffix::tag::CheckSum) { element.insert(it->tag(), it->value().as_string_view()); ++it; } if (reader.find_with_hint(hff::tag::MsgSeqNum, it) && it->value().as_string_view() == "1") { if (messageType == "A") { event.setType(Event::Type::AUTHORIZATION_STATUS); message.setType(Message::Type::AUTHORIZATION_SUCCESS); if (this->pingTimerByMethodByConnectionIdMap.find(fixConnectionPtr->id) != this->pingTimerByMethodByConnectionIdMap.end()) { for (const auto& x : this->pingTimerByMethodByConnectionIdMap.at(fixConnectionPtr->id)) { x.second->cancel(); } this->pingTimerByMethodByConnectionIdMap.erase(fixConnectionPtr->id); } this->setPingPongTimer( PingPongMethod::FIX_PROTOCOL_LEVEL, fixConnectionPtr, [that = shared_from_base()](std::shared_ptr fixConnectionPtr) { CCAPI_LOGGER_TRACE("pingMethod is triggered"); auto now = UtilTime::now(); auto nowFixTimeStr = UtilTime::convertTimePointToFIXTime(now); that->writeMessage( fixConnectionPtr, nowFixTimeStr, {{ {hff::tag::MsgType, "0"}, }, { {hff::tag::MsgType, "1"}, {hff::tag::TestReqID, std::to_string(std::chrono::duration_cast(now.time_since_epoch()).count())}, }}); }, true); } else { event.setType(Event::Type::AUTHORIZATION_STATUS); message.setType(Message::Type::AUTHORIZATION_FAILURE); } } else { event.setType(Event::Type::FIX); message.setType(Message::Type::FIX); if (messageType == "5") { if (fixConnectionPtr->status == FixConnection::Status::OPEN) { this->writeMessage(fixConnectionPtr, nowFixTimeStr, {{ {hff::tag::MsgType, "5"}, }}); } else { this->onClose(fixConnectionPtr, {}); } } } } } catch (const std::exception& e) { std::string errorMessage(std::string("Error reading fields: ") + e.what()); element.insert(CCAPI_ERROR_MESSAGE, errorMessage); event.setType(Event::Type::FIX_STATUS); message.setType(Message::Type::GENERIC_ERROR); } } else { std::string errorMessage("Error Invalid FIX message: "); errorMessage.append(reader.message_begin(), std::min(ssize_t(64), readMessageBuffer.data() + readMessageBufferReadLength - reader.message_begin())); errorMessage.append("..."); element.insert(CCAPI_ERROR_MESSAGE, errorMessage); event.setType(Event::Type::FIX_STATUS); message.setType(Message::Type::GENERIC_ERROR); } if (shouldEmitEvent) { message.setElementList({element}); event.setMessageList({message}); this->eventHandler(event, nullptr); } } readMessageBufferReadLength = reader.buffer_end() - reader.buffer_begin(); if (readMessageBufferReadLength >= this->readMessageChunkSize) { std::memmove(readMessageBuffer.data(), reader.buffer_begin(), readMessageBufferReadLength); CCAPI_LOGGER_TRACE("about to start read"); this->startReadFix(fixConnectionPtr, readMessageBuffer.data() + readMessageBufferReadLength, std::min(readMessageBuffer.size() - readMessageBufferReadLength, this->readMessageChunkSize)); } else { CCAPI_LOGGER_TRACE("about to start read"); this->startReadFix(fixConnectionPtr, readMessageBuffer.data() + readMessageBufferReadLength, std::min(readMessageBuffer.size() - readMessageBufferReadLength, this->readMessageChunkSize - readMessageBufferReadLength)); } this->onPongByMethod(PingPongMethod::FIX_PROTOCOL_LEVEL, fixConnectionPtr, now); CCAPI_LOGGER_FUNCTION_EXIT; } void startWriteFix(std::shared_ptr fixConnectionPtr, void* data, size_t numBytesToWrite) { std::visit( [&](auto& streamPtr) { CCAPI_LOGGER_TRACE("before async_write"); CCAPI_LOGGER_TRACE("numBytesToWrite = " + toString(numBytesToWrite)); boost::asio::async_write(*streamPtr, boost::asio::buffer(data, numBytesToWrite), beast::bind_front_handler(&FixService::onWriteFix, shared_from_base(), fixConnectionPtr)); CCAPI_LOGGER_TRACE("after async_write"); }, fixConnectionPtr->streamPtr); } void onWriteFix(std::shared_ptr fixConnectionPtr, const boost::system::error_code& ec, std::size_t n) { CCAPI_LOGGER_FUNCTION_ENTER; auto now = UtilTime::now(); auto& connectionId = fixConnectionPtr->id; if (ec) { CCAPI_LOGGER_TRACE("fail"); ErrorCode ec; // this->close(fixConnectionPtr); this->onClose(fixConnectionPtr, ec); return; } auto& writeMessageBuffer = this->writeMessageBufferByConnectionIdMap[connectionId]; auto& writeMessageBufferWrittenLength = this->writeMessageBufferWrittenLengthByConnectionIdMap[connectionId]; writeMessageBufferWrittenLength -= n; CCAPI_LOGGER_TRACE("writeMessageBufferWrittenLength = " + toString(writeMessageBufferWrittenLength)); if (writeMessageBufferWrittenLength > 0) { std::memmove(writeMessageBuffer.data(), writeMessageBuffer.data() + n, writeMessageBufferWrittenLength); CCAPI_LOGGER_TRACE("about to start write"); this->startWriteFix(fixConnectionPtr, writeMessageBuffer.data(), writeMessageBufferWrittenLength); } CCAPI_LOGGER_FUNCTION_EXIT; } void writeMessage(std::shared_ptr fixConnectionPtr, const std::string& nowFixTimeStr, const std::vector>>& paramList) { if (fixConnectionPtr->status != FixConnection::Status::OPEN) { CCAPI_LOGGER_WARN("should write no more messages"); return; } auto& connectionId = fixConnectionPtr->id; auto& writeMessageBuffer = this->writeMessageBufferByConnectionIdMap[connectionId]; auto& writeMessageBufferWrittenLength = this->writeMessageBufferWrittenLengthByConnectionIdMap[connectionId]; size_t n = writeMessageBufferWrittenLength; for (const auto& param : paramList) { auto commonParam = this->createCommonParam(fixConnectionPtr, nowFixTimeStr); hff::message_writer messageWriter(writeMessageBuffer.data() + n, writeMessageBuffer.data() + writeMessageBuffer.size()); messageWriter.push_back_header(this->protocolVersion.c_str()); auto it = param.begin(); if (it != param.end()) { messageWriter.push_back_string(it->first, it->second); for (const auto& x : commonParam) { messageWriter.push_back_string(x.first, x.second); } ++it; while (it != param.end()) { messageWriter.push_back_string(it->first, it->second); ++it; } } messageWriter.push_back_trailer(); n += messageWriter.message_end() - messageWriter.message_begin(); } CCAPI_LOGGER_DEBUG("about to send " + printableString(writeMessageBuffer.data(), n)); CCAPI_LOGGER_TRACE("writeMessageBufferWrittenLength = " + toString(writeMessageBufferWrittenLength)); if (writeMessageBufferWrittenLength == 0) { CCAPI_LOGGER_TRACE("about to start write"); this->startWriteFix(fixConnectionPtr, writeMessageBuffer.data(), n); } writeMessageBufferWrittenLength = n; CCAPI_LOGGER_TRACE("writeMessageBufferWrittenLength = " + toString(writeMessageBufferWrittenLength)); } void onPongByMethod(PingPongMethod method, std::shared_ptr fixConnectionPtr, const TimePoint& timeReceived) { CCAPI_LOGGER_FUNCTION_ENTER; this->lastPongTpByMethodByConnectionIdMap[fixConnectionPtr->id][method] = timeReceived; CCAPI_LOGGER_FUNCTION_EXIT; } void sendRequestByFix(const std::string& fixOrderEntrySubscriptionCorrelationId, Request& request, const TimePoint& now) override { CCAPI_LOGGER_FUNCTION_ENTER; CCAPI_LOGGER_TRACE("now = " + toString(now)); boost::asio::post(*this->serviceContextPtr->ioContextPtr, [that = shared_from_base(), fixOrderEntrySubscriptionCorrelationId, request]() mutable { auto now = UtilTime::now(); CCAPI_LOGGER_DEBUG("request = " + toString(request)); CCAPI_LOGGER_TRACE("now = " + toString(now)); request.setTimeSent(now); auto nowFixTimeStr = UtilTime::convertTimePointToFIXTime(now); auto it = that->fixConnectionPtrByCorrelationIdMap.find(fixOrderEntrySubscriptionCorrelationId); if (it == that->fixConnectionPtrByCorrelationIdMap.end()) { that->onError(Event::Type::REQUEST_STATUS, Message::Type::REQUEST_FAILURE, "FIX connection was not found", {fixOrderEntrySubscriptionCorrelationId}); return; } auto& fixConnectionPtr = it->second; CCAPI_LOGGER_TRACE("fixConnectionPtr = " + toString(*fixConnectionPtr)); that->writeMessage(fixConnectionPtr, nowFixTimeStr, request.getParamListFix()); }); CCAPI_LOGGER_FUNCTION_EXIT; } void setPingPongTimer(PingPongMethod method, std::shared_ptr fixConnectionPtr, std::function)> pingMethod, bool pingNow = false) { CCAPI_LOGGER_FUNCTION_ENTER; CCAPI_LOGGER_TRACE("method = " + pingPongMethodToString(method)); auto pingIntervalMilliseconds = this->pingIntervalMillisecondsByMethodMap[method]; auto pongTimeoutMilliseconds = this->pongTimeoutMillisecondsByMethodMap[method]; CCAPI_LOGGER_TRACE("pingIntervalMilliseconds = " + toString(pingIntervalMilliseconds)); CCAPI_LOGGER_TRACE("pongTimeoutMilliseconds = " + toString(pongTimeoutMilliseconds)); if (pingIntervalMilliseconds <= pongTimeoutMilliseconds) { return; } CCAPI_LOGGER_DEBUG("fixConnectionPtr->status = " + FixConnection::statusToString(fixConnectionPtr->status)); if (fixConnectionPtr->status == FixConnection::Status::OPEN) { if (pingNow) { pingMethod(fixConnectionPtr); } if (this->pingTimerByMethodByConnectionIdMap.find(fixConnectionPtr->id) != this->pingTimerByMethodByConnectionIdMap.end() && this->pingTimerByMethodByConnectionIdMap.at(fixConnectionPtr->id).find(method) != this->pingTimerByMethodByConnectionIdMap.at(fixConnectionPtr->id).end()) { this->pingTimerByMethodByConnectionIdMap.at(fixConnectionPtr->id).at(method)->cancel(); } auto timerPtr = std::make_shared(*this->serviceContextPtr->ioContextPtr, std::chrono::milliseconds(pingIntervalMilliseconds - pongTimeoutMilliseconds)); timerPtr->async_wait([fixConnectionPtr, that = shared_from_base(), pingMethod, pongTimeoutMilliseconds, method](ErrorCode const& ec) { if (that->fixConnectionPtrByIdMap.find(fixConnectionPtr->id) != that->fixConnectionPtrByIdMap.end()) { if (ec) { if (ec != boost::asio::error::operation_aborted) { CCAPI_LOGGER_ERROR("fixConnectionPtr = " + toString(*fixConnectionPtr) + ", ping timer error: " + ec.message()); that->onError(Event::Type::FIX_STATUS, Message::Type::GENERIC_ERROR, ec, "timer"); } } else { if (that->fixConnectionPtrByIdMap.at(fixConnectionPtr->id)->status == FixConnection::Status::OPEN) { ErrorCode ec; pingMethod(fixConnectionPtr); if (ec) { that->onError(Event::Type::FIX_STATUS, Message::Type::GENERIC_ERROR, ec, "ping"); } if (pongTimeoutMilliseconds <= 0) { return; } if (that->pongTimeOutTimerByMethodByConnectionIdMap.find(fixConnectionPtr->id) != that->pongTimeOutTimerByMethodByConnectionIdMap.end() && that->pongTimeOutTimerByMethodByConnectionIdMap.at(fixConnectionPtr->id).find(method) != that->pongTimeOutTimerByMethodByConnectionIdMap.at(fixConnectionPtr->id).end()) { that->pongTimeOutTimerByMethodByConnectionIdMap.at(fixConnectionPtr->id).at(method)->cancel(); } auto timerPtr = std::make_shared(*that->serviceContextPtr->ioContextPtr, std::chrono::milliseconds(pongTimeoutMilliseconds)); timerPtr->async_wait([fixConnectionPtr, that, pingMethod, pongTimeoutMilliseconds, method](ErrorCode const& ec) { if (that->fixConnectionPtrByIdMap.find(fixConnectionPtr->id) != that->fixConnectionPtrByIdMap.end()) { if (ec) { if (ec != boost::asio::error::operation_aborted) { CCAPI_LOGGER_ERROR("fixConnectionPtr = " + toString(*fixConnectionPtr) + ", pong timeout timer error: " + ec.message()); that->onError(Event::Type::FIX_STATUS, Message::Type::GENERIC_ERROR, ec, "timer"); } } else { if (that->fixConnectionPtrByIdMap.at(fixConnectionPtr->id)->status == FixConnection::Status::OPEN) { auto now = UtilTime::now(); if (that->lastPongTpByMethodByConnectionIdMap.find(fixConnectionPtr->id) != that->lastPongTpByMethodByConnectionIdMap.end() && that->lastPongTpByMethodByConnectionIdMap.at(fixConnectionPtr->id).find(method) != that->lastPongTpByMethodByConnectionIdMap.at(fixConnectionPtr->id).end() && std::chrono::duration_cast(now - that->lastPongTpByMethodByConnectionIdMap.at(fixConnectionPtr->id).at(method)) .count() >= pongTimeoutMilliseconds) { that->close(fixConnectionPtr); } else { that->setPingPongTimer(method, fixConnectionPtr, pingMethod); } } } } }); that->pongTimeOutTimerByMethodByConnectionIdMap[fixConnectionPtr->id][method] = timerPtr; } } } }); this->pingTimerByMethodByConnectionIdMap[fixConnectionPtr->id][method] = timerPtr; } CCAPI_LOGGER_FUNCTION_EXIT; } virtual std::vector> createCommonParam(std::shared_ptr fixConnectionPtr, const std::string& nowFixTimeStr) { return {}; } virtual std::vector> createLogonParam(std::shared_ptr fixConnectionPtr, const std::string& nowFixTimeStr, const std::map logonOptionMap = {}) { return {}; } void close(std::shared_ptr fixConnectionPtr) { CCAPI_LOGGER_DEBUG("fixConnectionPtr->status = " + FixConnection::statusToString(fixConnectionPtr->status)); if (fixConnectionPtr->status == FixConnection::Status::CLOSING || fixConnectionPtr->status == FixConnection::Status::CLOSED) { return; } std::visit( [&](auto& streamPtr) { const auto& now = UtilTime::now(); const auto& nowFixTimeStr = UtilTime::convertTimePointToFIXTime(now); this->writeMessage(fixConnectionPtr, nowFixTimeStr, {{ {hff::tag::MsgType, "5"}, }}); }, fixConnectionPtr->streamPtr); fixConnectionPtr->status = FixConnection::Status::CLOSING; } virtual void onClose(std::shared_ptr fixConnectionPtr, ErrorCode ec) { CCAPI_LOGGER_FUNCTION_ENTER; CCAPI_LOGGER_DEBUG("fixConnectionPtr->status = " + FixConnection::statusToString(fixConnectionPtr->status)); if (fixConnectionPtr->status == FixConnection::Status::CLOSING || fixConnectionPtr->status == FixConnection::Status::CLOSED) { return; } auto now = UtilTime::now(); fixConnectionPtr->status = FixConnection::Status::CLOSED; CCAPI_LOGGER_INFO("connection " + toString(*fixConnectionPtr) + " is closed"); Event event; event.setType(Event::Type::SESSION_STATUS); Message message; message.setTimeReceived(now); message.setType(Message::Type::SESSION_CONNECTION_DOWN); Element element; element.insert(CCAPI_CONNECTION_ID, fixConnectionPtr->id); element.insert(CCAPI_CONNECTION_URL, fixConnectionPtr->url); message.setElementList({element}); std::vector correlationIdList{fixConnectionPtr->subscription.getCorrelationId()}; CCAPI_LOGGER_DEBUG("correlationIdList = " + toString(correlationIdList)); message.setCorrelationIdList(correlationIdList); event.setMessageList({message}); this->eventHandler(event, nullptr); CCAPI_LOGGER_INFO("connection " + toString(*fixConnectionPtr) + " is closed"); this->clearStates(fixConnectionPtr); this->setFixConnectionStream(fixConnectionPtr); this->fixConnectionPtrByCorrelationIdMap.erase(fixConnectionPtr->subscription.getCorrelationId()); this->fixConnectionPtrByIdMap.erase(fixConnectionPtr->id); if (this->shouldContinue.load()) { this->connect(fixConnectionPtr); } CCAPI_LOGGER_FUNCTION_EXIT; } const size_t readMessageChunkSize = CCAPI_HFFIX_READ_MESSAGE_CHUNK_SIZE; std::map> readMessageBufferByConnectionIdMap; std::map readMessageBufferReadLengthByConnectionIdMap; std::map> writeMessageBufferByConnectionIdMap; std::map writeMessageBufferWrittenLengthByConnectionIdMap; std::map> fixConnectionPtrByIdMap; std::string fixApiKeyName; std::string fixApiPrivateKeyPathName; std::string fixApiPrivateKeyPasswordName; std::string baseUrlFix; std::string hostFix; std::string portFix; std::string baseUrlFixMarketData; std::string hostFixMarketData; std::string portFixMarketData; std::string protocolVersion; std::string senderCompId; std::string targetCompId; std::map fixMsgSeqNumByConnectionIdMap; std::map> fixConnectionPtrByCorrelationIdMap; }; } /* namespace ccapi */ #endif #endif // INCLUDE_CCAPI_CPP_SERVICE_CCAPI_FIX_SERVICE_H_