148 lines
6.0 KiB
C++
148 lines
6.0 KiB
C++
#pragma once
|
|
|
|
#include "../core/ApiClientInterop.h"
|
|
#include "Result.h"
|
|
#include "ApiException.h"
|
|
#include "RawUpdate.h"
|
|
#include "ServiceContext.h"
|
|
#include "lib/logging/logging.h"
|
|
|
|
#include <rxcpp/rx.hpp>
|
|
#include <functional>
|
|
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
|
|
|
|
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.ByteSize()+1;
|
|
assert(header_size < 128);
|
|
|
|
std::string request_buffer;
|
|
request_buffer.reserve(header_size + request.ByteSize());
|
|
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<const T>>> subscribe(int method_id, const char* method, const std::string& qualifier) {
|
|
return rxcpp::observable<>::create<RawUpdate<std::shared_ptr<const T>>>([=](rxcpp::subscriber<RawUpdate<std::shared_ptr<const 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<const 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<const 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<const 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
|