#include "ApiGateway.h" #include "lib/logging/logging.h" #include "lib/api/public/ApiUtils.h" #include "lib/api/core/ApiClientInterop.h" #include "lib/api/services/UserService.client.pb.h" #include "lib/utils/bts_assert.h" #include #include #include using namespace bts::api::gateway; namespace bts { namespace http { struct ApiGatewayImpl { std::mutex _m; const api::ServiceContext& _sc; api::user::UserService _logon; std::unordered_map _apiclient; std::vector _subscriptions; ApiGatewayImpl(const api::ServiceContext& ctx) : _m(), _sc(ctx), _logon(ctx.locate()), _apiclient(), _subscriptions() { } void handle_login(const GatewayLogin& login, const Responder& respond) { LOG(Api,Info, "Logon request for {}", login.username()); api::user::AuthenticateLoginRequest alr; alr.set_login(login.username()); alr.set_password(login.password()); _logon.authenticate_login(alr, [respond](const api::Result& logon_response) { GatewayResponse resp; resp.mutable_logon()->set_is_valid(false); if (logon_response) { if (logon_response.result()->is_valid()) { resp.mutable_logon()->set_is_valid(true); resp.mutable_logon()->set_token(logon_response.result()->token().token()); } else { resp.mutable_logon()->set_reason(logon_response.result()->reason()); } } else { resp.mutable_logon()->set_reason(logon_response.error_message()); } respond(resp); }); } void error(const Responder& r, const std::string msg) { GatewayResponse response; response.set_error(msg); r(response); } void handle_call(const GatewayCallHeader& header, const std::string& body, const Responder& r) { std::lock_guard lock(_m); if (header.service_type().empty()) { error(r, "Invalid service name"); return; } auto key = header.service_type() + header.service_qualifier(); // create the api_client if needed auto iter = _apiclient.find(key); api::ApiClient* pclient = nullptr; if (iter == _apiclient.end()) { pclient = api::api_client_create(&_sc.bus(), header.service_type().c_str(), header.service_qualifier().c_str()); _apiclient.insert(std::make_pair(key, pclient)); } else { pclient = iter->second; } // Form the api request buffer api::RequestHeader api_header; api_header.set_method(header.method()); api_header.set_request_id(header.request_id()); //todo: token int header_size = 1 + api_header.ByteSize(); bts_assert(header_size < 128); std::string buffer; buffer.reserve(header_size + body.size()); buffer += (char)header_size; api_header.AppendToString(&buffer); buffer += body; // call send Responder* presponder = new Responder(move(r)); api_client_send(pclient, buffer.c_str(), buffer.size(), [](const char* buffer, size_t length, void* extra) { // buffer = [size][ResponseHeader][Payload]. GatewayResponse response; response.set_call_result(buffer, length); LOG(Api,Info, "Gateway Result: {}", api::toJSON(response)); // in response send to client const Responder* r = static_cast(extra); if (r != nullptr) { (*r)(response); delete r; } }, presponder); } // void handle_subscribe() // void handle_unsubscribe() }; ApiGatewaySession::ApiGatewaySession() : _me() {} ApiGatewaySession::ApiGatewaySession(const api::ServiceContext& ctx) : _me(std::make_unique(ctx)) {} ApiGatewaySession::~ApiGatewaySession(){} void ApiGatewaySession::handle(const api::gateway::GatewayRequest& request, const Responder& reply) { GatewayResponse response; LOG(Api,Info, "Gateway Request: {}", api::toJSON(request)); switch(request.request_case()) { case GatewayRequest::kLogin: _me->handle_login(request.login(), reply); break; case GatewayRequest::kCall: _me->handle_call(request.call(), request.addendum(), reply); break; case GatewayRequest::kSubscribe: case GatewayRequest::kUnsubscribe: case GatewayRequest::REQUEST_NOT_SET: break; } } }}