Files
spark/src/lib/persistence/PersistenceServiceServer.cpp
T

364 lines
10 KiB
C++

#include "PersistenceServiceServer.h"
#include "SqliteStore.h"
#include "lib/logging/logging.h"
#include "lib/os/os.h"
#include "lib/utils/bts_assert.h"
#include "lib/utils/bts_no_copy.h"
#include "lib/utils/file_utils.h"
namespace bts {
namespace persistence {
using namespace api::persistence;
struct PersistenceServiceServer::NSRecord {
NSRecord() : publish(), data() {}
Publisher publish;
std::map<std::string, std::string> data;
std::vector<Record> to_vec() {
std::vector<Record> result;
result.reserve(data.size());
for (auto const &kvp : data) {
result.emplace_back();
auto &r = result.back();
r.set_key(kvp.first);
r.set_value(kvp.second);
}
return result;
}
void publish_all() {
auto v = to_vec();
publish(&v, nullptr, nullptr);
}
};
struct PersistenceServiceServer::PImpl {
PImpl(std::string const &db) : db(db), store(db), data() {}
std::string const db;
SqliteStore store;
std::map<std::string, NSRecord> data;
BTS_NO_COPY(PImpl);
};
PersistenceServiceServer::PersistenceServiceServer(
bts::api::ServiceContext &context, std::string const &db)
: PersistenceServiceBase(context, db), me(new PImpl(db)) {
LOG(persist, Warn, "Starting persistence service for {}", db);
bts_assert(db.size());
// load data
auto data = me->store.retrieve_all();
for (auto const &kvp : data) {
auto const &ns = kvp.first;
auto &ns_rec = me->data[ns];
ns_rec.publish = make_ns_publisher(ns);
for (auto const &kvp : kvp.second) {
auto const &k = kvp.first;
auto const &v = kvp.second;
ns_rec.data[k] = std::move(v);
}
ns_rec.publish_all();
}
}
PersistenceServiceServer::~PersistenceServiceServer() {}
void PersistenceServiceServer::retrieve(
const RetrieveRequest &request,
const std::function<void(const RetrieveResponse &)> &reply) {
LOG(persist, Diag, "Retrieving {} rows from {}/{}", request.key().size(),
me->db, request.ns());
RetrieveResponse response;
if (request.ns().empty()) {
LOG(persist, Error,
"Client used empty namespace while trying to retrieve rows in "
"database {}",
me->db);
response.set_result(RetrieveResponse::EMPTY_NS);
reply(response);
return;
}
auto it = me->data.find(request.ns());
if (it == me->data.end()) {
LOG(persist, Warn,
"Client tried to retrieve specific rows from unknown namespace {}/{}",
me->db, request.ns());
response.set_result(RetrieveResponse::NO_SUCH_NS);
reply(response);
return;
}
auto &known_rows = it->second.data;
std::set<std::string> keys;
for (auto &k : request.key()) {
if (keys.count(k)) {
LOG(persist, Error,
"Client tried to retrieve row with key {} twice in {}/{}", k,
me->db, request.ns());
response.set_result(RetrieveResponse::DUPLICATE_KEY);
reply(response);
return;
}
auto it = known_rows.find(k);
if (it == known_rows.end()) {
LOG(persist, Warn,
"Client tried to retrieve unknown row with key {} in {}/{}", k,
me->db, request.ns());
response.set_result(RetrieveResponse::DUPLICATE_KEY);
reply(response);
return;
}
Record r;
r.set_key(k);
r.set_value(it->second);
*response.add_record() = r;
}
response.set_result(RetrieveResponse::OK);
reply(response);
LOG(persist, Diag, "Successfully retrieved {} rows from {}/{}",
request.key().size(), me->db, request.ns());
}
void PersistenceServiceServer::retrieve_all(
const RetrieveAllRequest &request,
const std::function<void(const RetrieveResponse &)> &reply) {
LOG(persist, Diag, "Retrieving all rows from {}/{}", me->db, request.ns());
RetrieveResponse response;
if (request.ns().empty()) {
LOG(persist, Warn,
"Client used empty namespace while trying to retrieve rows in "
"database {}",
me->db);
response.set_result(RetrieveResponse::EMPTY_NS);
reply(response);
return;
}
auto it = me->data.find(request.ns());
if (it == me->data.end()) {
response.set_result(RetrieveResponse::NO_SUCH_NS);
reply(response);
return;
}
auto v = it->second.to_vec();
for (auto &r : v)
*response.add_record() = r;
response.set_result(RetrieveResponse::OK);
reply(response);
LOG(persist, Diag, "Successfully retrieved all {} rows from {}/{}", v.size(),
me->db, request.ns());
}
void PersistenceServiceServer::remove(
const RemoveRequest &request,
const std::function<void(const RemoveResponse &)> &reply) {
LOG(persist, Diag, "Removing {} rows from {}/{}", request.key().size(),
me->db, request.ns());
RemoveResponse response;
if (request.ns().empty()) {
LOG(persist, Error,
"Client used empty namespace while trying to remove rows in database "
"{}",
me->db);
response.set_result(RemoveResponse::EMPTY_NS);
reply(response);
return;
}
auto it = me->data.find(request.ns());
if (it == me->data.end()) {
LOG(persist, Warn,
"Client used unknown namespace {} while trying to remove rows in "
"database {}",
request.ns(), me->db);
response.set_result(RemoveResponse::NO_SUCH_NS);
reply(response);
return;
}
auto &ns_rec = it->second;
std::set<std::string> keys;
for (auto &k : request.key()) {
if (keys.count(k)) {
LOG(persist, Warn,
"Client used duplicate key {} while trying to remove rows in "
"{}/{}",
k, me->db, request.ns());
response.set_result(RemoveResponse::DUPLICATE_KEY);
reply(response);
return;
}
keys.insert(k);
if (k.empty()) {
LOG(persist, Warn,
"Client used empty key while trying to remove rows in {}/{}",
me->db, request.ns());
response.set_result(RemoveResponse::EMPTY_KEY);
reply(response);
return;
}
if (ns_rec.data.find(k) == ns_rec.data.end()) {
LOG(persist, Info,
"Client tried to remove unknown row with key {} in {}/{}", k,
me->db, request.ns());
response.set_result(RemoveResponse::NO_SUCH_KEY);
reply(response);
return;
}
}
// update memory
for (auto &k : keys)
ns_rec.data.erase(k);
// update store
me->store.remove(request.ns(), keys);
// update stream
ns_rec.publish(nullptr, nullptr, &keys);
response.set_result(RemoveResponse::OK);
reply(response);
LOG(persist, Diag, "Successfully removed {} rows from {}/{}", keys.size(),
me->db, request.ns());
}
void PersistenceServiceServer::remove_all(
const RemoveAllRequest &request,
const std::function<void(const RemoveResponse &)> &reply) {
LOG(persist, Diag, "Removing all rows from {}/{}", me->db, request.ns());
RemoveResponse response;
if (request.ns().empty()) {
LOG(persist, Error,
"Client used empty namespace while trying to remove all rows in "
"database {}",
me->db);
response.set_result(RemoveResponse::EMPTY_NS);
reply(response);
return;
}
auto it = me->data.find(request.ns());
if (it == me->data.end()) {
LOG(persist, Error,
"Client used unknown namespace {} while trying to remove all rows in "
"database {}",
request.ns(), me->db);
response.set_result(RemoveResponse::NO_SUCH_NS);
reply(response);
return;
}
auto &ns_rec = it->second;
std::set<std::string> keys;
for (auto &kvp : ns_rec.data)
keys.insert(kvp.first);
// update memory
ns_rec.data.clear();
// update store
me->store.remove_all(request.ns());
// update stream
ns_rec.publish(nullptr, nullptr, &keys);
response.set_result(RemoveResponse::OK);
reply(response);
LOG(persist, Diag, "Successfully removed all {} rows from {}/{}",
keys.size(), me->db, request.ns());
}
void PersistenceServiceServer::store(
const StoreRequest &request,
const std::function<void(const StoreResponse &)> &reply) {
LOG(persist, Diag, "Storing {} rows in {}/{}", request.record().size(),
me->db, request.ns());
StoreResponse response;
if (request.ns().empty()) {
LOG(persist, Error,
"Client used empty namespace while trying to store rows in database "
"{}",
me->db);
response.set_result(StoreResponse::EMPTY_NS);
reply(response);
return;
}
NSRecord *rec = nullptr;
auto it = me->data.find(request.ns());
if (it == me->data.end()) {
rec = &me->data[request.ns()];
rec->publish = make_ns_publisher(request.ns());
} else
rec = &(it->second);
std::set<std::string> keys;
for (auto &r : request.record()) {
auto const &k = r.key();
if (keys.count(k)) {
LOG(persist, Error,
"Client used duplicate key {} while trying to store rows in {}/{}",
k, me->db, request.ns());
response.set_result(StoreResponse::DUPLICATE_KEY);
reply(response);
return;
}
if (k.empty()) {
LOG(persist, Error,
"Client used empty key while trying to store rows in {}/{}",
me->db, request.ns());
response.set_result(StoreResponse::EMPTY_KEY);
reply(response);
return;
}
}
std::vector<Record> insert;
std::vector<Record> update;
for (auto &record : request.record()) {
auto it = rec->data.find(record.key());
// update memory
me->data[request.ns()].data[record.key()] = record.value();
if (it != rec->data.end()) {
// update store
update.push_back(record);
me->store.update(request.ns(), record.key(), record.value());
} else {
// insert in store
insert.push_back(record);
me->store.insert(request.ns(), record.key(), record.value());
}
}
rec->publish(&insert, &update, nullptr);
response.set_result(StoreResponse::OK);
reply(response);
LOG(persist, Diag, "Successfully stored {} rows in {}/{}",
request.record().size(), me->db, request.ns());
}
} // namespace persistence
} // namespace bts