Files
spark/src/lib/persistence/PersistenceServiceServer.cpp
T
2018-08-01 17:11:17 +00:00

340 lines
10 KiB
C++

#include "PersistenceServiceServer.h"
#include "lib/utils/bts_assert.h"
#include "lib/utils/file_utils.h"
#include "lib/utils/bts_no_copy.h"
#include "lib/os/os.h"
#include "lib/logging/logging.h"
#include "SqliteStore.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());
}
}}