170 lines
5.5 KiB
C++
170 lines
5.5 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/api/services/AdminService.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,Diag, "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,Diag, "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;
|
|
}
|
|
}
|
|
|
|
std::string get_server_info(const api::ServiceContext& ctx) {
|
|
using namespace api::admin;
|
|
using std::endl;
|
|
api::VoidMessage vod;
|
|
AdminService admin(ctx.locate<api::admin::AdminService>());
|
|
auto response = admin.get_admin_data(vod, 100);
|
|
|
|
std::stringstream ss;
|
|
ss << "{" << endl;
|
|
|
|
if (response.success()) {
|
|
ss << " \"users\": [" << endl;
|
|
for (const auto& user : response.result()->users()) {
|
|
ss << " ";
|
|
if (&user != &response.result()->users()[0]) ss << ",";
|
|
ss << "{ ";
|
|
ss << "\"name\": \"" << user.name() << "\", ";
|
|
ss << "\"operator_id\": \"" << user.user_data().exchange_user_data().cme_data().operator_id() << "\"";
|
|
ss << "}" << endl;
|
|
}
|
|
ss << " ]" << endl;
|
|
}
|
|
|
|
ss << "}" << endl;
|
|
|
|
return ss.str();
|
|
}
|
|
|
|
}} |