Files
spark/src/server/sparkd/http/ApiGateway.cpp
T

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();
}
}}