Merge pull request #1473 from lioncash/cmake

web_service: Make linkage of web_service-related externals and the library private
This commit is contained in:
bunnei 2018-10-15 21:33:32 -04:00 committed by GitHub
commit 548958bcaf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 224 additions and 209 deletions

View File

@ -5,6 +5,7 @@
#pragma once #pragma once
#include <string> #include <string>
#include "common/common_types.h"
namespace Common { namespace Common {
struct WebResult { struct WebResult {

View File

@ -400,8 +400,8 @@ create_target_directory_groups(core)
target_link_libraries(core PUBLIC common PRIVATE audio_core video_core) target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn open_source_archives) target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn open_source_archives)
if (ENABLE_WEB_SERVICE) if (ENABLE_WEB_SERVICE)
add_definitions(-DENABLE_WEB_SERVICE) target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)
target_link_libraries(core PUBLIC json-headers web_service) target_link_libraries(core PRIVATE web_service)
endif() endif()
if (ARCHITECTURE_x86_64) if (ARCHITECTURE_x86_64)

View File

@ -2,96 +2,114 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include <thread> #include <json.hpp>
#include "common/assert.h"
#include "common/detached_tasks.h" #include "common/detached_tasks.h"
#include "common/web_result.h"
#include "web_service/telemetry_json.h" #include "web_service/telemetry_json.h"
#include "web_service/web_backend.h" #include "web_service/web_backend.h"
namespace WebService { namespace WebService {
TelemetryJson::TelemetryJson(const std::string& host, const std::string& username, struct TelemetryJson::Impl {
const std::string& token) Impl(std::string host, std::string username, std::string token)
: host(std::move(host)), username(std::move(username)), token(std::move(token)) {} : host{std::move(host)}, username{std::move(username)}, token{std::move(token)} {}
nlohmann::json& TopSection() {
return sections[static_cast<u8>(Telemetry::FieldType::None)];
}
const nlohmann::json& TopSection() const {
return sections[static_cast<u8>(Telemetry::FieldType::None)];
}
template <class T>
void Serialize(Telemetry::FieldType type, const std::string& name, T value) {
sections[static_cast<u8>(type)][name] = value;
}
void SerializeSection(Telemetry::FieldType type, const std::string& name) {
TopSection()[name] = sections[static_cast<unsigned>(type)];
}
nlohmann::json output;
std::array<nlohmann::json, 7> sections;
std::string host;
std::string username;
std::string token;
};
TelemetryJson::TelemetryJson(std::string host, std::string username, std::string token)
: impl{std::make_unique<Impl>(std::move(host), std::move(username), std::move(token))} {}
TelemetryJson::~TelemetryJson() = default; TelemetryJson::~TelemetryJson() = default;
template <class T>
void TelemetryJson::Serialize(Telemetry::FieldType type, const std::string& name, T value) {
sections[static_cast<u8>(type)][name] = value;
}
void TelemetryJson::SerializeSection(Telemetry::FieldType type, const std::string& name) {
TopSection()[name] = sections[static_cast<unsigned>(type)];
}
void TelemetryJson::Visit(const Telemetry::Field<bool>& field) { void TelemetryJson::Visit(const Telemetry::Field<bool>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<double>& field) { void TelemetryJson::Visit(const Telemetry::Field<double>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<float>& field) { void TelemetryJson::Visit(const Telemetry::Field<float>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<u8>& field) { void TelemetryJson::Visit(const Telemetry::Field<u8>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<u16>& field) { void TelemetryJson::Visit(const Telemetry::Field<u16>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<u32>& field) { void TelemetryJson::Visit(const Telemetry::Field<u32>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<u64>& field) { void TelemetryJson::Visit(const Telemetry::Field<u64>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<s8>& field) { void TelemetryJson::Visit(const Telemetry::Field<s8>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<s16>& field) { void TelemetryJson::Visit(const Telemetry::Field<s16>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<s32>& field) { void TelemetryJson::Visit(const Telemetry::Field<s32>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<s64>& field) { void TelemetryJson::Visit(const Telemetry::Field<s64>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<std::string>& field) { void TelemetryJson::Visit(const Telemetry::Field<std::string>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue());
} }
void TelemetryJson::Visit(const Telemetry::Field<const char*>& field) { void TelemetryJson::Visit(const Telemetry::Field<const char*>& field) {
Serialize(field.GetType(), field.GetName(), std::string(field.GetValue())); impl->Serialize(field.GetType(), field.GetName(), std::string(field.GetValue()));
} }
void TelemetryJson::Visit(const Telemetry::Field<std::chrono::microseconds>& field) { void TelemetryJson::Visit(const Telemetry::Field<std::chrono::microseconds>& field) {
Serialize(field.GetType(), field.GetName(), field.GetValue().count()); impl->Serialize(field.GetType(), field.GetName(), field.GetValue().count());
} }
void TelemetryJson::Complete() { void TelemetryJson::Complete() {
SerializeSection(Telemetry::FieldType::App, "App"); impl->SerializeSection(Telemetry::FieldType::App, "App");
SerializeSection(Telemetry::FieldType::Session, "Session"); impl->SerializeSection(Telemetry::FieldType::Session, "Session");
SerializeSection(Telemetry::FieldType::Performance, "Performance"); impl->SerializeSection(Telemetry::FieldType::Performance, "Performance");
SerializeSection(Telemetry::FieldType::UserFeedback, "UserFeedback"); impl->SerializeSection(Telemetry::FieldType::UserFeedback, "UserFeedback");
SerializeSection(Telemetry::FieldType::UserConfig, "UserConfig"); impl->SerializeSection(Telemetry::FieldType::UserConfig, "UserConfig");
SerializeSection(Telemetry::FieldType::UserSystem, "UserSystem"); impl->SerializeSection(Telemetry::FieldType::UserSystem, "UserSystem");
auto content = TopSection().dump(); auto content = impl->TopSection().dump();
// Send the telemetry async but don't handle the errors since they were written to the log // Send the telemetry async but don't handle the errors since they were written to the log
Common::DetachedTasks::AddTask( Common::DetachedTasks::AddTask(
[host{this->host}, username{this->username}, token{this->token}, content]() { [host{impl->host}, username{impl->username}, token{impl->token}, content]() {
Client{host, username, token}.PostJson("/telemetry", content, true); Client{host, username, token}.PostJson("/telemetry", content, true);
}); });
} }

View File

@ -4,11 +4,9 @@
#pragma once #pragma once
#include <array> #include <chrono>
#include <string> #include <string>
#include <json.hpp>
#include "common/telemetry.h" #include "common/telemetry.h"
#include "common/web_result.h"
namespace WebService { namespace WebService {
@ -18,8 +16,8 @@ namespace WebService {
*/ */
class TelemetryJson : public Telemetry::VisitorInterface { class TelemetryJson : public Telemetry::VisitorInterface {
public: public:
TelemetryJson(const std::string& host, const std::string& username, const std::string& token); TelemetryJson(std::string host, std::string username, std::string token);
~TelemetryJson(); ~TelemetryJson() override;
void Visit(const Telemetry::Field<bool>& field) override; void Visit(const Telemetry::Field<bool>& field) override;
void Visit(const Telemetry::Field<double>& field) override; void Visit(const Telemetry::Field<double>& field) override;
@ -39,20 +37,8 @@ public:
void Complete() override; void Complete() override;
private: private:
nlohmann::json& TopSection() { struct Impl;
return sections[static_cast<u8>(Telemetry::FieldType::None)]; std::unique_ptr<Impl> impl;
}
template <class T>
void Serialize(Telemetry::FieldType type, const std::string& name, T value);
void SerializeSection(Telemetry::FieldType type, const std::string& name);
nlohmann::json output;
std::array<nlohmann::json, 7> sections;
std::string host;
std::string username;
std::string token;
}; };
} // namespace WebService } // namespace WebService

View File

@ -3,6 +3,7 @@
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include <json.hpp> #include <json.hpp>
#include "common/web_result.h"
#include "web_service/verify_login.h" #include "web_service/verify_login.h"
#include "web_service/web_backend.h" #include "web_service/web_backend.h"

View File

@ -3,9 +3,11 @@
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include <cstdlib> #include <cstdlib>
#include <mutex>
#include <string> #include <string>
#include <thread>
#include <LUrlParser.h> #include <LUrlParser.h>
#include <httplib.h>
#include "common/common_types.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "common/web_result.h" #include "common/web_result.h"
#include "core/settings.h" #include "core/settings.h"
@ -20,19 +22,47 @@ constexpr u32 HTTPS_PORT = 443;
constexpr u32 TIMEOUT_SECONDS = 30; constexpr u32 TIMEOUT_SECONDS = 30;
Client::JWTCache Client::jwt_cache{}; struct Client::Impl {
Impl(std::string host, std::string username, std::string token)
Client::Client(const std::string& host, const std::string& username, const std::string& token) : host{std::move(host)}, username{std::move(username)}, token{std::move(token)} {
: host(host), username(username), token(token) {
std::lock_guard<std::mutex> lock(jwt_cache.mutex); std::lock_guard<std::mutex> lock(jwt_cache.mutex);
if (username == jwt_cache.username && token == jwt_cache.token) { if (this->username == jwt_cache.username && this->token == jwt_cache.token) {
jwt = jwt_cache.jwt; jwt = jwt_cache.jwt;
} }
} }
Common::WebResult Client::GenericJson(const std::string& method, const std::string& path, /// A generic function handles POST, GET and DELETE request together
const std::string& data, const std::string& jwt, Common::WebResult GenericJson(const std::string& method, const std::string& path,
const std::string& username, const std::string& token) { const std::string& data, bool allow_anonymous) {
if (jwt.empty()) {
UpdateJWT();
}
if (jwt.empty() && !allow_anonymous) {
LOG_ERROR(WebService, "Credentials must be provided for authenticated requests");
return Common::WebResult{Common::WebResult::Code::CredentialsMissing,
"Credentials needed"};
}
auto result = GenericJson(method, path, data, jwt);
if (result.result_string == "401") {
// Try again with new JWT
UpdateJWT();
result = GenericJson(method, path, data, jwt);
}
return result;
}
/**
* A generic function with explicit authentication method specified
* JWT is used if the jwt parameter is not empty
* username + token is used if jwt is empty but username and token are not empty
* anonymous if all of jwt, username and token are empty
*/
Common::WebResult 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) { if (cli == nullptr) {
auto parsedUrl = LUrlParser::clParseURL::ParseURL(host); auto parsedUrl = LUrlParser::clParseURL::ParseURL(host);
int port; int port;
@ -40,8 +70,8 @@ Common::WebResult Client::GenericJson(const std::string& method, const std::stri
if (!parsedUrl.GetPort(&port)) { if (!parsedUrl.GetPort(&port)) {
port = HTTP_PORT; port = HTTP_PORT;
} }
cli = cli = std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port,
std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port, TIMEOUT_SECONDS); TIMEOUT_SECONDS);
} else if (parsedUrl.m_Scheme == "https") { } else if (parsedUrl.m_Scheme == "https") {
if (!parsedUrl.GetPort(&port)) { if (!parsedUrl.GetPort(&port)) {
port = HTTPS_PORT; port = HTTPS_PORT;
@ -70,7 +100,8 @@ Common::WebResult Client::GenericJson(const std::string& method, const std::stri
}; };
} }
params.emplace(std::string("api-version"), std::string(API_VERSION.begin(), API_VERSION.end())); params.emplace(std::string("api-version"),
std::string(API_VERSION.begin(), API_VERSION.end()));
if (method != "GET") { if (method != "GET") {
params.emplace(std::string("Content-Type"), std::string("application/json")); params.emplace(std::string("Content-Type"), std::string("application/json"));
}; };
@ -109,10 +140,14 @@ Common::WebResult Client::GenericJson(const std::string& method, const std::stri
return Common::WebResult{Common::WebResult::Code::WrongContent, "Wrong content"}; return Common::WebResult{Common::WebResult::Code::WrongContent, "Wrong content"};
} }
return Common::WebResult{Common::WebResult::Code::Success, "", response.body}; return Common::WebResult{Common::WebResult::Code::Success, "", response.body};
} }
// Retrieve a new JWT from given username and token
void UpdateJWT() {
if (username.empty() || token.empty()) {
return;
}
void Client::UpdateJWT() {
if (!username.empty() && !token.empty()) {
auto result = GenericJson("POST", "/jwt/internal", "", "", username, token); auto result = GenericJson("POST", "/jwt/internal", "", "", username, token);
if (result.result_code != Common::WebResult::Code::Success) { if (result.result_code != Common::WebResult::Code::Success) {
LOG_ERROR(WebService, "UpdateJWT failed"); LOG_ERROR(WebService, "UpdateJWT failed");
@ -123,27 +158,39 @@ void Client::UpdateJWT() {
jwt_cache.jwt = jwt = result.returned_data; jwt_cache.jwt = jwt = result.returned_data;
} }
} }
std::string host;
std::string username;
std::string token;
std::string jwt;
std::unique_ptr<httplib::Client> cli;
struct JWTCache {
std::mutex mutex;
std::string username;
std::string token;
std::string jwt;
};
static inline JWTCache jwt_cache;
};
Client::Client(std::string host, std::string username, std::string token)
: impl{std::make_unique<Impl>(std::move(host), std::move(username), std::move(token))} {}
Client::~Client() = default;
Common::WebResult Client::PostJson(const std::string& path, const std::string& data,
bool allow_anonymous) {
return impl->GenericJson("POST", path, data, allow_anonymous);
} }
Common::WebResult Client::GenericJson(const std::string& method, const std::string& path, Common::WebResult Client::GetJson(const std::string& path, bool allow_anonymous) {
const std::string& data, bool allow_anonymous) { return impl->GenericJson("GET", path, "", allow_anonymous);
if (jwt.empty()) { }
UpdateJWT();
}
if (jwt.empty() && !allow_anonymous) { Common::WebResult Client::DeleteJson(const std::string& path, const std::string& data,
LOG_ERROR(WebService, "Credentials must be provided for authenticated requests"); bool allow_anonymous) {
return Common::WebResult{Common::WebResult::Code::CredentialsMissing, "Credentials needed"}; return impl->GenericJson("DELETE", path, data, allow_anonymous);
}
auto result = GenericJson(method, path, data, jwt);
if (result.result_string == "401") {
// Try again with new JWT
UpdateJWT();
result = GenericJson(method, path, data, jwt);
}
return result;
} }
} // namespace WebService } // namespace WebService

View File

@ -4,23 +4,19 @@
#pragma once #pragma once
#include <functional> #include <memory>
#include <mutex>
#include <string> #include <string>
#include <tuple>
#include <httplib.h>
#include "common/common_types.h"
#include "common/web_result.h"
namespace httplib { namespace Common {
class Client; struct WebResult;
} }
namespace WebService { namespace WebService {
class Client { class Client {
public: public:
Client(const std::string& host, const std::string& username, const std::string& token); Client(std::string host, std::string username, std::string token);
~Client();
/** /**
* Posts JSON to the specified path. * Posts JSON to the specified path.
@ -30,9 +26,7 @@ public:
* @return the result of the request. * @return the result of the request.
*/ */
Common::WebResult PostJson(const std::string& path, const std::string& data, Common::WebResult PostJson(const std::string& path, const std::string& data,
bool allow_anonymous) { bool allow_anonymous);
return GenericJson("POST", path, data, allow_anonymous);
}
/** /**
* Gets JSON from the specified path. * Gets JSON from the specified path.
@ -40,9 +34,7 @@ public:
* @param allow_anonymous If true, allow anonymous unauthenticated requests. * @param allow_anonymous If true, allow anonymous unauthenticated requests.
* @return the result of the request. * @return the result of the request.
*/ */
Common::WebResult GetJson(const std::string& path, bool allow_anonymous) { Common::WebResult GetJson(const std::string& path, bool allow_anonymous);
return GenericJson("GET", path, "", allow_anonymous);
}
/** /**
* Deletes JSON to the specified path. * Deletes JSON to the specified path.
@ -52,41 +44,11 @@ public:
* @return the result of the request. * @return the result of the request.
*/ */
Common::WebResult DeleteJson(const std::string& path, const std::string& data, Common::WebResult DeleteJson(const std::string& path, const std::string& data,
bool allow_anonymous) { bool allow_anonymous);
return GenericJson("DELETE", path, data, allow_anonymous);
}
private: private:
/// A generic function handles POST, GET and DELETE request together struct Impl;
Common::WebResult GenericJson(const std::string& method, const std::string& path, std::unique_ptr<Impl> impl;
const std::string& data, bool allow_anonymous);
/**
* A generic function with explicit authentication method specified
* JWT is used if the jwt parameter is not empty
* username + token is used if jwt is empty but username and token are not empty
* anonymous if all of jwt, username and token are empty
*/
Common::WebResult 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 = "");
// Retrieve a new JWT from given username and token
void UpdateJWT();
std::string host;
std::string username;
std::string token;
std::string jwt;
std::unique_ptr<httplib::Client> cli;
struct JWTCache {
std::mutex mutex;
std::string username;
std::string token;
std::string jwt;
};
static JWTCache jwt_cache;
}; };
} // namespace WebService } // namespace WebService