174 lines
7.0 KiB
C++
174 lines
7.0 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 (std::size_t x = 0;
|
|
x < static_cast<std::size_t>(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
|