Files
spark/src/lib/api/public/ClientChannel.h
T

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