#pragma once #include "../core/ApiClientInterop.h" #include "ApiException.h" #include "RawUpdate.h" #include "Result.h" #include "ServiceContext.h" #include "lib/logging/logging.h" #include #include #include namespace bts { namespace api { template std::shared_ptr deserialize(const char *buffer, size_t length) { google::protobuf::io::ArrayInputStream stream(buffer, length); auto item = std::make_shared(); 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 void send( int method_id, const Request &request, std::function)> 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(); google::protobuf::io::ArrayInputStream data_stream( response_buffer + header_size, response_size - header_size); if (response->ParseFromZeroCopyStream(&data_stream)) { on_response(Result(move(response))); return; } } else { on_response(Result((ApiError)header.code())); } } else { on_response(Result(ApiError::UNEXPECTED_RESPONSE)); } }); } template rxcpp::observable>> subscribe(int method_id, const char *method, const std::string &qualifier) { return rxcpp::observable<>::create>>( [=](rxcpp::subscriber>> observer) { StreamAccessRequest request; request.set_qualifier(qualifier); send( method_id, request, [=](const Result &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> added_items, changed_items; std::vector added_keys, changed_keys, removed_keys; for (std::size_t x = 0; x < static_cast(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( change.buffer, change.buffer_len)); changed_keys.push_back(change.key); break; case StreamUpdate::CREATE: added_items.push_back(deserialize( change.buffer, change.buffer_len)); added_keys.push_back(change.key); break; } } observer.on_next( RawUpdate>( 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>::Reset()); } first_update = false; } }; observer.add( subscribe_core(method, qualifier.c_str(), cb)); } }); }); } virtual bool is_sync_call_ok() = 0; protected: typedef std::function OnReply; typedef std::function Unsubscribe; typedef std::function 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