#ifndef WIN32 #include "SyntheticSecurityService.h" #include "lib/config/config.h" #include "lib/api/public/ServiceContext.h" #include "lib/api/services/PersistenceService.pb.h" #include "lib/md/common.h" #include "lib/md/SecurityIDRecorder.h" #include "lib/md/SecurityDB.h" #include "lib/md/get_symbols.h" #include "lib/utils/Dispatcher.h" #include "lib/utils/Event.h" #include namespace bts { namespace api { namespace synthetic { struct SecurityLess { bool operator()(const api::Security& left, const api::Security& right) { return left.id() < right.id(); } }; struct SyntheticSecurityService::Pimpl { Pimpl() : recorder(), timer(utils::Dispatcher::background(), 200, [&]() { recorder.do_work(); }), synthetics(), on_security(), meta(), on_metadata() {} md::SecurityIDRecorder recorder; utils::DispatcherTimer timer; std::unordered_map synthetics; utils::Event on_security; std::unordered_map meta; utils::Event on_metadata; }; SyntheticSecurityService::SyntheticSecurityService(api::ServiceContext& context) : SyntheticSecurityServiceBase(context), _me(new Pimpl()) { // load securities std::set symbols; md::get_system_md_symbols(api::VENUE_BTS, api::SECURITYTYPE_UNSET, symbols); md::db::load_securities(symbols, [=](const api::Security& security) { if (security.Contract_case() == api::Security::kSynthetic) { auto key = SecurityKey(security.id()); _me->synthetics.insert(std::make_pair(key, security)); } }); // Load metadata auto metadata = md::db::load_metadata(); for (const auto& entry : metadata) { _me->meta.insert(std::make_pair(entry.security_key(), entry)); } } SyntheticSecurityService::~SyntheticSecurityService() { } const std::unordered_map SyntheticSecurityService::securities() { return _me->synthetics; } utils::EventSubscriber& SyntheticSecurityService::on_securities() { return _me->on_security; } const Metadata* SyntheticSecurityService::get_metadata(SecurityKey key) { auto iter = _me->meta.find(key); if (iter != _me->meta.end()) { return &iter->second; } return nullptr; } utils::EventSubscriber& SyntheticSecurityService::on_metadata() { return _me->on_metadata; } void send_reply(const api::Response& fn, CreateResult::Error err, uint32_t key=md::invalid_security_key) { CreateResult r; r.set_key(key); r.set_error(err); fn(r); } void SyntheticSecurityService::create_synthetic( const Security& security, const api::Response& reply) { CreateResult result; // Validate security is synthetic if (security.Contract_case() != Security::kSynthetic) { send_reply(reply, CreateResult::ERROR_NOT_SYNTHETIC); return; } if (security.id() != md::invalid_security_key) { send_reply(reply, CreateResult::ERROR_ID_ALREADY_ASSIGNED); return; } // Assign security key _me->recorder.assign_key(security, [=](const api::Security& security) { // Notify listeners that a new security is added _me->synthetics.insert(std::make_pair(security.id(), security)); _me->on_security.publish(security); // signal success send_reply(reply, CreateResult::ERROR_OK, security.id()); }); } void SyntheticSecurityService::update_security_metadata( const Metadata& request, const api::Response& reply) { UpdateResult result; if (request.security_key() == md::invalid_security_key) { result.set_error(UpdateResult::ERROR_MISSING_KEY); reply(result); return; } auto key = SecurityKey(request.security_key()); if (_me->synthetics.find(key) == _me->synthetics.end()) { result.set_error(UpdateResult::ERROR_UNKNOWN_SECURITY); reply(result); return; } // update the on disk database if (!md::db::store_metadata(request)) { result.set_error(UpdateResult::ERROR_DATABASE); reply(result); return; } // update the local database _me->meta[key] = request; // notify subscribers _me->on_metadata.publish(request); reply(result); } void SyntheticSecurityService::query_security_metadata( const MetadataQuery& request, const api::Response& reply) { MetadataCollection result; for (const auto k : request.security_key()) { SecurityKey key(k); auto iter = _me->meta.find(key); if (iter != _me->meta.end()) { result.mutable_data()->Add()->CopyFrom(iter->second); } } reply(result); } }}}//namespace #endif