141 lines
4.6 KiB
C++
141 lines
4.6 KiB
C++
#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 <vector>
|
|
#include <unordered_map>
|
|
#include <mutex>
|
|
|
|
|
|
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<std::string, api::ApiClient*> _apiclient;
|
|
std::vector<api::TableSubscription> _subscriptions;
|
|
|
|
|
|
ApiGatewayImpl(const api::ServiceContext& ctx) :
|
|
_m(),
|
|
_sc(ctx),
|
|
_logon(ctx.locate<api::user::UserService>()),
|
|
_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<api::user::AuthenticateLoginResponse>& 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<std::mutex> 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<const Responder*>(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<ApiGatewayImpl>(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;
|
|
}
|
|
}
|
|
|
|
}} |