Files
spark/src/lib/api/core/ApiServerInterop.cpp
T
2017-08-07 17:21:12 -04:00

83 lines
3.2 KiB
C++

#include "ApiServerInterop.h"
#include "lib/quickbus/quickbus.h"
#include "lib/logging/logging.h"
namespace bts {
namespace api {
// defined in ApiClientInterop.h
std::string base_topic(const char* type_name, const char* service_qualifier);
bts::qbus::RPCServiceName rpc_topic(const std::string& base_topic);
bts::qbus::Topic stream_topic(const std::string& base_topic, const char* method_and_qualifier);
struct ApiServerCore {
ApiServerCore(Quickbus& qbus, const std::string topic, const qbus::OnRPCRequest& handler) :
qbus(qbus),
topic(topic),
rpc(qbus, rpc_topic(topic), handler)
{}
Quickbus& qbus;
std::string topic;
qbus::RPCServer rpc;
};
BTS_EXPORT ApiServerCore* api_server_create(Quickbus* pbus, const char* type_name, const char* service_qualifier, raw_rpc_request_callback cb, void* extra) {
bts_assert(pbus);
// Invalid characters in qualifier: +
for (auto ch : { '+', '_' }) {
bts_assert(strchr(service_qualifier, ch) == nullptr);
}
auto service_name = base_topic(type_name, service_qualifier);
LOG(Api,Info,"create server: {}",service_name);
return new ApiServerCore(*pbus, service_name, [=](qbus::RPCRequestPtr const& req, qbus::ReplyHandler const& reply) {
// Extend the lifetime of the ReplyHandler by moving it to the heap
qbus::ReplyHandler* phandler = new qbus::ReplyHandler(std::move(reply));
LOG(Api,Info,"Received rpc request: {}",reinterpret_cast<intptr_t>(phandler));
cb((uint8_t*)(req->value().c_str()), req->value().size(), reinterpret_cast<ReplyHandler*>(phandler), extra);
});
}
BTS_EXPORT void api_server_call_callback(ReplyHandler** ppvhandler, const uint8_t* buffer, int length) {
bts_assert(ppvhandler);
bts_assert(*ppvhandler);
LOG(Api,Info,"Send rpc reply: {}",reinterpret_cast<intptr_t>(*ppvhandler));
qbus::ReplyHandler** pphandler = reinterpret_cast<qbus::ReplyHandler**>(ppvhandler);
std::string reply_buffer((const char*)buffer, length);
qbus::RPCReplyPtr replyptr = std::make_shared<qbus::RPCReply>(move(reply_buffer));
(**pphandler)(replyptr);
delete (*pphandler);
*pphandler = nullptr;
}
BTS_EXPORT TableHandle api_server_create_table(ApiServerCore* pserver, const char* method_and_qualifier) {
bts_assert(pserver);
auto topic = stream_topic(pserver->topic, method_and_qualifier);
LOG(Api,Info,"Create table: {}",topic.value());
return new qbus::TablePublisher(pserver->qbus, topic);
}
BTS_EXPORT void api_server_update_table(TableHandle htable, StreamUpdate* raw_changes, int change_count) {
if (change_count > 0) {
bts_assert(htable);
qbus::TablePublisher* ptable = reinterpret_cast<qbus::TablePublisher*>(htable);
std::vector<qbus::Change> changes(change_count);
for (int x = 0; x < change_count; ++x) {
StreamUpdate& ch = raw_changes[x];
std::string buffer(ch.buffer, ch.buffer_len);
qbus::RecordPtr record = std::make_shared<qbus::Record>(std::move(buffer));
changes[x] = qbus::Change((qbus::Change::Type)ch.type, qbus::RecordKey(ch.key), record);
}
ptable->publish(std::move(changes));
}
}
BTS_EXPORT void api_server_destroy_table(qbus::TablePublisher* ptable) {
if (ptable) {
ptable->disconnect();
delete ptable;
}
}
} }//namespace