A lot of server-side changes were just merged as part of the Brandon project (crypto). Many of those changes were in libspark (a lib on which both the client and server depend), and upgrades to its external dependencies. As a result, windows counterparts of several upgraded external libs needed to be similarly upgraded (or added for the first time). These libs include: boost, btree, catch, curl, fmt, nlohmann json, openssl, range, rxcpp, websocketpp This change also makes protobuf generation compatible with python3, and thus eliminates the build's dependency on python2
172 lines
6.9 KiB
C++
172 lines
6.9 KiB
C++
#pragma once
|
|
|
|
#include "../core/ApiClientInterop.h"
|
|
#include "ApiException.h"
|
|
#include "RawUpdate.h"
|
|
#include "Result.h"
|
|
#include "ServiceContext.h"
|
|
#include "lib/logging/logging.h"
|
|
|
|
#include <functional>
|
|
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
|
|
#include <rxcpp/rx.hpp>
|
|
|
|
namespace bts {
|
|
namespace api {
|
|
|
|
template <typename T>
|
|
std::shared_ptr<T> deserialize(const char *buffer, size_t length) {
|
|
google::protobuf::io::ArrayInputStream stream(buffer, length);
|
|
auto item = std::make_shared<T>();
|
|
if (item->ParseFromZeroCopyStream(&stream)) {
|
|
return item;
|
|
}
|
|
LOG(Api, Error,
|
|
"Failed to deserialize proto from api stream. This is likely fatal.");
|
|
return nullptr;
|
|
}
|
|
|
|
class ClientChannel {
|
|
int _id;
|
|
ServiceContext _context;
|
|
|
|
public:
|
|
ClientChannel(const ServiceContext &);
|
|
virtual ~ClientChannel();
|
|
|
|
template <typename Request, typename Response>
|
|
void send(
|
|
int method_id,
|
|
const Request &request,
|
|
std::function<void(const Result<Response>)> on_response) {
|
|
RequestHeader header;
|
|
header.set_method(method_id);
|
|
header.set_request_id(++_id);
|
|
auto ptoken = _context.token();
|
|
if (ptoken)
|
|
header.mutable_token()->CopyFrom(*ptoken);
|
|
int header_size = header.ByteSizeLong() + 1;
|
|
assert(header_size < 128);
|
|
|
|
std::string request_buffer;
|
|
request_buffer.reserve(header_size + request.ByteSizeLong());
|
|
request_buffer += (char)(header_size);
|
|
bool success = header.AppendToString(&request_buffer);
|
|
success = success && request.AppendToString(&request_buffer);
|
|
if (!success)
|
|
throw ApiException("Failed to serialize request.");
|
|
|
|
send_core(
|
|
request_buffer,
|
|
[on_response](const char *response_buffer, size_t response_size) {
|
|
assert(response_size > 1);
|
|
int header_size = response_buffer[0];
|
|
assert(header_size > 0);
|
|
google::protobuf::io::ArrayInputStream header_stream(
|
|
response_buffer + 1, header_size - 1);
|
|
ResponseHeader header;
|
|
if (header.ParseFromZeroCopyStream(&header_stream)) {
|
|
if (header.code() == ApiError::SUCCESS) {
|
|
auto response = std::make_shared<Response>();
|
|
google::protobuf::io::ArrayInputStream data_stream(
|
|
response_buffer + header_size,
|
|
response_size - header_size);
|
|
if (response->ParseFromZeroCopyStream(&data_stream)) {
|
|
on_response(Result<Response>(move(response)));
|
|
return;
|
|
}
|
|
} else {
|
|
on_response(Result<Response>((ApiError)header.code()));
|
|
}
|
|
} else {
|
|
on_response(Result<Response>(ApiError::UNEXPECTED_RESPONSE));
|
|
}
|
|
});
|
|
}
|
|
|
|
template <typename T>
|
|
rxcpp::observable<RawUpdate<std::shared_ptr<T>>>
|
|
subscribe(int method_id, const char *method, const std::string &qualifier) {
|
|
return rxcpp::observable<>::create<RawUpdate<std::shared_ptr<T>>>(
|
|
[=](rxcpp::subscriber<RawUpdate<std::shared_ptr<T>>> observer) {
|
|
StreamAccessRequest request;
|
|
request.set_qualifier(qualifier);
|
|
send<StreamAccessRequest, StreamAccessResponse>(
|
|
method_id, request,
|
|
[=](const Result<StreamAccessResponse> &response) {
|
|
// There is a race on server startup. If the server is not
|
|
// yet we can't return a dead stream if (!response) {
|
|
// observer.on_error(
|
|
// std::make_exception_ptr(
|
|
// ApiException(response.error_message())));
|
|
// }
|
|
if (response && !response.value()->authorized()) {
|
|
observer.on_completed();
|
|
} else {
|
|
bool first_update = true;
|
|
auto cb = [observer, first_update, qualifier](
|
|
EventType event_type,
|
|
const StreamUpdate *changes,
|
|
int change_count) mutable {
|
|
if (event_type == EventType::TABLE_UPDATED) {
|
|
std::vector<std::shared_ptr<T>> added_items,
|
|
changed_items;
|
|
std::vector<int> added_keys, changed_keys,
|
|
removed_keys;
|
|
for (size_t x = 0; x < change_count; ++x) {
|
|
const StreamUpdate &change = changes[x];
|
|
switch (change.type) {
|
|
case StreamUpdate::REMOVE:
|
|
removed_keys.push_back(change.key);
|
|
break;
|
|
case StreamUpdate::REPLACE:
|
|
changed_items.push_back(deserialize<T>(
|
|
change.buffer, change.buffer_len));
|
|
changed_keys.push_back(change.key);
|
|
break;
|
|
case StreamUpdate::CREATE:
|
|
added_items.push_back(deserialize<T>(
|
|
change.buffer, change.buffer_len));
|
|
added_keys.push_back(change.key);
|
|
break;
|
|
}
|
|
}
|
|
observer.on_next(
|
|
RawUpdate<std::shared_ptr<T>>(
|
|
added_items, added_keys, changed_items,
|
|
changed_keys, removed_keys));
|
|
} else if (event_type == EventType::TABLE_CREATED) {
|
|
if (!first_update) {
|
|
observer.on_next(
|
|
RawUpdate<
|
|
std::shared_ptr<T>>::Reset());
|
|
}
|
|
first_update = false;
|
|
}
|
|
};
|
|
observer.add(
|
|
subscribe_core(method, qualifier.c_str(), cb));
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
virtual bool is_sync_call_ok() = 0;
|
|
|
|
protected:
|
|
typedef std::function<void(const char *, size_t)> OnReply;
|
|
typedef std::function<void()> Unsubscribe;
|
|
typedef std::function<void(EventType, const StreamUpdate *, int)>
|
|
OnSubscriptionCB;
|
|
virtual void
|
|
send_core(const std::string &request_buffer, OnReply on_response) = 0;
|
|
virtual Unsubscribe subscribe_core(
|
|
const char *method, const char *qualifier, OnSubscriptionCB cb) = 0;
|
|
|
|
private:
|
|
ClientChannel(const ClientChannel &other); // = delete;
|
|
};
|
|
|
|
} // namespace api
|
|
} // namespace bts
|