web_service: stop using std::future + callback style async
This commit is contained in:
Weiyi Wang
parent
0a4d338ffa
commit
77c1f647cb
23 changed files with 329 additions and 457 deletions
|
|
@ -20,334 +20,128 @@ constexpr int HTTPS_PORT = 443;
|
|||
|
||||
constexpr int TIMEOUT_SECONDS = 30;
|
||||
|
||||
std::string UpdateCoreJWT(bool force_new_token, const std::string& username,
|
||||
const std::string& token) {
|
||||
static std::string jwt;
|
||||
if (jwt.empty() || force_new_token) {
|
||||
if (!username.empty() && !token.empty()) {
|
||||
std::future<Common::WebResult> future =
|
||||
PostJson(Settings::values.web_api_url + "/jwt/internal", username, token);
|
||||
jwt = future.get().returned_data;
|
||||
}
|
||||
}
|
||||
return jwt;
|
||||
}
|
||||
Client::JWTCache Client::jwt_cache{};
|
||||
|
||||
std::unique_ptr<httplib::Client> GetClientFor(const LUrlParser::clParseURL& parsedUrl) {
|
||||
namespace hl = httplib;
|
||||
|
||||
int port;
|
||||
|
||||
std::unique_ptr<hl::Client> cli;
|
||||
|
||||
if (parsedUrl.m_Scheme == "http") {
|
||||
if (!parsedUrl.GetPort(&port)) {
|
||||
port = HTTP_PORT;
|
||||
}
|
||||
return std::make_unique<hl::Client>(parsedUrl.m_Host.c_str(), port, TIMEOUT_SECONDS);
|
||||
} else if (parsedUrl.m_Scheme == "https") {
|
||||
if (!parsedUrl.GetPort(&port)) {
|
||||
port = HTTPS_PORT;
|
||||
}
|
||||
return std::make_unique<hl::SSLClient>(parsedUrl.m_Host.c_str(), port, TIMEOUT_SECONDS);
|
||||
} else {
|
||||
LOG_ERROR(WebService, "Bad URL scheme {}", parsedUrl.m_Scheme);
|
||||
return nullptr;
|
||||
Client::Client(const std::string& host, const std::string& username, const std::string& token)
|
||||
: host(host), username(username), token(token) {
|
||||
if (username == jwt_cache.username && token == jwt_cache.token) {
|
||||
jwt = jwt_cache.jwt;
|
||||
}
|
||||
}
|
||||
|
||||
static Common::WebResult PostJsonAsyncFn(const std::string& url,
|
||||
const LUrlParser::clParseURL& parsed_url,
|
||||
const httplib::Headers& params, const std::string& data,
|
||||
bool is_jwt_requested) {
|
||||
static bool is_first_attempt = true;
|
||||
|
||||
namespace hl = httplib;
|
||||
std::unique_ptr<hl::Client> cli = GetClientFor(parsed_url);
|
||||
|
||||
Common::WebResult Client::GenericJson(const std::string& method, const std::string& path,
|
||||
const std::string& data, const std::string& jwt,
|
||||
const std::string& username, const std::string& token) {
|
||||
if (cli == nullptr) {
|
||||
return Common::WebResult{Common::WebResult::Code::InvalidURL, "URL is invalid"};
|
||||
auto parsedUrl = LUrlParser::clParseURL::ParseURL(host);
|
||||
int port;
|
||||
if (parsedUrl.m_Scheme == "http") {
|
||||
if (!parsedUrl.GetPort(&port)) {
|
||||
port = HTTP_PORT;
|
||||
}
|
||||
cli =
|
||||
std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port, TIMEOUT_SECONDS);
|
||||
} else if (parsedUrl.m_Scheme == "https") {
|
||||
if (!parsedUrl.GetPort(&port)) {
|
||||
port = HTTPS_PORT;
|
||||
}
|
||||
cli = std::make_unique<httplib::SSLClient>(parsedUrl.m_Host.c_str(), port,
|
||||
TIMEOUT_SECONDS);
|
||||
} else {
|
||||
LOG_ERROR(WebService, "Bad URL scheme {}", parsedUrl.m_Scheme);
|
||||
return Common::WebResult{Common::WebResult::Code::InvalidURL, "Bad URL scheme"};
|
||||
}
|
||||
}
|
||||
if (cli == nullptr) {
|
||||
LOG_ERROR(WebService, "Invalid URL {}", host + path);
|
||||
return Common::WebResult{Common::WebResult::Code::InvalidURL, "Invalid URL"};
|
||||
}
|
||||
|
||||
hl::Request request;
|
||||
request.method = "POST";
|
||||
request.path = "/" + parsed_url.m_Path;
|
||||
httplib::Headers params;
|
||||
if (!jwt.empty()) {
|
||||
params = {
|
||||
{std::string("Authorization"), fmt::format("Bearer {}", jwt)},
|
||||
};
|
||||
} else if (!username.empty()) {
|
||||
params = {
|
||||
{std::string("x-username"), username},
|
||||
{std::string("x-token"), token},
|
||||
};
|
||||
}
|
||||
|
||||
params.emplace(std::string("api-version"), std::string(API_VERSION));
|
||||
if (method != "GET") {
|
||||
params.emplace(std::string("Content-Type"), std::string("application/json"));
|
||||
};
|
||||
|
||||
httplib::Request request;
|
||||
request.method = method;
|
||||
request.path = path;
|
||||
request.headers = params;
|
||||
request.body = data;
|
||||
|
||||
hl::Response response;
|
||||
httplib::Response response;
|
||||
|
||||
if (!cli->send(request, response)) {
|
||||
LOG_ERROR(WebService, "POST to {} returned null", url);
|
||||
LOG_ERROR(WebService, "{} to {} returned null", method, host + path);
|
||||
return Common::WebResult{Common::WebResult::Code::LibError, "Null response"};
|
||||
}
|
||||
|
||||
if (response.status >= 400) {
|
||||
LOG_ERROR(WebService, "POST to {} returned error status code: {}", url, response.status);
|
||||
if (response.status == 401 && !is_jwt_requested && is_first_attempt) {
|
||||
LOG_WARNING(WebService, "Requesting new JWT");
|
||||
UpdateCoreJWT(true, Settings::values.citra_username, Settings::values.citra_token);
|
||||
is_first_attempt = false;
|
||||
PostJsonAsyncFn(url, parsed_url, params, data, is_jwt_requested);
|
||||
is_first_attempt = true;
|
||||
}
|
||||
LOG_ERROR(WebService, "{} to {} returned error status code: {}", method, host + path,
|
||||
response.status);
|
||||
return Common::WebResult{Common::WebResult::Code::HttpError,
|
||||
std::to_string(response.status)};
|
||||
}
|
||||
|
||||
auto content_type = response.headers.find("content-type");
|
||||
|
||||
if (content_type == response.headers.end() ||
|
||||
(content_type->second.find("application/json") == std::string::npos &&
|
||||
content_type->second.find("text/html; charset=utf-8") == std::string::npos)) {
|
||||
LOG_ERROR(WebService, "POST to {} returned wrong content: {}", url, content_type->second);
|
||||
if (content_type == response.headers.end()) {
|
||||
LOG_ERROR(WebService, "{} to {} returned no content", method, host + path);
|
||||
return Common::WebResult{Common::WebResult::Code::WrongContent, ""};
|
||||
}
|
||||
|
||||
if (content_type->second.find("application/json") == std::string::npos &&
|
||||
content_type->second.find("text/html; charset=utf-8") == std::string::npos) {
|
||||
LOG_ERROR(WebService, "{} to {} returned wrong content: {}", method, host + path,
|
||||
content_type->second);
|
||||
return Common::WebResult{Common::WebResult::Code::WrongContent, "Wrong content"};
|
||||
}
|
||||
return Common::WebResult{Common::WebResult::Code::Success, "", response.body};
|
||||
}
|
||||
|
||||
std::future<Common::WebResult> PostJson(const std::string& url, const std::string& data,
|
||||
bool allow_anonymous) {
|
||||
|
||||
using lup = LUrlParser::clParseURL;
|
||||
namespace hl = httplib;
|
||||
|
||||
lup parsedUrl = lup::ParseURL(url);
|
||||
|
||||
if (url.empty() || !parsedUrl.IsValid()) {
|
||||
LOG_ERROR(WebService, "URL is invalid");
|
||||
return std::async(std::launch::deferred, [] {
|
||||
return Common::WebResult{Common::WebResult::Code::InvalidURL, "URL is invalid"};
|
||||
});
|
||||
void Client::UpdateJWT() {
|
||||
if (!username.empty() && !token.empty()) {
|
||||
auto result = GenericJson("POST", "/jwt/internal", "", "", username, token);
|
||||
if (result.result_code != Common::WebResult::Code::Success) {
|
||||
LOG_ERROR(WebService, "UpdateJWT failed");
|
||||
} else {
|
||||
jwt_cache.username = username;
|
||||
jwt_cache.token = token;
|
||||
jwt_cache.jwt = jwt = result.returned_data;
|
||||
}
|
||||
}
|
||||
|
||||
const std::string jwt =
|
||||
UpdateCoreJWT(false, Settings::values.citra_username, Settings::values.citra_token);
|
||||
|
||||
const bool are_credentials_provided{!jwt.empty()};
|
||||
if (!allow_anonymous && !are_credentials_provided) {
|
||||
LOG_ERROR(WebService, "Credentials must be provided for authenticated requests");
|
||||
return std::async(std::launch::deferred, [] {
|
||||
return Common::WebResult{Common::WebResult::Code::CredentialsMissing,
|
||||
"Credentials needed"};
|
||||
});
|
||||
}
|
||||
|
||||
// Built request header
|
||||
hl::Headers params;
|
||||
if (are_credentials_provided) {
|
||||
// Authenticated request if credentials are provided
|
||||
params = {{std::string("Authorization"), fmt::format("Bearer {}", jwt)},
|
||||
{std::string("api-version"), std::string(API_VERSION)},
|
||||
{std::string("Content-Type"), std::string("application/json")}};
|
||||
} else {
|
||||
// Otherwise, anonymous request
|
||||
params = {{std::string("api-version"), std::string(API_VERSION)},
|
||||
{std::string("Content-Type"), std::string("application/json")}};
|
||||
}
|
||||
|
||||
// Post JSON asynchronously
|
||||
return std::async(std::launch::async, PostJsonAsyncFn, url, parsedUrl, params, data, false);
|
||||
}
|
||||
|
||||
std::future<Common::WebResult> PostJson(const std::string& url, const std::string& username,
|
||||
const std::string& token) {
|
||||
using lup = LUrlParser::clParseURL;
|
||||
namespace hl = httplib;
|
||||
|
||||
lup parsedUrl = lup::ParseURL(url);
|
||||
|
||||
if (url.empty() || !parsedUrl.IsValid()) {
|
||||
LOG_ERROR(WebService, "URL is invalid");
|
||||
return std::async(std::launch::deferred, [] {
|
||||
return Common::WebResult{Common::WebResult::Code::InvalidURL, ""};
|
||||
});
|
||||
Common::WebResult Client::GenericJson(const std::string& method, const std::string& path,
|
||||
const std::string& data, bool allow_anonymous) {
|
||||
if (jwt.empty()) {
|
||||
UpdateJWT();
|
||||
}
|
||||
|
||||
const bool are_credentials_provided{!token.empty() && !username.empty()};
|
||||
if (!are_credentials_provided) {
|
||||
if (jwt.empty() && !allow_anonymous) {
|
||||
LOG_ERROR(WebService, "Credentials must be provided for authenticated requests");
|
||||
return std::async(std::launch::deferred, [] {
|
||||
return Common::WebResult{Common::WebResult::Code::CredentialsMissing, ""};
|
||||
});
|
||||
return Common::WebResult{Common::WebResult::Code::CredentialsMissing, "Credentials needed"};
|
||||
}
|
||||
|
||||
// Built request header
|
||||
hl::Headers params;
|
||||
if (are_credentials_provided) {
|
||||
// Authenticated request if credentials are provided
|
||||
params = {{std::string("x-username"), username},
|
||||
{std::string("x-token"), token},
|
||||
{std::string("api-version"), std::string(API_VERSION)},
|
||||
{std::string("Content-Type"), std::string("application/json")}};
|
||||
} else {
|
||||
// Otherwise, anonymous request
|
||||
params = {{std::string("api-version"), std::string(API_VERSION)},
|
||||
{std::string("Content-Type"), std::string("application/json")}};
|
||||
auto result = GenericJson(method, path, data, jwt);
|
||||
if (result.result_string == "401") {
|
||||
// Try again with new JWT
|
||||
UpdateJWT();
|
||||
result = GenericJson(method, path, data, jwt);
|
||||
}
|
||||
|
||||
// Post JSON asynchronously
|
||||
return std::async(std::launch::async, PostJsonAsyncFn, url, parsedUrl, params, "", true);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
std::future<T> GetJson(std::function<T(const std::string&)> func, const std::string& url,
|
||||
bool allow_anonymous) {
|
||||
static bool is_first_attempt = true;
|
||||
|
||||
using lup = LUrlParser::clParseURL;
|
||||
namespace hl = httplib;
|
||||
|
||||
lup parsedUrl = lup::ParseURL(url);
|
||||
|
||||
if (url.empty() || !parsedUrl.IsValid()) {
|
||||
LOG_ERROR(WebService, "URL is invalid");
|
||||
return std::async(std::launch::deferred, [func{std::move(func)}]() { return func(""); });
|
||||
}
|
||||
|
||||
const std::string jwt =
|
||||
UpdateCoreJWT(false, Settings::values.citra_username, Settings::values.citra_token);
|
||||
|
||||
const bool are_credentials_provided{!jwt.empty()};
|
||||
if (!allow_anonymous && !are_credentials_provided) {
|
||||
LOG_ERROR(WebService, "Credentials must be provided for authenticated requests");
|
||||
return std::async(std::launch::deferred, [func{std::move(func)}]() { return func(""); });
|
||||
}
|
||||
|
||||
// Built request header
|
||||
hl::Headers params;
|
||||
if (are_credentials_provided) {
|
||||
params = {{std::string("Authorization"), fmt::format("Bearer {}", jwt)},
|
||||
{std::string("api-version"), std::string(API_VERSION)}};
|
||||
} else {
|
||||
// Otherwise, anonymous request
|
||||
params = {{std::string("api-version"), std::string(API_VERSION)}};
|
||||
}
|
||||
|
||||
// Get JSON asynchronously
|
||||
return std::async(std::launch::async, [func, url, parsedUrl, params, allow_anonymous] {
|
||||
std::unique_ptr<hl::Client> cli = GetClientFor(parsedUrl);
|
||||
|
||||
if (cli == nullptr) {
|
||||
return func("");
|
||||
}
|
||||
|
||||
hl::Request request;
|
||||
request.method = "GET";
|
||||
request.path = "/" + parsedUrl.m_Path;
|
||||
request.headers = params;
|
||||
|
||||
hl::Response response;
|
||||
|
||||
if (!cli->send(request, response)) {
|
||||
LOG_ERROR(WebService, "GET to {} returned null", url);
|
||||
return func("");
|
||||
}
|
||||
|
||||
if (response.status >= 400) {
|
||||
LOG_ERROR(WebService, "GET to {} returned error status code: {}", url, response.status);
|
||||
if (response.status == 401 && is_first_attempt) {
|
||||
LOG_WARNING(WebService, "Requesting new JWT");
|
||||
UpdateCoreJWT(true, Settings::values.citra_username, Settings::values.citra_token);
|
||||
is_first_attempt = false;
|
||||
GetJson(func, url, allow_anonymous);
|
||||
is_first_attempt = true;
|
||||
}
|
||||
return func("");
|
||||
}
|
||||
|
||||
auto content_type = response.headers.find("content-type");
|
||||
|
||||
if (content_type == response.headers.end() ||
|
||||
content_type->second.find("application/json") == std::string::npos) {
|
||||
LOG_ERROR(WebService, "GET to {} returned wrong content: {}", url,
|
||||
content_type->second);
|
||||
return func("");
|
||||
}
|
||||
|
||||
return func(response.body);
|
||||
});
|
||||
}
|
||||
|
||||
template std::future<bool> GetJson(std::function<bool(const std::string&)> func,
|
||||
const std::string& url, bool allow_anonymous);
|
||||
template std::future<AnnounceMultiplayerRoom::RoomList> GetJson(
|
||||
std::function<AnnounceMultiplayerRoom::RoomList(const std::string&)> func,
|
||||
const std::string& url, bool allow_anonymous);
|
||||
|
||||
void DeleteJson(const std::string& url, const std::string& data) {
|
||||
static bool is_first_attempt = true;
|
||||
|
||||
using lup = LUrlParser::clParseURL;
|
||||
namespace hl = httplib;
|
||||
|
||||
lup parsedUrl = lup::ParseURL(url);
|
||||
|
||||
if (url.empty() || !parsedUrl.IsValid()) {
|
||||
LOG_ERROR(WebService, "URL is invalid");
|
||||
return;
|
||||
}
|
||||
|
||||
const std::string jwt =
|
||||
UpdateCoreJWT(false, Settings::values.citra_username, Settings::values.citra_token);
|
||||
|
||||
const bool are_credentials_provided{!jwt.empty()};
|
||||
if (!are_credentials_provided) {
|
||||
LOG_ERROR(WebService, "Credentials must be provided for authenticated requests");
|
||||
return;
|
||||
}
|
||||
|
||||
// Built request header
|
||||
hl::Headers params = {{std::string("Authorization"), fmt::format("Bearer {}", jwt)},
|
||||
{std::string("api-version"), std::string(API_VERSION)},
|
||||
{std::string("Content-Type"), std::string("application/json")}};
|
||||
|
||||
// Delete JSON asynchronously
|
||||
std::async(std::launch::async, [url, parsedUrl, params, data] {
|
||||
std::unique_ptr<hl::Client> cli = GetClientFor(parsedUrl);
|
||||
|
||||
if (cli == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
hl::Request request;
|
||||
request.method = "DELETE";
|
||||
request.path = "/" + parsedUrl.m_Path;
|
||||
request.headers = params;
|
||||
request.body = data;
|
||||
|
||||
hl::Response response;
|
||||
|
||||
if (!cli->send(request, response)) {
|
||||
LOG_ERROR(WebService, "DELETE to {} returned null", url);
|
||||
return;
|
||||
}
|
||||
|
||||
if (response.status >= 400) {
|
||||
LOG_ERROR(WebService, "DELETE to {} returned error status code: {}", url,
|
||||
response.status);
|
||||
if (response.status == 401 && is_first_attempt) {
|
||||
LOG_WARNING(WebService, "Requesting new JWT");
|
||||
UpdateCoreJWT(true, Settings::values.citra_username, Settings::values.citra_token);
|
||||
is_first_attempt = false;
|
||||
DeleteJson(url, data);
|
||||
is_first_attempt = true;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
auto content_type = response.headers.find("content-type");
|
||||
|
||||
if (content_type == response.headers.end() ||
|
||||
content_type->second.find("application/json") == std::string::npos) {
|
||||
LOG_ERROR(WebService, "DELETE to {} returned wrong content: {}", url,
|
||||
content_type->second);
|
||||
return;
|
||||
}
|
||||
|
||||
return;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
} // namespace WebService
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue