owen/lms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replaced Json parser with a custom one (optims+compact output)

Browse Source
This commit is contained in:
emeric
2023-10-20 15:22:00 +02:00
parent 4562e0368a
commit d86260ba2d
13 changed files with 316 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/subsonic/impl/SubsonicResource.cpp
+2 -1
View File
@@ -290,10 +290,11 @@ namespace API::Subsonic
Response resp{ (itEntryPoint->second.func)(requestContext) };
LMS_LOG(API_SUBSONIC, DEBUG) << "Request " << requestId << " '" << requestPath << "' handled!";
resp.write(response.out(), format);
response.setMimeType(std::string{ ResponseFormatToMimeType(format) });
LMS_LOG(API_SUBSONIC, DEBUG) << "Request " << requestId << " '" << requestPath << "' written!";
LMS_LOG(API_SUBSONIC, DEBUG) << "Request " << requestId << " '" << requestPath << "' handled!";
return;
}
src/libs/subsonic/impl/SubsonicResponse.cpp
+148 -72
View File
@@ -20,12 +20,8 @@
#include "SubsonicResponse.hpp"
#include <cassert>
#include <Wt/Json/Array.h>
#include <Wt/Json/Object.h>
#include <Wt/Json/Value.h>
#include <Wt/Json/Serializer.h>
#include <boost/property_tree/json_parser.hpp>
#include <cmath>
#include <climits>
#include <boost/property_tree/xml_parser.hpp>
#include "utils/Exception.hpp"
@@ -57,59 +53,66 @@ namespace API::Subsonic
_value = value;
}
void Response::Node::setAttribute(std::string_view key, std::string_view value)
void Response::Node::setAttribute(Key key, std::string_view value)
{
_attributes[std::string{ key }] = std::string{ value };
_attributes[key] = std::string{ value };
}
void Response::Node::addChild(const std::string& key, Node node)
void Response::Node::addChild(Key key, Node node)
{
assert(!_value);
_children[key].emplace_back(std::move(node));
assert(_children.find(key) == std::cend(_children));
_children[key] = std::move(node);
}
void Response::Node::createEmptyArrayChild(std::string_view key)
void Response::Node::createEmptyArrayChild(Key key)
{
assert(!_value);
assert(_children.find(key) == std::cend(_children));
_childrenArrays.emplace(key, std::vector<Node>{});
}
void Response::Node::addArrayChild(std::string_view key, Node node)
void Response::Node::addArrayChild(Key key, Node node)
{
assert(!_value);
_childrenArrays[std::string{ key }].emplace_back(std::move(node));
assert(_children.find(key) == std::cend(_children));
_childrenArrays[key].emplace_back(std::move(node));
}
void Response::Node::createEmptyArrayValue(std::string_view key)
void Response::Node::createEmptyArrayValue(Key key)
{
assert(!_value);
assert(_children.find(key) == std::cend(_children));
_childrenValues.emplace(key, ValuesType{});
}
void Response::Node::addArrayValue(std::string_view key, std::string_view value)
void Response::Node::addArrayValue(Key key, std::string_view value)
{
assert(!_value);
auto& values{ _childrenValues[std::string{ key }] };
assert(_children.find(key) == std::cend(_children));
auto& values{ _childrenValues[key] };
values.push_back(std::string{ value });
assert(std::all_of(std::cbegin(values) + 1, std::cend(values), [&](const ValueType& value) {return value.index() == values.front().index();}));
}
void Response::Node::addArrayValue(std::string_view key, long long value)
void Response::Node::addArrayValue(Key key, long long value)
{
assert(!_value);
auto& values{ _childrenValues[std::string{ key }] };
auto& values{ _childrenValues[key] };
values.push_back(value);
assert(std::all_of(std::cbegin(values) + 1, std::cend(values), [&](const ValueType& value) {return value.index() == values.front().index();}));
}
Response::Node& Response::Node::createChild(const std::string& key)
Response::Node& Response::Node::createChild(Key key)
{
_children[key].emplace_back();
return _children[key].back();
assert(!_value);
return _children[key];
}
Response::Node& Response::Node::createArrayChild(const std::string& key)
Response::Node& Response::Node::createArrayChild(Key key)
{
assert(!_value);
assert(_children.find(key) == std::cend(_children));
_childrenArrays[key].emplace_back();
return _childrenArrays[key].back();
}
@@ -152,19 +155,19 @@ namespace API::Subsonic
return response;
}
void Response::addNode(const std::string& key, Node node)
void Response::addNode(Node::Key key, Node node)
{
return _root._children["subsonic-response"].front().addChild(key, std::move(node));
return _root._children["subsonic-response"].addChild(key, std::move(node));
}
Response::Node& Response::createNode(const std::string& key)
Response::Node& Response::createNode(Node::Key key)
{
return _root._children["subsonic-response"].front().createChild(key);
return _root._children["subsonic-response"].createChild(key);
}
Response::Node& Response::createArrayNode(const std::string& key)
Response::Node& Response::createArrayNode(Node::Key key)
{
return _root._children["subsonic-response"].front().createArrayChild(key);
return _root._children["subsonic-response"].createArrayChild(key);
}
void Response::write(std::ostream& os, ResponseFormat format)
@@ -186,16 +189,16 @@ namespace API::Subsonic
{
boost::property_tree::ptree res;
for (auto itAttribute : node._attributes)
for (const auto& [key, value] : node._attributes)
{
if (std::holds_alternative<std::string>(itAttribute.second))
res.put("<xmlattr>." + itAttribute.first, std::get<std::string>(itAttribute.second));
else if (std::holds_alternative<bool>(itAttribute.second))
res.put("<xmlattr>." + itAttribute.first, std::get<bool>(itAttribute.second));
else if (std::holds_alternative<float>(itAttribute.second))
res.put("<xmlattr>." + itAttribute.first, std::get<float>(itAttribute.second));
else if (std::holds_alternative<long long>(itAttribute.second))
res.put("<xmlattr>." + itAttribute.first, std::get<long long>(itAttribute.second));
if (std::holds_alternative<std::string>(value))
res.put("<xmlattr>." + std::string{ key.get() }, std::get<std::string>(value));
else if (std::holds_alternative<bool>(value))
res.put("<xmlattr>." + std::string{ key.get() }, std::get<bool>(value));
else if (std::holds_alternative<float>(value))
res.put("<xmlattr>." + std::string{ key.get() }, std::get<float>(value));
else if (std::holds_alternative<long long>(value))
res.put("<xmlattr>." + std::string{ key.get() }, std::get<long long>(value));
}
auto valueToPropertyTree = [](const Node::ValueType& value)
@@ -215,22 +218,21 @@ namespace API::Subsonic
}
else
{
for (const auto& [key, childNodes] : node._children)
for (const auto& [key, childNode] : node._children)
{
for (const Node& childNode : childNodes)
res.add_child(key, nodeToPropertyTree(childNode));
res.add_child(std::string{ key.get() }, nodeToPropertyTree(childNode));
}
for (const auto& [key, childArrayNodes] : node._childrenArrays)
{
for (const Node& childNode : childArrayNodes)
res.add_child(key, nodeToPropertyTree(childNode));
res.add_child(std::string{ key.get() }, nodeToPropertyTree(childNode));
}
for (const auto& [key, childArrayValues] : node._childrenValues)
{
for (const Response::Node::ValueType& value : childArrayValues)
res.add_child(key, valueToPropertyTree(value));
res.add_child(std::string{ key.get() }, valueToPropertyTree(value));
}
}
@@ -241,63 +243,137 @@ namespace API::Subsonic
boost::property_tree::write_xml(os, root);
}
void Response::writeJSON(std::ostream& os)
void Response::JsonSerializer::serializeNode(std::ostream& os, const Response::Node& node)
{
namespace Json = Wt::Json;
os << '{';
std::function<Json::Object(const Response::Node&)> nodeToJsonObject = [&](const Response::Node& node)
{
Json::Object res;
bool first{ true };
auto valueToJsonValue{ [](const Node::ValueType& value) -> Json::Value
for (const auto& [key, value] : node._attributes)
{
Json::Value res;
std::visit([&](const auto& rawValue)
{
res = Json::Value{ rawValue };
}, value);
return res;
} };
if (!first)
os << ',';
for (auto itAttribute : node._attributes)
res[itAttribute.first] = valueToJsonValue(itAttribute.second);
serializeEscapedString(os, key.get());
os << ':';
serializeValue(os, value);
first = false;
}
if (node._value)
{
res["value"] = valueToJsonValue(*node._value);
if (!first)
os << ',';
os << "value:";
serializeValue(os, *node._value);
first = false;
}
else
{
for (const auto& [key, childNodes] : node._children)
for (const auto& [key, childNode] : node._children)
{
for (const Response::Node& childNode : childNodes)
res[key] = nodeToJsonObject(childNode);
if (!first)
os << ',';
serializeEscapedString(os, key.get());
os << ':';
serializeNode(os, childNode);
first = false;
}
for (const auto& [key, childArrayNodes] : node._childrenArrays)
{
Json::Array array;
for (const Response::Node& childNode : childArrayNodes)
array.emplace_back(nodeToJsonObject(childNode));
if (!first)
os << ',';
res[key] = std::move(array);
serializeEscapedString(os, key.get());
os << ":[";
bool firstChild{ true };
for (const Response::Node& childNode : childArrayNodes)
{
if (!firstChild)
os << ",";
serializeNode(os, childNode);
firstChild = false;
}
os << ']';
first = false;
}
for (const auto& [key, childValues] : node._childrenValues)
{
Json::Array array;
if (!first)
os << ',';
serializeEscapedString(os, key.get());
os << ":[";
bool firstChild{ true };
for (const Node::ValueType& childValue : childValues)
array.emplace_back(valueToJsonValue(childValue));
{
if (!firstChild)
os << ",";
res[key] = std::move(array);
serializeValue(os, childValue);
firstChild = false;
}
os << ']';
first = false;
}
}
return res;
};
os << '}';
}
Json::Object root{ nodeToJsonObject(_root) };
os << Json::serialize(root);
void Response::JsonSerializer::serializeValue(std::ostream& os, const Node::ValueType& value)
{
if (std::holds_alternative<std::string>(value))
{
serializeEscapedString(os, std::get<std::string>(value));
}
else if (std::holds_alternative<bool>(value))
{
os << (std::get<bool>(value) ? "true" : "false");
}
else if (std::holds_alternative<float>(value))
{
const float d{ std::get<float>(value) };
if (std::isnan(d) || std::fabs(d) == std::numeric_limits<float>::infinity())
os << "null";
else
os << d;
}
else if (std::holds_alternative<long long>(value))
{
os << std::get<long long>(value);
}
else
{
assert(false);
}
}
void Response::JsonSerializer::serializeEscapedString(std::ostream& os, std::string_view str)
{
os << '\"';
StringUtils::writeJSEscapedString(os, str);
os << '\"';
}
void Response::writeJSON(std::ostream& os)
{
JsonSerializer serializer;
serializer.serializeNode(os, _root);
}
} // namespace
src/libs/subsonic/impl/SubsonicResponse.hpp
+42 -20
View File
@@ -191,17 +191,30 @@ namespace API::Subsonic
class Node
{
public:
void setAttribute(std::string_view key, std::string_view value);
class Key
{
public:
template<std::size_t N>
constexpr Key(const char (&str)[N]) : _str{ str } {}
constexpr std::string_view get() const { return _str; }
bool constexpr operator<(const Key& other) const { return _str < other._str; }
private:
const std::string_view _str;
};
void setAttribute(Key key, std::string_view value);
template <typename T, std::enable_if_t<std::is_arithmetic<T>::value>* = nullptr>
void setAttribute(std::string_view key, T value)
void setAttribute(Key key, T value)
{
if constexpr (std::is_same<bool, T>::value)
_attributes[std::string{ key }] = value;
_attributes[key] = value;
else if constexpr (std::is_floating_point<T>::value)
_attributes[std::string{ key }] = static_cast<float>(value);
_attributes[key] = static_cast<float>(value);
else if constexpr (std::is_integral<T>::value)
_attributes[std::string{ key }] = static_cast<long long>(value);
_attributes[key] = static_cast<long long>(value);
else
static_assert("Unhandled type");
}
@@ -209,28 +222,28 @@ namespace API::Subsonic
// A Node has either a single value or an array of values or some children
void setValue(std::string_view value);
void setValue(long long value);
Node& createChild(const std::string& key);
Node& createArrayChild(const std::string& key);
Node& createChild(Key key);
Node& createArrayChild(Key key);
void addChild(const std::string& key, Node node);
void createEmptyArrayChild(std::string_view key);
void addArrayChild(std::string_view key, Node node);
void createEmptyArrayValue(std::string_view key);
void addArrayValue(std::string_view key, std::string_view value);
void addArrayValue(std::string_view key, long long value);
void addChild(Key key, Node node);
void createEmptyArrayChild(Key key);
void addArrayChild(Key key, Node node);
void createEmptyArrayValue(Key key);
void addArrayValue(Key key, std::string_view value);
void addArrayValue(Key key, long long value);
private:
void setVersionAttribute(ProtocolVersion version);
friend class Response;
using ValueType = std::variant<std::string, bool, float, long long>;
std::map<std::string, ValueType> _attributes;
std::map<Key, ValueType> _attributes;
std::optional<ValueType> _value;
std::map<std::string, std::vector<Node>> _children;
std::map<std::string, std::vector<Node>> _childrenArrays;
std::map<Key, Node> _children;
std::map<Key, std::vector<Node>> _childrenArrays;
using ValuesType = std::vector<ValueType>;
std::map<std::string, ValuesType> _childrenValues;
std::map<Key, ValuesType> _childrenValues;
};
static Response createOkResponse(ProtocolVersion protocolVersion);
@@ -242,14 +255,23 @@ namespace API::Subsonic
Response(Response&&) = default;
Response& operator=(Response&&) = default;
void addNode(const std::string& key, Node node);
Node& createNode(const std::string& key);
Node& createArrayNode(const std::string& key);
void addNode(Node::Key key, Node node);
Node& createNode(Node::Key key);
Node& createArrayNode(Node::Key key);
void write(std::ostream& os, ResponseFormat format);
private:
static Response createResponseCommon(ProtocolVersion protocolVersion, const Error* error = nullptr);
class JsonSerializer
{
public:
void serializeNode(std::ostream& os, const Node& node);
void serializeValue(std::ostream& os, const Node::ValueType& node);
void serializeEscapedString(std::ostream&, std::string_view str);
};
void writeJSON(std::ostream& os);
void writeXML(std::ostream& os);
src/libs/subsonic/impl/entrypoints/AlbumSongLists.cpp
+2 -2
View File
@@ -133,7 +133,7 @@ namespace API::Subsonic
throw NotImplementedGenericError{};
Response response{ Response::createOkResponse(context.serverProtocolVersion) };
Response::Node& albumListNode{ response.createNode(id3 ? "albumList2" : "albumList") };
Response::Node& albumListNode{ response.createNode(id3 ? Response::Node::Key{ "albumList2" } : Response::Node::Key{ "albumList" }) };
for (const ReleaseId releaseId : releases.results)
{
@@ -153,7 +153,7 @@ namespace API::Subsonic
throw UserNotAuthorizedError{};
Response response{ Response::createOkResponse(context.serverProtocolVersion) };
Response::Node& starredNode{ response.createNode(id3 ? "starred2" : "starred") };
Response::Node& starredNode{ response.createNode(id3 ? Response::Node::Key{ "starred2" } : Response::Node::Key{ "starred" }) };
Scrobbling::IScrobblingService& scrobbling{ *Service<Scrobbling::IScrobblingService>::get() };
src/libs/subsonic/impl/entrypoints/Browsing.cpp
+2 -2
View File
@@ -54,7 +54,7 @@ namespace API::Subsonic
std::size_t count{ getParameterAs<std::size_t>(context.parameters, "count").value_or(20) };
Response response{ Response::createOkResponse(context.serverProtocolVersion) };
Response::Node& artistInfoNode{ response.createNode(id3 ? "artistInfo2" : "artistInfo") };
Response::Node& artistInfoNode{ response.createNode(id3 ? Response::Node::Key{ "artistInfo2" } : Response::Node::Key{ "artistInfo" }) };
{
auto transaction{ context.dbSession.createSharedTransaction() };
@@ -236,7 +236,7 @@ namespace API::Subsonic
throw UserNotAuthorizedError{};
Response response{ Response::createOkResponse(context.serverProtocolVersion) };
Response::Node& similarSongsNode{ response.createNode(id3 ? "similarSongs2" : "similarSongs") };
Response::Node& similarSongsNode{ response.createNode(id3 ? Response::Node::Key{ "similarSongs2" } : Response::Node::Key{ "similarSongs" }) };
for (const TrackId trackId : tracks)
{
const Track::pointer track{ Track::find(context.dbSession, trackId) };
src/libs/subsonic/impl/entrypoints/MediaLibraryScanning.cpp
+1 -2
View File
@@ -28,8 +28,7 @@ namespace API::Subsonic::Scan
namespace
{
Response::Node
createStatusResponseNode()
Response::Node createStatusResponseNode()
{
Response::Node statusResponse;
src/libs/subsonic/impl/responses/Album.cpp
+3 -3
View File
@@ -114,7 +114,7 @@ namespace API::Subsonic
if (artists.size() == 1)
{
albumNode.setAttribute(id3 ? "artistId" : "parent", idToString(artists.front()->getId()));
albumNode.setAttribute(id3 ? Response::Node::Key{ "artistId" } : Response::Node::Key{ "parent" }, idToString(artists.front()->getId()));
}
else
{
@@ -140,7 +140,7 @@ namespace API::Subsonic
{
const Wt::WDateTime dateTime{ Service<Scrobbling::IScrobblingService>::get()->getLastListenDateTime(user->getId(), release->getId()) };
albumNode.setAttribute("played", dateTime.isValid() ? StringUtils::toISO8601String(dateTime) : "");
albumNode.setAttribute("played", dateTime.isValid() ? StringUtils::toISO8601String(dateTime) : std::string{ "" });
}
{
@@ -148,7 +148,7 @@ namespace API::Subsonic
albumNode.setAttribute("musicBrainzId", mbid ? mbid->getAsString() : "");
}
auto addClusters{ [&](std::string_view field, std::string_view clusterTypeName)
auto addClusters{ [&](Response::Node::Key field, std::string_view clusterTypeName)
{
albumNode.createEmptyArrayValue(field);
src/libs/subsonic/impl/responses/Song.cpp
+2 -2
View File
@@ -186,7 +186,7 @@ namespace API::Subsonic
}
}
auto addArtistLinks{ [&](std::string_view nodeName, TrackArtistLinkType type)
auto addArtistLinks{ [&](Response::Node::Key nodeName, TrackArtistLinkType type)
{
trackResponse.createEmptyArrayChild(nodeName);
@@ -209,7 +209,7 @@ namespace API::Subsonic
if (release)
trackResponse.setAttribute("displayAlbumArtist", release->getArtistDisplayName());
auto addClusters{ [&](std::string_view field, std::string_view clusterTypeName)
auto addClusters{ [&](Response::Node::Key field, std::string_view clusterTypeName)
{
trackResponse.createEmptyArrayValue(field);
src/libs/utils/impl/StreamLogger.cpp
+6 -5
View File
@@ -17,18 +17,19 @@
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include <thread>
#include "utils/StreamLogger.hpp"
StreamLogger::StreamLogger(std::ostream& os, EnumSet<Severity> severities)
: _os {os}
, _severities {severities}
: _os{ os }
, _severities{ severities }
{
}
void
StreamLogger::processLog(const Log& log)
void StreamLogger::processLog(const Log& log)
{
if (_severities.contains(log.getSeverity()))
_os << "[" << getSeverityName(log.getSeverity()) << "] [" << getModuleName(log.getModule()) << "] " << log.getMessage() << std::endl;
_os << std::this_thread::get_id() << " [" << getSeverityName(log.getSeverity()) << "] [" << getModuleName(log.getModule()) << "] " << log.getMessage() << std::endl;
}
src/libs/utils/impl/String.cpp
+23 -1
View File
@@ -219,7 +219,7 @@ namespace StringUtils
return res;
}
std::string jsEscape(const std::string& str)
std::string jsEscape(std::string_view str)
{
static const std::unordered_map<char, std::string_view> escapeMap
{
@@ -249,6 +249,28 @@ namespace StringUtils
return escaped;
}
void writeJSEscapedString(std::ostream& os, std::string_view str)
{
static constexpr std::pair<char, std::string_view> charsToEscape[]
{
{'\\', "\\\\" },
{ '\n', "\\n" },
{ '\r', "\\r" },
{ '\t', "\\t" },
{ '"', "\\\"" },
{ '\'', "\\\'" },
};
for (const char c : str)
{
auto itEntry{ std::find_if(std::cbegin(charsToEscape), std::cend(charsToEscape), [=](const auto& entry) { return entry.first == c;}) };
if (itEntry != std::cend(charsToEscape))
os << itEntry->second;
else
os << c;
}
}
std::string escapeString(std::string_view str, std::string_view charsToEscape, char escapeChar)
{
std::string res;
src/libs/utils/impl/WtLogger.cpp
+14 -3
View File
@@ -19,14 +19,25 @@
#include "utils/WtLogger.hpp"
#include <thread>
#include <sstream>
#include <Wt/WApplication.h>
#include <Wt/WLogger.h>
#include "utils/Logger.hpp"
void
WtLogger::processLog(const Log& log)
namespace
{
Wt::log(getSeverityName(log.getSeverity())) << Wt::WLogger::sep << "[" << getModuleName(log.getModule()) << "]" << Wt::WLogger::sep << log.getMessage();
std::string to_string(std::thread::id id)
{
std::ostringstream oss;
oss << id;
return oss.str();
}
}
void WtLogger::processLog(const Log& log)
{
Wt::log(getSeverityName(log.getSeverity())) << Wt::WLogger::sep << to_string(std::this_thread::get_id()) << Wt::WLogger::sep << "[" << getModuleName(log.getModule()) << "]" << Wt::WLogger::sep << log.getMessage();
}
src/libs/utils/include/utils/Logger.hpp
+9 -7
View File
@@ -61,7 +61,7 @@ const char* getSeverityName(Severity sev);
class Logger;
class Log
{
public:
public:
Log(Logger* logger, Module module, Severity severity);
~Log();
@@ -71,20 +71,22 @@ class Log
std::ostringstream& getOstream() { return _oss; }
private:
private:
Log(const Log&) = delete;
Log& operator=(const Log&) = delete;
Module _module;
Severity _severity;
std::ostringstream _oss;
Logger* _logger {};
Logger* _logger{};
};
class Logger
{
public:
public:
virtual ~Logger() = default;
virtual void processLog(const Log& log) = 0;
};
#define LMS_LOG(module, severity) Log(Service<Logger>::get(), Module::module, Severity::severity).getOstream()
#define LMS_LOG_EX(module, severity) Log(Service<Logger>::get(), module, severity).getOstream()
#define LMS_LOG(module, severity) Log{Service<Logger>::get(), Module::module, Severity::severity}.getOstream()
#define LMS_LOG_EX(module, severity) Log{Service<Logger>::get(), module, severity}.getOstream()
src/libs/utils/include/utils/String.hpp
+2 -1
View File
@@ -83,7 +83,8 @@ namespace StringUtils {
[[nodiscard]] std::string replaceInString(std::string_view str, const std::string& from, const std::string& to);
[[nodiscard]] std::string jsEscape(const std::string& str);
[[nodiscard]] std::string jsEscape(std::string_view str);
void writeJSEscapedString(std::ostream& os, std::string_view str);
[[nodiscard]] std::string escapeString(std::string_view str, std::string_view charsToEscape, char escapeChar);