Files
spark/src/lib/md/SyntheticSecurityService.cpp
T

227 lines
7.9 KiB
C++

#ifndef _WIN32
#include "SyntheticSecurityService.h"
#include "lib/api/public/ServiceContext.h"
#include "lib/api/services/PersistenceService.pb.h"
#include "lib/config/config.h"
#include "lib/md/SecurityDB.h"
#include "lib/md/SecurityIDRecorder.h"
#include "lib/md/common.h"
#include "lib/md/get_symbols.h"
#include "lib/utils/Dispatcher.h"
#include "lib/utils/Event.h"
#include <set>
namespace bts {
namespace api {
namespace synthetic {
struct SecurityLess {
bool operator()(const api::Security &left, const api::Security &right) {
return left.id() < right.id();
}
};
typedef SyntheticSecurityServiceBase::MetadataStatefulPublisher
MetadataPublisher;
struct SyntheticSecurityService::Pimpl {
Pimpl(const MetadataStatefulPublisher &fn)
: recorder(utils::Dispatcher::background()), synthetics(), on_security(),
meta(), on_metadata(), metadata_publisher(fn) {}
md::SecurityIDRecorder recorder;
std::unordered_map<SecurityKey, Security> synthetics;
utils::Event<Security> on_security;
std::unordered_map<SecurityKey, Metadata> meta;
utils::Event<Metadata> on_metadata;
MetadataStatefulPublisher metadata_publisher;
};
SyntheticSecurityService::SyntheticSecurityService(api::ServiceContext &context)
: SyntheticSecurityServiceBase(context),
_me(new Pimpl(make_metadata_stateful_publisher())) {
// load securities
std::set<md::UserSymbol> symbols;
md::get_system_md_symbols(api::VENUE_BTS, api::SECURITYTYPE_UNSET, symbols);
md::db::load_securities(symbols, [=, this](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) {
auto iter = _me->synthetics.find(SecurityKey(entry.security_key()));
if (iter != _me->synthetics.end()) {
if (entry.strategy().deleted()) {
_me->synthetics.erase(iter);
} else {
_me->meta.insert(std::make_pair(entry.security_key(), entry));
_me->metadata_publisher.add_or_update(entry);
}
}
}
if (_me->meta.size() > 0) {
_me->metadata_publisher.flush();
}
}
SyntheticSecurityService::~SyntheticSecurityService() {}
const std::unordered_map<SecurityKey, Security>
SyntheticSecurityService::securities() {
return _me->synthetics;
}
utils::EventSubscriber<Security> &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<Metadata> &SyntheticSecurityService::on_metadata() {
return _me->on_metadata;
}
void send_reply(
const api::Response<CreateResult> &fn,
CreateResult::Error err,
uint32_t key = md::invalid_security_key) {
CreateResult r;
r.set_key(key);
r.set_error(err);
fn(r);
LOG(md, Info, "Create new synthetic security key={} response={}", key,
CreateResult::Error_Name(err));
}
void SyntheticSecurityService::create_synthetic(
const Security &security, const api::Response<CreateResult> &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;
}
if (security.exchange() != api::VENUE_BTS) {
send_reply(reply, CreateResult::ERROR_BAD_VENUE);
return;
}
if (security.symbol().empty()) {
send_reply(reply, CreateResult::ERROR_BAD_SYMBOL);
return;
}
if (security.synthetic().name().empty()) {
send_reply(reply, CreateResult::ERROR_BAD_NAME);
return;
}
// Assign security key
_me->recorder.assign_key(
security, [this, reply](const api::Security &security) {
// Notify listeners that a new security is added
auto iter = _me->synthetics.find(SecurityKey(security.id()));
if (iter != _me->synthetics.end()) {
auto metadata = get_metadata(iter->first);
if (metadata && metadata->strategy().deleted()) {
// If this security is deleted we can just undelete it
Metadata newmeta;
// Rather than copy from the existing metatdata create a
// default. The existing metadata is from a deleted spread so
// may not be valid UI will call update_security_metadata if
// non-defaults are needed
newmeta.set_security_key(security.id());
newmeta.mutable_strategy()->set_deleted(false);
LOG(Api, Info, "Un-deleting security {}", security.id());
auto id = security.id();
update_security_metadata(
newmeta, [id, reply](const UpdateResult &result) {
if (result.error() == UpdateResult::ERROR_OK) {
// undelete was successful. Metadata update will make
// this visible again
send_reply(reply, CreateResult::ERROR_OK, id);
} else {
LOG(Api, Info,
"Failed to un-delete security {}. Error {}", id,
result.error());
send_reply(
reply,
CreateResult::ERROR_SECURITY_ALREADY_EXISTS, id);
}
});
} else {
send_reply(
reply, CreateResult::ERROR_SECURITY_ALREADY_EXISTS,
security.id());
}
} else {
_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<UpdateResult> &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);
_me->metadata_publisher.add_or_update(request);
_me->metadata_publisher.flush();
LOG(md, Info, "Update synthetic security key={} response={}", key,
UpdateResult::Error_Name(result.error()));
reply(result);
}
void SyntheticSecurityService::query_security_metadata(
const MetadataQuery &request,
const api::Response<MetadataCollection> &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 synthetic
} // namespace api
} // namespace bts
#endif