Files
spark/src/lib/api/public/ClientChannel.h
T
2019-05-01 14:03:34 -04:00

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